[pygccxml-commit] SF.net SVN: pygccxml: [417] pydsc_dev

[<rom...@us...>]

Revision: 417
Author:   roman_yakovenko
Date:     2006-08-16 20:44:31 -0700 (Wed, 16 Aug 2006)
ViewCVS:  http://svn.sourceforge.net/pygccxml/?rev=417&view=rev

Log Message:
-----------
moving pydsc.py one directory up, for setup.py script

Added Paths:
-----------
    pydsc_dev/pydsc.py

Removed Paths:
-------------
    pydsc_dev/pydsc/
Copied: pydsc_dev/pydsc.py (from rev 415, pydsc_dev/pydsc/pydsc.py)
===================================================================
--- pydsc_dev/pydsc.py	                        (rev 0)
+++ pydsc_dev/pydsc.py	2006-08-17 03:44:31 UTC (rev 417)
@@ -0,0 +1,272 @@
+# Copyright 2004 Roman Yakovenko.
+# Distributed under the Boost Software License, Version 1.0. (See
+# accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+"""
+Python Documentation Spell Checker.
+
+The pydsc module contains functionality needed to check documentation strings
+and comments for spelling errors, within Python code. The pydsc module depends
+on PyEnchant spell checker. PyEnchant provides interface for different spell
+engines:
+    * ispell
+    * aspell
+    * OpenOffice
+
+The use of the pydsc module is very simple - just import pydsc and all modules
+that will be imported after it will be checked. By default all spelling errors
+will be printed to sys.stdout. The pydsc checker could be customized in many
+different ways:
+    * you can define set of files/directories that should be included/excluded
+      from check process
+    * you can redefine error messages destination
+    * you can redefine and/or re-configurate spell checker
+
+Install:
+python setup.py install
+
+Usage example:
+
+import pydsc
+import readline #errors will be printed to standart output
+
+more complex example ( taken from pygccxml project ):
+
+import pydsc
+#test only pygccxml
+#package_directory defined earlier
+pydsc.doc_checker.filter.append( package_directory )
+pydsc.doc_checker.filter_type = pydsc.FILTER_TYPE.INCLUDE
+#
+map( pydsc.doc_checker.speller.ignore_always
+     , [ 'org'
+         , 'http'
+         , 'bool'
+         , 'str'
+         , 'www'
+         , 'param'
+         , 'txt'
+         , 'decl'
+         , 'decls'
+         , 'namespace'
+         , 'enum'
+         , 'const'
+         , 'GCC'
+         , 'xcc'
+         , 'TODO'
+         , 'typedef'
+         , 'os'
+         , 'normcase'
+         , 'normpath' ] )
+
+"""
+
+__version__ = '0.1'
+__author__ = 'Roman Yakovenko <rom...@gm...>'
+__url__ = 'http://sourceforge.net/projects/pygccxml/'
+__license__ = 'Boost Software License <http://boost.org/more/license_info.html>'
+
+import os
+import sys
+import pprint
+import inspect
+import __builtin__
+from enchant import checker
+
+
+#TODO: source code encoding
+# -*- coding: encoding -*-
+# -*- coding: iso-8859-15 -*-
+
+def normalize_path( some_path ):
+    """return os.path.normcase( os.path.normpath( some_path ) )"""
+    return os.path.normcase( os.path.normpath( some_path ) )
+
+class filter_by_path_t:
+    class FILTER_TYPE:
+        """defines few filter constants"""
+        INCLUDE = 'include'
+        EXCLUDE = 'exclude'
+
+    def __init__( self, what, ftype ):
+        self.what = what
+        if None is self.what:
+            self.what = []
+        elif isinstance( self.what, str ):
+            self.what = [self.what]
+        self.what = map( normalize_path, self.what )
+        self.ftype = ftype
+
+    @staticmethod
+    def contains_parent_dir( path, dirs ):
+        """
+        returns true if one of the directories is root directory for the path,
+        false otherwise
+
+        @param path: path
+        @type path: str
+
+        @param dirs: list of directories and\\or files
+        @type dirs: [ str ]
+
+        @return: bool
+        """
+        #precondition: dirs and fpath should be normalize_path'ed before calling this function
+        return bool( filter( lambda dir: path.startswith( dir ), dirs ) )
+
+    def check( self, source_file ):
+        source_file = normalize_path( source_file )
+        if source_file in self.what or self.contains_parent_dir( source_file, self.what ):
+            return self.ftype == self.FILTER_TYPE.INCLUDE
+        else:
+            return self.ftype == self.FILTER_TYPE.EXCLUDE
+
+def exclude( what ):
+    return filter_by_path_t( what, filter_t.FILTER_TYPE.EXCLUDE )
+
+def include( what ):
+    return filter_by_path_t( what, filter_t.FILTER_TYPE.INCLUDE )
+
+
+class checker_t( object ):
+    """
+    applies spell check process on every imported module
+
+    This is the main class of this module. This class applies spell check
+    process on every imported module. Every documentation string within the
+    module will be checked. Some comments will be checked too. You should read
+    inspect module documentation, in order to find out which comments will be
+    checked.
+    """
+
+    def __init__( self
+                  , speller
+                  , writer=None
+                  , filter=None
+                  , ignore_identifiers=True ):
+        """
+        initialization method
+
+        During this method, reference to __builtin__.__import__ function is
+        saved in one of the members of the class, and replaced with import_
+        member function.
+
+        @param speller: reference to enchant.checker.SpellChecker object
+        @type speller: enchant.checker.SpellChecker
+
+        @param writer: reference to instance of class that has write method.
+                       By default sys.stdout will be used.
+
+        @param filter: list of files or directories
+        @type filter: [ str ]
+
+        @param filter_type: provides interpretation for content of filter parameter
+        @type filter_type: L{FILTER_TYPE}
+
+        @param ignore_identifiers: often comments/documentation strings contains
+                                   class\\method\\function names. Those names,
+                                   usually introduce spell error. If ignore_identifiers
+                                   set to True, those names will be ignored.
+        @type ignore_identifiers: bool
+        """
+        object.__init__( self )
+        self.__checked = set()
+        self.__orig_import = __builtin__.__import__
+        __builtin__.__import__ = self.import_
+        self.__already_imported = set( sys.modules.keys() )
+        self.__checked = set()
+        self.speller = speller
+        self.writer = writer
+        if self.writer is None:
+            self.writer = sys.stdout
+        self.filter = filter
+        self.identifiers = set()
+        self.ignore_identifiers = ignore_identifiers
+
+    def should_be_checked( self, obj, module=None ):
+        if id(obj) in self.__checked:
+            return False
+        if inspect.isbuiltin( obj ):
+            return False
+        if inspect.ismodule( obj ):
+            if obj.__name__ in self.__already_imported:
+                return False #do not check already imported modules
+            if self.filter:
+                try:
+                    source_file = inspect.getsourcefile(obj)
+                    if source_file is None:
+                        source_file = inspect.getfile( obj )
+                    return self.filter.check( source_file )
+                except TypeError:
+                    return False #built in module
+            else:
+                return True
+        obj_module = inspect.getmodule( obj )
+        if not obj_module is module:
+            return False
+        if inspect.isclass( obj ) \
+           or inspect.ismethod( obj ) \
+           or inspect.isfunction( obj ) \
+           or inspect.isroutine( obj ) \
+           or inspect.ismethoddescriptor( obj ) \
+           or inspect.isdatadescriptor( obj ):
+            return True
+        return False
+
+    def import_( self, name, globals=None, locals=None, fromlist=None ):
+        pymodule = self.__orig_import( name, globals, locals, fromlist )
+        if self.should_be_checked(pymodule):
+            #write = self.writer.write
+            #write( 'inspecting %s%s' % ( inspect.getsourcefile( pymodule ), os.linesep ) )
+            self.__already_imported.add( name )
+            self.check( pymodule )
+            #write( 'inspecting %s done%s' % ( inspect.getsourcefile( pymodule ), os.linesep ) )
+        return pymodule
+
+    def __check_text_impl( self, obj, text, text_type ):
+        if not text:
+            return
+        if self.ignore_identifiers and hasattr( obj, '__name__' ) and obj.__name__:
+            self.identifiers.add( obj.__name__ )
+        errors = {}
+        self.speller.set_text( text )
+        for error in self.speller:
+            if error.word in self.identifiers:
+                continue
+            if not errors.has_key( error.word ):
+                errors[ error.word ] = []
+            errors[ error.word ] = self.speller.suggest()
+        if not errors:
+            return
+        write = self.writer.write
+        if inspect.getsourcefile( inspect.getmodule( obj ) ):
+            write( '  error details: %s' % os.linesep )
+            write( '    file       : %s%s' % ( inspect.getsourcefile( inspect.getmodule( obj ) ), os.linesep ) )
+            write( '    line       : %d%s' % ( inspect.getsourcelines( obj )[1], os.linesep ) )
+            write( '    text type  : %s%s' % ( text_type, os.linesep ) )
+        else:
+            write( '  error details: %s' % os.linesep )
+            write( '    text type  : %s%s' % ( text_type, os.linesep ) )
+        for word, suggestions in errors.items():
+            write( '      misspelled word: %s%s' % ( word, os.linesep ) )
+            write( '        suggestions    : %s%s' % ( `suggestions`, os.linesep ) )
+
+    def check_text( self, obj):
+        self.__check_text_impl( obj, inspect.getdoc( obj ), 'documentation string' )
+        if inspect.getsourcefile( obj ):
+            self.__check_text_impl( obj, inspect.getcomments( obj ), 'comment' )
+
+    def check( self, module ):
+        self.check_text( module )
+        to_be_checked = map( lambda x: x[1], inspect.getmembers( module ) )
+        while to_be_checked:
+            member = to_be_checked.pop(0)
+            if not self.should_be_checked( member, module ):
+                continue
+            self.check_text( member )
+            to_be_checked.extend( map( lambda x: x[1], inspect.getmembers( member ) ) )
+            self.__checked.add( id(member) )
+
+"""documentation spell checker instance"""
+doc_checker = checker_t( checker.SpellChecker( "en_US" ) )


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.