Changeset 150

Timestamp:

08/25/06 15:30:34 (7 years ago)

Author:

mk

Message:

Merging mk branch into the trunk.

Files:

• trunk/AUTHORS (copied) (copied from branches/mk/AUTHORS)
• trunk/CHANGES (copied) (copied from branches/mk/CHANGES)
• trunk/INSTALL (copied) (copied from branches/mk/INSTALL)
• trunk/README (modified) (6 diffs)
• trunk/README.html (deleted)
• trunk/THANKS (copied) (copied from branches/mk/THANKS)
• trunk/__init__.py (deleted)
• trunk/cheesecake/__init__.py (modified) (1 diff)
• trunk/cheesecake/_util.py (deleted)
• trunk/cheesecake/ast_pp.py (copied) (copied from branches/mk/cheesecake/ast_pp.py)
• trunk/cheesecake/cheesecake_index.py (modified) (9 diffs)
• trunk/cheesecake/codeparser.py (modified) (7 diffs)
• trunk/cheesecake/config.py (deleted)
• trunk/cheesecake/model.py (modified) (14 diffs)
• trunk/cheesecake/subprocess.py (modified) (3 diffs)
• trunk/cheesecake/util.py (copied) (copied from branches/mk/cheesecake/util.py)
• trunk/docs (deleted)
• trunk/setup.py (modified) (2 diffs)
• trunk/support (copied) (copied from branches/mk/support)
• trunk/tests/_path_cheesecake.py (deleted)
• trunk/tests/data/import_self.py (copied) (copied from branches/mk/tests/data/import_self.py)
• trunk/tests/data/module1.py (modified) (5 diffs)
• trunk/tests/data/module1.tar.gz (copied) (copied from branches/mk/tests/data/module1.tar.gz)
• trunk/tests/data/package2.tar.gz (copied) (copied from branches/mk/tests/data/package2.tar.gz)
• trunk/tests/data/required.tar.gz (copied) (copied from branches/mk/tests/data/required.tar.gz)
• trunk/tests/data/static.tar.gz (copied) (copied from branches/mk/tests/data/static.tar.gz)
• trunk/tests/functional (copied) (copied from branches/mk/tests/functional)
• trunk/tests/test_code_parser.py (deleted)
• trunk/tests/test_config.py (deleted)
• trunk/tests/test_index_docstrings.py (deleted)
• trunk/tests/test_index_install.py (deleted)
• trunk/tests/test_index_installability.py (deleted)
• trunk/tests/test_index_unpack.py (deleted)
• trunk/tests/test_index_unpack_dir.py (deleted)
• trunk/tests/test_index_url_download.py (deleted)
• trunk/tests/test_init_cleanup.py (deleted)
• trunk/tests/unit (copied) (copied from branches/mk/tests/unit)

trunk/README

@@ -12 +12 @@
-
- * whether the package can be downloaded from PyPI given its name
- * whether the package can be downloaded from a full URL
- * whether the package can be unpacked
- * whether the unpack directory is the same as the package name
- * whether the package can be installed into an alternate directory
- * existence of certain files such as README, INSTALL, LICENSE, setup.py etc.
- * existence of certain directories such as doc, test, demo, examples
- * percentage of modules/functions/classes/methods with docstrings
-
-
-
+
+
-
-Currently, the Cheesecake index is computed for invidual packages obtained 
@@ -74 +70 @@
-
-If the package can be successfully downloaded and unpacked, a log file is
-andbox
-cheesecake_sandbox/
-not 
-since its purpose is to be inspected for debug information
+ystem /tmp
+
+
+except for situations when errors have occured
-
-Command-line examples:
@@ -98 +94 @@
-    For more options, run cheesecake.py with -h or --help.
-
+Requirements
+------------
+
+* `pylint <http://www.logilab.org/projects/pylint>`_ is required for
+  part of the code kwalitee index computation 
+* `setuptools <http://peak.telecommunity.com/DevCenter/setuptools>`_ is
+  required for the installability index computation
+
-Obtaining the source code
--------------------------
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-License
@@ -120 +184 @@
-http://www.opensource.org/licenses/PythonSoftFoundation.php.
-
-
-
+s
+-
-
-Grig Gheorghiu
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-
-Algorithm for computing the Cheesecake index
---------------------------------------------
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-Sample output
@@ -325 +266 @@
-::
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-Future plans
-------------
@@ -377 +308 @@
-index measurement, followed by other metrics inspired from the 
-`kwalitee indicators <http://cpants.dev.zsi.at/kwalitee.html>`_. 
-tracos.org/cheesecake
+pycheesecake.org
-Wiki page to add things that you would like to see covered 
-by the Cheesecake metrics.
-
-
-
-
-
+

trunk/cheesecake/__init__.py

@@ +1 @@
+__version__ = '0.6'

trunk/cheesecake/cheesecake_index.py

@@ -1 +1 @@
-#!/usr/bin/env python
+"""Cheesecake: How tasty is your code?
+
+The idea of the Cheesecake project is to rank Python packages based on various 
+empirical "kwalitee" factors, such as:
+
+ * whether the package can be downloaded from PyPI given its name
+ * whether the package can be unpacked
+ * whether the package can be installed into an alternate directory
+ * existence of certain files such as README, INSTALL, LICENSE, setup.py etc.
+ * percentage of modules/functions/classes/methods with docstrings
+ * ... and many others
-"""
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
-from optparse import OptionParser
-from urllib import urlretrieve
@@ -25 +24 @@
-from math import ceil
-
-from _util import run_cmd, pad_with_dots, pad_left_spaces, pad_msg, pad_line
-from _util import StdoutRedirector
-import logger
-
+
+
+
+
+
+
+
-from codeparser import CodeParser
+from cheesecake import __version__ as VERSION
+
+__docformat__ = 'reStructuredText en'
+
+
+################################################################################
+## Helpers.
+################################################################################
+
+if 'sorted' not in dir(__builtins__):
+    def sorted(L):
+        new_list = L[:]
+        new_list.sort()
+        return new_list
+
+if 'set' not in dir(__builtins__):
+    from sets import Set as set
+
+def isiterable(obj):
+    """Check whether object is iterable.
+
+    >>> isiterable([1,2,3])
+    True
+    >>> isiterable("string")
+    True
+    >>> isiterable(object)
+    False
+    """
+    return hasattr(obj, '__iter__') or isinstance(obj, basestring)
+
+def has_extension(filename, ext):
+    """Check if filename has given extension.
+
+    >>> has_extension("foobar.py", ".py")
+    True
+    >>> has_extension("foo.bar.py", ".py")
+    True
+    >>> has_extension("foobar.pyc", ".py")
+    False
+
+    This function is case insensitive.
+        >>> has_extension("FOOBAR.PY", ".py")
+        True
+    """
+    return os.path.splitext(filename.lower())[1] == ext.lower()
+
+def discover_file_type(filename):
+    """Discover type of a file according to its name and its parent directory.
+
+    Currently supported file types:
+        * pyc
+        * pyo
+        * module: .py files of an application
+        * demo: .py files for documentation/demonstration purposes
+        * test: .py files used for testing
+        * special: .py file for special purposes
+
+    :Note: This function only check file's name, and doesn't touch the
+           filesystem. If you have to, check if file exists by yourself.
+
+    >>> discover_file_type('module.py')
+    'module'
+    >>> discover_file_type('./setup.py')
+    'special'
+    >>> discover_file_type('some/directory/junk.pyc')
+    'pyc'
+    >>> discover_file_type('examples/readme.txt')
+    >>> discover_file_type('examples/runthis.py')
+    'demo'
+    >>> discover_file_type('optimized.pyo')
+    'pyo'
+
+    >>> test_files = ['ut/test_this_and_that.py',
+    ...               'another_test.py',
+    ...               'TEST_MY_MODULE.PY']
+    >>> for filename in test_files:
+    ...     assert discover_file_type(filename) == 'test', filename
+
+    >>> discover_file_type('this_is_not_a_test_really.py')
+    'module'
+    """
+    dirs = filename.split(os.path.sep)
+    dirs, filename = dirs[:-1], dirs[-1]
+
+    if filename in ["setup.py", "ez_setup.py", "__pkginfo__.py"]:
+        return 'special'
+
+    if has_extension(filename, ".pyc"):
+        return 'pyc'
+    if has_extension(filename, ".pyo"):
+        return 'pyo'
+    if has_extension(filename, ".py"):
+        for dir in dirs:
+            if dir in ['test', 'tests']:
+                return 'test'
+            elif dir in ['doc', 'docs', 'demo', 'example', 'examples']:
+                return 'demo'
+
+        # Most test frameworks look for files starting with "test_".
+        # py.test also looks at files with trailing "_test".
+        if filename.lower().startswith('test_') or \
+               os.path.splitext(filename)[0].lower().endswith('_test'):
+            return 'test'
+
+        return 'module'
+
+def get_files_of_type(file_list, file_type):
+    """Return files from `file_list` that match given `file_type`.
+
+    >>> file_list = ['test/test_foo.py', 'setup.py', 'README', 'test/test_bar.py']
+    >>> get_files_of_type(file_list, 'test')
+    ['test/test_foo.py', 'test/test_bar.py']
+    """
+    return filter(lambda x: discover_file_type(x) == file_type, file_list)
+
+def get_package_name_from_path(path):
+    """Get package name as file portion of path.
+
+    >>> get_package_name_from_path('/some/random/path/package.tar.gz')
+    'package.tar.gz'
+    >>> get_package_name_from_path('/path/underscored_name.zip')
+    'underscored_name.zip'
+    >>> get_package_name_from_path('/path/unknown.extension.txt')
+    'unknown.extension.txt'
+    """
+    dir, filename = os.path.split(path)
+    return filename
+
+def get_package_name_from_url(url):
+    """Use ``urlparse`` to obtain package name from URL.
+
+    >>> get_package_name_from_url('http://www.example.com/file.tar.bz2')
+    'file.tar.bz2'
+    >>> get_package_name_from_url('https://www.example.com/some/dir/file.txt')
+    'file.txt'
+    """
+    (scheme,location,path,param,query,fragment_id) = urlparse(url)
+    return get_package_name_from_path(path)
+
+def get_package_name_and_type(package, known_extensions):
+    """Return package name and type.
+
+    Package type must exists in known_extensions list. Otherwise None is
+    returned.
+
+    >>> extensions = ['tar.gz', 'zip']
+    >>> get_package_name_and_type('underscored_name.zip', extensions)
+    ('underscored_name', 'zip')
+    >>> get_package_name_and_type('unknown.extension.txt', extensions)
+    """
+    for package_type in known_extensions:
+        if package.endswith('.'+package_type):
+            # Package name is name of package without file extension (ex. twill-7.3).
+            return package[:package.rfind('.'+package_type)], package_type
+
+def get_method_arguments(method):
+    """Return tuple of arguments for given method, excluding self.
+
+    >>> class Class:
+    ...     def method(s, arg1, arg2, other_arg):
+    ...         pass
+    >>> get_method_arguments(Class.method)
+    ('arg1', 'arg2', 'other_arg')
+    """
+    return method.func_code.co_varnames[1:method.func_code.co_argcount]
+
+def get_attributes(obj, names):
+    """Return attributes dictionary with keys from `names`.
+
+    Object is queried for each attribute name, if it doesn't have this
+    attribute, default value None will be returned.
+
+    >>> class Class:
+    ...     pass
+    >>> obj = Class()
+    >>> obj.attr = True
+    >>> obj.value = 13
+    >>> obj.string = "Hello"
+
+    >>> d = get_attributes(obj, ['attr', 'string', 'other'])
+    >>> d == {'attr': True, 'string': "Hello", 'other': None}
+    True
+    """
+    attrs = {}
+
+    for name in names:
+        attrs[name] = getattr(obj, name, None)
+
+    return attrs
+
+def camel2underscore(name):
+    """Convert name from CamelCase to underscore_name.
+
+    >>> camel2underscore('CamelCase')
+    'camel_case'
+    >>> camel2underscore('already_underscore_name')
+    'already_underscore_name'
+    >>> camel2underscore('BigHTMLClass')
+    'big_html_class'
+    >>> camel2underscore('')
+    ''
+    """
+    if name and name[0].upper:
+        name = name[0].lower() + name[1:]
+
+    def capitalize(match):
+        string = match.group(1).lower().capitalize()
+        return string[:-1] + string[-1].upper()
+
+    def underscore(match):
+        return '_' + match.group(1).lower()
+
+    name = re.sub(r'([A-Z]+)', capitalize, name)
+    return re.sub(r'([A-Z])', underscore, name)
+
+def index_class_to_name(clsname):
+    """Covert index class name to index name.
+
+    >>> index_class_to_name("IndexDownload")
+    'download'
+    >>> index_class_to_name("IndexUnitTests")
+    'unit_tests'
+    >>> index_class_to_name("IndexPyPIDownload")
+    'py_pi_download'
+    """
+    return camel2underscore(clsname.replace('Index', '', 1))
+
+def is_empty(path):
+    """Returns True if file or directory pointed by `path` is empty.
+    """
+    if os.path.isfile(path) and os.path.getsize(path) == 0:
+        return True
+    if os.path.isdir(path) and os.listdir(path) == []:
+        return True
+
+    return False
+
+def strip_dir_part(path, root):
+    """Strip `root` part from `path`.
+
+    >>> strip_dir_part('/home/ruby/file', '/home')
+    'ruby/file'
+    >>> strip_dir_part('/home/ruby/file', '/home/')
+    'ruby/file'
+    >>> strip_dir_part('/home/ruby/', '/home')
+    'ruby/'
+    >>> strip_dir_part('/home/ruby/', '/home/')
+    'ruby/'
+    """
+    path = path.replace(root, '', 1)
+
+    if path.startswith(os.path.sep):
+        path = path[1:]
+
+    return path
+
+def get_files_dirs_list(root):
+    """Return list of all files and directories below `root`.
+
+    Root directory is excluded from files/directories paths.
+    """
+    files = []
+    directories = []
+
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirpath = strip_dir_part(dirpath, root)
+        files.extend(map(lambda x: os.path.join(dirpath, x), filenames))
+        directories.extend(map(lambda x: os.path.join(dirpath, x), dirnames))
+
+    return files, directories
+
+def length(L):
+    """Overall length of all strings in list.
+
+    >>> length(['a', 'bc', 'd', '', 'efg'])
+    7
+    """
+    return sum(map(lambda x: len(x), L))
+
+def generate_arguments(arguments, max_length):
+    """Pass list of strings in chunks of size not greater than max_length.
+
+    >>> for x in generate_arguments(['abc', 'def'], 4):
+    ...     print x
+    ['abc']
+    ['def']
+
+    >>> for x in generate_arguments(['a', 'bc', 'd', 'e', 'f'], 2):
+    ...     print x
+    ['a']
+    ['bc']
+    ['d', 'e']
+    ['f']
+
+    If a single argument is larger than max_length, ValueError is raised.
+        >>> L = []
+        >>> for x in generate_arguments(['abc', 'de', 'fghijk', 'l'], 4):
+        ...     L.append(x)
+        Traceback (most recent call last):
+          ...
+        ValueError: Argument 'fghijk' larger than 4.
+        >>> L
+        [['abc'], ['de']]
+    """
+    L = []
+    i = 0
+
+    # We have to look ahead, so C-style loop here.
+    while arguments:
+        if L == [] and len(arguments[i]) > max_length:
+            raise ValueError("Argument '%s' larger than %d." % (arguments[i], max_length))
+
+        L.append(arguments[i])
+
+        # End of arguments: yield then terminate.
+        if i == len(arguments) - 1:
+            yield L
+            break
+
+        # Adding next argument would exceed max_length, so yield now.
+        if length(L) + len(arguments[i+1]) > max_length:
+            yield L
+            L = []
+
+        i += 1
+
+################################################################################
+## Main index class.
+################################################################################
+
+class NameSetter(type):
+    def __init__(cls, name, bases, dict):
+        if 'name' not in dict:
+            setattr(cls, 'name', name)
+
+        if 'compute_with' in dict:
+            orig_compute_with = cls.compute_with
+
+            def _timed_compute_with(self, cheesecake):
+                (ret, self.time_taken) = time_function(lambda: orig_compute_with(self, cheesecake))
+                self.cheesecake.log.debug("Index %s computed in %.2f seconds." % (self.name, self.time_taken))
+                return ret
+
+            setattr(cls, 'compute_with', _timed_compute_with)
+
+    def __repr__(cls):
+        return '<Index class: %s>' % cls.name
+
+def make_indices_dict(indices):
+    indices_dict = {}
+    for index in indices:
+        indices_dict[index.name] = index
+    return indices_dict
-
-class Index(object):
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    def print_info(self):
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-        else:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        value = 0
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-class CheesecakeError(Exception):
-
-
+
-    """
-    pass
-
+
+class CheesecakeIndex(Index):
+    name = "Cheesecake"
+    subindices = [
+        IndexInstallability,
+        IndexDocumentation,
+        IndexCodeKwalitee,
+    ]
+
+
+class Step(object):
+    """Single step during computation of package score.
+    """
+    def __init__(self, provides):
+        self.provides = provides
+
+    def decide(self, cheesecake):
+        """Decide if step should be run.
+
+        It checks if there's at least one index from current profile that need
+        variables provided by this step. Override this method for other behaviour.
+        """
+        for provide in self.provides:
+            if provide in cheesecake.index.requirements:
+                return True
+        return False
+
+class StepByVariable(Step):
+    """Step which is always run if given Cheesecake instance variable is true.
+    """
+    def __init__(self, variable_name, provides):
+        self.variable_name = variable_name
+        Step.__init__(self, provides)
+
+    def decide(self, cheesecake):
+        if getattr(cheesecake, self.variable_name, None):
+            return True
+
+        # Fallback to the default.
+        return Step.decide(self, cheesecake)
+
-class Cheesecake(object):
-
-
+
-
-    Generates "cheesecake index" that takes into account things like:
@@ -119 +1190 @@
-    """
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        """
-        self.name = name
-        self.url = url
-        self.package_path = path
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-        if not os.path.isdir(self.sandbox):
-            os.mkdir(self.sandbox)
+
-        self.verbose = verbose
-        self.quiet = quiet
-
-
+
+
+
+
-        self.sandbox_pkg_file = ""
-        self.sandbox_pkg_dir = ""
-        self.sandbox_install_dir = ""
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    def raise_exception(self, msg):
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-        """
-        if os.path.isfile(self.sandbox_pkg_file):
-            self.log("Removing file %s" % self.sandbox_pkg_file)
-            os.unlink(self.sandbox_pkg_file)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        else:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-
-        logger.setconsumer('logfile', open(str(self.logfile), 'w', buffering=1))
@@ -270 +1315 @@
-        logger.setconsumer('null', None)
-
-
-
-
-
-
-
-
-
+
+
-        self.log.debug = logger.MultipleProducer('cheesecake logfile')
-        self.log.warn = logger.MultipleProducer('cheesecake console')
-        self.log.error = logger.MultipleProducer('cheesecake console')
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    def get_pkg_from_pypi(self):
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        try:
-            self.log.info("Trying to download package %s from PyPI using setuptools utilities" % self.name)
-            from setuptools.package_index import PackageIndex
-            from pkg_resources import Requirement
-            from distutils import log
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-        except ImportError, e:
-Error: 
-nw
+
+wn
-            msg += "Example: python cheesecake.py --url=http://www.mems-exchange.org/software/durus/Durus-3.1.tar.gz"
-            self.raise_exception(msg)
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    def download_pkg(self):
-
-
+
-        """
-        #self.log("Downloading package %s from URL %s" % (self.package, self.url))
@@ -458 +1476 @@
-            self.raise_exception(str(e))
-        #self.log("Downloaded package %s to %s" % (self.package, downloaded_filename))
-
+
+
-            f = open(downloaded_filename)
-            if re.search("404 Not Found", "".join(f.readlines())):
@@ -464 +1483 @@
-                self.raise_exception("Got '404 Not Found' error while trying to download package ... exiting")
-            f.close()
-
-
-
-
+
+
+
+
+
-    def copy_pkg(self):
-
-
+
-        """
-        self.sandbox_pkg_file = os.path.join(self.sandbox, self.package)
@@ -478 +1497 @@
-        shutil.copyfile(self.package_path, self.sandbox_pkg_file)
-
+    steps['unpack_pkg'] = Step(['original_package_name',
+                                'sandbox_pkg_dir',
+                                'unpacked',
+                                'unpack_dir'])
-    def unpack_pkg(self):
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-        self.sandbox_pkg_dir = os.path.join(self.sandbox, self.package_name)
-        if os.path.isdir(self.sandbox_pkg_dir):
-            shutil.rmtree(self.sandbox_pkg_dir)
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-        if self.unpack_dir != self.package_name:
-details += " instead of the expected " +
+self.original_package_name =
-            self.package_name = self.unpack_dir
+
+    steps['walk_pkg'] = Step(['dirs_list',
+                              'docstring_cnt',
+                              'docformat_cnt',
+                              'doctests_count',
+                              'unittests_count',
+                              'files_list',
+                              'functions',
+                              'classes',
+                              'methods',
+                              'object_cnt',
+                              'package_dir'])
+    def walk_pkg(self):
+        """Get package files and directories.
+
+        New attributes:
+          dirs_list : list
+              List of directories package contains.
+          docstring_cnt : int
+              Number of docstrings found in all package objects.
+          docformat_cnt : int
+              Number of formatted docstrings found in all package objects.
+          doctests_count : int
+              Number of docstrings that include doctests.
+          unittests_count : int
+              Number of classes which inherit from unittest.TestCase.
+          files_list : list
+              List of files package contains.
+          functions : list
+              List of all functions defined in package sources.
+          classes : list
+              List of all classes defined in package sources.
+          methods : list
+              List of all methods defined in package sources.
+          object_cnt : int
+              Number of documentable objects found in all package modules.
+          package_dir : str
+              Path to project directory.
+        """
+        self.package_dir = os.path.join(self.sandbox, self.package_name)
+
+        self.files_list, self.dirs_list = get_files_dirs_list(self.package_dir)
+
+        self.object_cnt = 0
+        self.docstring_cnt = 0
+        self.docformat_cnt = 0
+        self.doctests_count = 0
+        self.functions = []
+        self.classes = []
+        self.methods = []
+        self.unittests_count = 0
+
+        # Parse all application files and count objects
+        # (modules/classes/functions) and their associated docstrings.
+        for py_file in get_files_of_type(self.files_list, 'module'):
+            pyfile = os.path.join(self.package_dir, py_file)
+            code = CodeParser(pyfile, self.log.debug)
+
+            self.object_cnt += code.object_count()
+            self.docstring_cnt += code.docstring_count()
+            self.docformat_cnt += code.formatted_docstrings_count
+            self.functions += code.functions
+            self.classes += code.classes
+            self.methods += code.methods
+            self.doctests_count += code.doctests_count
+            self.unittests_count += code.unittests_count
+
+        # Log a bit of debugging info.
+        self.log.debug("Found %d files: %s." % (len(self.files_list),
+                                                ', '.join(self.files_list)))
+        self.log.debug("Found %d directories: %s." % (len(self.dirs_list),
+                                                      ', '.join(self.dirs_list)))
+
+    steps['install_pkg'] = Step(['installed'])
+    def install_pkg(self):
+        """Verify that package can be installed in alternate directory.
+
+        New attributes:
+          installed : bool
+              Describes whenever package has been succefully installed.
+        """
+        self.sandbox_install_dir = os.path.join(self.sandbox, "tmp_install_%s" % self.package_name)
+
+        if self.package_type == 'egg':
+            # Create dummy Python directories.
+            mkdirs('%s/lib/python2.3/site-packages/' % self.sandbox_install_dir)
+            mkdirs('%s/lib/python2.4/site-packages/' % self.sandbox_install_dir)
+
+            environment = {'PYTHONPATH':
+                           '%(sandbox)s/lib/python2.3/site-packages/:'\
+                           '%(sandbox)s/lib/python2.4/site-packages/' % \
+                           {'sandbox': self.sandbox_install_dir},
+                           # Pass PATH to child process.
+                           'PATH': os.getenv('PATH')}
+            rc, output = run_cmd("easy_install --no-deps --prefix %s %s" % \
+                                 (self.sandbox_install_dir,
+                                  self.sandbox_pkg_file),
+                                 environment)
-        else:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        else:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        else:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-def process_cmdline_args():
-
-
+
-    """
-    parser = OptionParser()
+    parser.add_option("--keep-log", action="store_true", dest="keep_log",
+                      default=False, help="don't remove log file even if run was successful")
+    parser.add_option("--lite", action="store_true", dest="lite",
+                      default=False, help="don't run time-consuming tests (default=False)")
+    parser.add_option("-l", "--logfile", dest="logfile",
+                      default=None,
+                      help="file to log all cheesecake messages")
-    parser.add_option("-n", "--name", dest="name",
-                      default="", help="package name (will be retrieved via setuptools utilities, if present)")
+    parser.add_option("-p", "--path", dest="path",
+                      default="", help="path of tar.gz/zip package on local file system")
+    parser.add_option("-q", "--quiet", action="store_true", dest="quiet",
+                      default=False, help="only print Cheesecake index value (default=False)")
+    parser.add_option("-s", "--sandbox", dest="sandbox",
+                      default=None,
+                      help="directory where package will be unpacked "\
+                           "(default is to use random directory inside %s)" % tempfile.gettempdir())
+    parser.add_option("-t", "--static", action="store_true", dest="static",
+                      default=False, help="don't run any code from the package being tested (default=False)")
-    parser.add_option("-u", "--url", dest="url",
-                      default="", help="package URL")
-    parser.add_option("-p", "--path", dest="path",
-                      default="", help="package path on local file system")
-    parser.add_option("-s", "--sandbox", dest="sandbox",
-                      default="/tmp/cheesecake_sandbox", 
-                      help="directory where package will be unpacked (default=/tmp/cheesecake_sandbox)")
-    parser.add_option("-v", "--verbose", action="store_true", dest="verbose",
-                      default=False, help="verbose output (default=False)")
-q", "--quiet", action="store_true", dest="quiet
-only print Cheesecake index value (default=False)
+V", "--version", action="store_true", dest="version
+Output cheesecake version and exit
-
-    (options, args) = parser.parse_args()
@@ -976 +1717 @@
-
-def main():
-
-
+
-    """
-    options = process_cmdline_args()
+    keep_log = options.keep_log
+    lite = options.lite
+    logfile = options.logfile
-    name = options.name
+    path = options.path
+    quiet = options.quiet
+    sandbox = options.sandbox
+    static_only = options.static
-    url = options.url
-    path = options.path
-    sandbox = options.sandbox
-    verbose = options.verbose
-
+
+
+
+
+
-
-    if not name and not url and not path:
@@ -992 +1741 @@
-
-    try:
-
+
+
+
+
-        c.compute_cheesecake_index()
+        c.cleanup()
-    except CheesecakeError, e:
-        print str(e)

trunk/cheesecake/codeparser.py

@@ +1 @@
+import doctest
-import os
+import re
+
+import logger
-from model import System, Module, Class, Function, parseFile, processModuleAst
-
+
+# Python 2.3/2.4 compatibilty hacks.
+if getattr(doctest, 'DocTestParser', False):
+    # Python 2.4 have DocTestParser class.
+    get_doctests = doctest.DocTestParser().get_examples
+else:
+    # Python 2.3 have _extract_examples function.
+    get_doctests = doctest._extract_examples
+
+
+def compile_regex(pattern, user_map=None):
+    """Compile a regex pattern using default or user mapping.
+    """
+
+    # Handy regular expressions.
+    mapping = {'ALPHA': r'[-.,?!\w]', 'WORD': r'[-.,?!\s\w]',
+                       'START': r'(^|\s)', 'END': r'([.,?!\s]|$)'}
+
+    if user_map:
+        mapping = mapping.copy()
+        mapping.update(user_map)
+
+    def sub(text, mapping):
+        for From, To in mapping.iteritems():
+            text = text.replace(From, To)
+        return text
+
+    pattern = sub(pattern, mapping)
+
+    return re.compile(pattern, re.LOCALE | re.VERBOSE)
+
+def inline_markup(start, end=None, mapping=None):
+    if end is None:
+        end = start
+    return compile_regex(r'''(START  %(start)s  ALPHA  %(end)s  END) |
+           (START  %(start)s  ALPHA  WORD*  ALPHA  %(end)s  END)'''\
+                         % {'start': start, 'end': end}, mapping)
+
+def line_markup(start, end=None):
+    return inline_markup(start, end, mapping={'ALPHA': r'[-.,?!\s\w]',
+                                              'START': r'(\n|^)[\ \t]*',
+                                              'END': r''})
+
+supported_formats = {
+    # reST refrence: http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html
+    'reST': [
+        inline_markup(r'\*'), # emphasis
+        inline_markup(r'\*\*'), # strong
+        inline_markup(r'``'), # inline
+        inline_markup(r'\(', r'_\)', # hyperlink
+                      {'ALPHA': r'\w', 'WORD': r'[-.\w]'}),
+        inline_markup(r'\(`', r'`_\)'), # long hyperlink
+        line_markup(r':'), # field
+        line_markup(r'[*+-]', r''), # unordered list
+        line_markup(r'((\d+) | ([a-zA-Z]+) [.\)])', r''), # ordered list
+        line_markup(r'\(  ((\d+)  |  ([a-zA-Z]+))  \)', r''), # ordered list
+    ],
+
+    # epytext reference: http://epydoc.sourceforge.net/epytext.html
+    'epytext': [
+        re.compile(r'[BCEGILMSUX]\{.*\}'), # inline elements
+        line_markup(r'@[a-z]+([\ \t][a-zA-Z]+)?:', r''), # fields
+        line_markup(r'-', r''), # unordered list
+        line_markup(r'\d+(\.\d+)*', r''), # ordered list
+    ],
+
+    # javadoc reference: http://java.sun.com/j2se/1.4.2/docs/tooldocs/solaris/javadoc.html
+    'javadoc': [
+        re.compile(r'<[a-zA-z]+[^>]*>'), # HTML elements
+        line_markup(r'@[a-z][a-zA-Z]*\s', r''), # normal tags
+        re.compile(r'{@  ((docRoot) | (inheritDoc) | (link) | (linkplain) |'\
+                    ' (value))  [^}]*  }', re.VERBOSE), # special tags
+    ],
+}
+
+
+def use_format(text, format):
+    """Return True if text includes given documentation format
+    and False otherwise.
+
+    See supported_formats for list of known formats.
+    """
+    for pattern in supported_formats[format]:
+        if re.search(pattern, text):
+            return True
+
+    return False
+
+
-class CodeParser(object):
-
-
+
-
-    * Collects modules, classes, methods, functions and associated docstrings
@@ -10 +102 @@
-    """
-    def __init__(self, pyfile, log=None):
+        """Initialize Code Parser object.
+
+        :Parameters:
+          `pyfile` : str
+              Path to a Python module to parse.
+          `log` : logger.Producer instance
+              Logger to use during code parsing.
+        """
-        if log:
-            self.log = log.codeparser
-        else:
-            import logger
-            self.log = logger.default.codeparser
-        self.modules = []
@@ -20 +119 @@
-        self.method_func = []
-        self.functions = []
-
-
+
+
+
+
+
+
+
+
+
+
-        (path, filename) = os.path.split(pyfile)
-        (module, ext) = os.path.splitext(filename)
@@ -29 +136 @@
-        try:
-            processModuleAst(parseFile(pyfile), module, self.system)
-
+
+
-            return
-
@@ -35 +143 @@
-            fullname = obj.fullName()
-            if isinstance(obj, Module):
-obj.fullName()
+fullname
-            if isinstance(obj, Class):
-
+
+
+
-            if isinstance(obj, Function):
-                self.method_func.append(fullname)
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-        for method_or_func in self.method_func:
@@ -57 +179 @@
-        self.log("methods: " + ",".join(self.methods))
-        self.log("functions: " + ",".join(self.functions))
+        self.log("docstrings: %s" % self.docstrings_by_format)
+        self.log("number of doctests: %d" % self.doctests_count)
-
-    def object_count(self):
-
-
-
+Return number of objects found in this module.
+
+
-        * module
-        * classes
@@ -74 +198 @@
-
-    def docstring_count(self):
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-        """
-        return self.system.func_called.keys()
+
+    functions_called = property(_functions_called)

trunk/cheesecake/model.py

@@ -1 +1 @@
-"""
-
-
+
+
+
+
+
+
+
+
-"""
+
-
-from compiler import ast
@@ -11 +18 @@
-import sets
-
-import compiler
-from compiler.transformer import parse, parseFile
-from compiler.visitor import walk
+
+import ast_pp
+
+
+def get_call_name(node):
+    assert isinstance(node, ast.CallFunc)
+
+    def get_name(node):
+        if isinstance(node, ast.CallFunc):
+            return None
+        elif isinstance(node, ast.Name):
+            return node.name
+        elif isinstance(node, str):
+            return node
+        elif isinstance(node, tuple):
+            if len(node) == 1:
+                return node[0]
+            else:
+                return "%s.%s" % (get_name(node[:-1][0]), node[-1])
+        elif isinstance(node, ast.Getattr):
+            return get_name(node.asList())
+        else:
+            return None
+
+    return get_name(node.node)
+
+def get_function_calls(node, fc):
+    if not isinstance(node, ast.Node):
+        return 
+
+    for child in node.getChildren():
+        if isinstance(child, ast.CallFunc):
+            func_called = get_call_name(child)
+            if func_called:
+                fc[func_called] = 1
+
+        get_function_calls(child, fc)
+
-
-class Documentable(object):
@@ -44 +88 @@
-            return self.parent.name2fullname(name)
-
+    def resolveDottedName(self, dottedname, verbose=False):
+        parts = dottedname.split('.')
+        obj = self
+        system = self.system
+        while parts[0] not in obj._name2fullname:
+            obj = obj.parent
+            if obj is None:
+                if parts[0] in system.allobjects:
+                    obj = system.allobjects[parts[0]]
+                    break
+                for othersys in system.moresystems:
+                    if parts[0] in othersys.allobjects:
+                        obj = othersys.allobjects[parts[0]]
+                        break
+                else:
+                    if verbose:
+                        print "1 didn't find %r from %r"%(dottedname,
+                                                      self.fullName())
+                    return None
+                break
+        else:
+            fn = obj._name2fullname[parts[0]]
+            if fn in system.allobjects:
+                obj = system.allobjects[fn]
+            else:
+                if verbose:
+                    print "1.5 didn't find %r from %r"%(dottedname,
+                                                        self.fullName())
+                return None
+        for p in parts[1:]:
+            if p not in obj.contents:
+                if verbose:
+                    print "2 didn't find %r from %r"%(dottedname,
+                                                      self.fullName())
+                return None
+            obj = obj.contents[p]
+        if verbose:
+            print dottedname, '->', obj.fullName(), 'in', self.fullName()
+        return obj
+
+    def dottedNameToFullName(self, dottedname):
+        if '.' not in dottedname:
+            start, rest = dottedname, ''
+        else:
+            start, rest = dottedname.split('.', 1)
+            rest = '.' + rest
+        obj = self
+        while start not in obj._name2fullname:
+            obj = obj.parent
+            if obj is None:
+                return dottedname
+        return obj._name2fullname[start] + rest
+
+    def __getstate__(self):
+        # this is so very, very evil.
+        # see doc/extreme-pickling-pain.txt for more.
+        r = {}
+        for k, v in self.__dict__.iteritems():
+            if isinstance(v, Documentable):
+                r['$'+k] = v.fullName()
+            elif isinstance(v, list) and v:
+                for vv in v:
+                    if vv is not None and not isinstance(vv, Documentable):
+                        r[k] = v
+                        break
+                else:
+                    rr = []
+                    for vv in v:
+                        if vv is None:
+                            rr.append(vv)
+                        else:
+                            rr.append(vv.fullName())
+                    r['@'+k] = rr
+            elif isinstance(v, dict) and v:
+                for vv in v.itervalues():
+                    if not isinstance(vv, Documentable):
+                        r[k] = v
+                        break
+                else:
+                    rr = {}
+                    for kk, vv in v.iteritems():
+                        rr[kk] = vv.fullName()
+                    r['!'+k] = rr
+            else:
+                r[k] = v
+        return r
-
-class Package(Documentable):
+    kind = "Package"
-    def name2fullname(self, name):
-        raise NameError
-
+
-class Module(Documentable):
+    kind = "Module"
-    def name2fullname(self, name):
-        if name in self._name2fullname:
@@ -59 +192 @@
-            return name
-
+
-class Class(Documentable):
+    kind = "Class"
-    def setup(self):
-        super(Class, self).setup()
-        self.bases = []
-def __repr__(self):
-return "%s(%r, %r) # %r"%(self.__class__.__name__,
-                          self.name, self.shortdocstring(),
-
+    self.rawbases = []
+self.baseobjects = []
+self.subclasses = []
+
-
-class Function(Documentable):
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
@@ -77 +348 @@
-    Package = Package
-    Function = Function
+    ModuleVistor = ModuleVistor
-
-    def __init__(self):
@@ -85 +357 @@
-        self.rootobjects = []
-        self.warnings = {}
-dby:[imports
+r:[imported
-        # for import * statements
-        self.importstargraph = {}
-        self.func_called = {}
+        self.state = 'blank'
+        self.packages = []
+        self.moresystems = []
+        self.urlprefix = ''
-
-    def _push(self, cls, name, docstring):
@@ -128 +404 @@
-        The default is that the second definition "wins".
-        '''
+        i = 0
+        fn = obj.fullName()
+        while (fn + ' ' + str(i)) in self.allobjects:
+            i += 1
+        prev = self.allobjects[obj.fullName()]
+        prev.name = obj.name + ' ' + str(i)
+        self.allobjects[prev.fullName()] = prev
-        self.warning("duplicate", self.allobjects[obj.fullName()])
-        self.allobjects[obj.fullName()] = obj
@@ -204 +487 @@
-
-    def warning(self, type, detail):
-
-
+
+
+
+
-        self.warnings.setdefault(type, []).append((fn, detail))
-
@@ -212 +497 @@
-            if isinstance(o, cls):
-                yield o
+
+    def finalStateComputations(self):
+        self.recordBasesAndSubclasses()
+
+    def recordBasesAndSubclasses(self):
+        for cls in self.objectsOfType(Class):
+            for n in cls.bases:
+                o = cls.parent.resolveDottedName(n)
+                cls.baseobjects.append(o)
+                if o:
+                    o.subclasses.append(cls)
+
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        del state['moresystems']
+        return state
+
+    def __setstate__(self, state):
+        self.moresystems = []
+        # this is so very, very evil.
+        # see doc/extreme-pickling-pain.txt for more.
+        self.__dict__.update(state)
+        for obj in self.orderedallobjects:
+            for k, v in obj.__dict__.copy().iteritems():
+                if k.startswith('$'):
+                    del obj.__dict__[k]
+                    obj.__dict__[k[1:]] = self.allobjects[v]
+                elif k.startswith('@'):
+                    n = []
+                    for vv in v:
+                        if vv is None:
+                            n.append(None)
+                        else:
+                            n.append(self.allobjects[vv])
+                    del obj.__dict__[k]
+                    obj.__dict__[k[1:]] = n
+                elif k.startswith('!'):
+                    n = {}
+                    for kk, vv in v.iteritems():
+                        n[kk] = self.allobjects[vv]
+                    del obj.__dict__[k]
+                    obj.__dict__[k[1:]] = n
+
-
-def expandModname(system, modname, givewarning=True):
@@ -242 +570 @@
-            modname = expandModname(self.system, node.modname, False)
-            self.system.importstargraph.setdefault(
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-def processModuleAst(ast, name, system):
-
+system.
-    walk(ast, mv)
-    while mv.morenodes:
@@ -405 +584 @@
-def fromText(src, modname='<test>', system=None):
-    if system is None:
-
-
-
+
+
+
+
+
+
+
-
-
-def preprocessDirectory(system, dirpath):
-
+
+
+
+
+
-    for fname in os.listdir(dirpath):
-        fullname = os.path.join(dirpath, fname)
-
+ and fname != 'test'
-            preprocessDirectory(system, fullname)
-        elif fname.endswith('.py'):
@@ -422 +609 @@
-            mod.processed = False
-            system.popModule()
-
-
-
-
+
+
+
+
+
+
-    modlist = list(system.objectsOfType(Module))
-    for mod in modlist:
-        system.push(mod.parent)
-        isf = ImportStarFinder(system, mod.fullName())
-
+
+
+
+
+
-        system.pop(mod.parent)
-
-
-
+
+
+
+
+
+
+
-
-    for mod in newlist:
+        mod = system.allobjects[mod]
-        system.push(mod.parent)
-
+
+
+
+
+
-        mod.processed = True
-        system.pop(mod.parent)
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    if '-r' in argv:
-        argv.remove('-r')
-        assert len(argv) == 1
-System
+systemcls
-        processDirectory(system, argv[0])
-        pickle.dump(system, open('da.out', 'wb'), pickle.HIGHEST_PROTOCOL)
@@ -454 +683 @@
-            print k, len(v)
-    else:
-System
+systemcls
-        for fname in argv:
-            modname = os.path.splitext(os.path.basename(fname))[0] # XXX!
@@ -463 +692 @@
-
-if __name__ == '__main__':
-
+System, 

trunk/cheesecake/subprocess.py

@@ -394 +394 @@
-    import pickle
-
-
+, "ProcessError"
-
-try:
@@ -495 +495 @@
-    return ''.join(result)
-
+class ProcessError(Exception):
+    """This exception is raised when there is an error calling
+    a subprocess."""
+    pass
-
-class Popen(object):
@@ -984 +988 @@
-            if data != "":
-                child_exception = pickle.loads(data)
-
+ProcessError, 
-
-

trunk/setup.py

@@ -1 +1 @@
-#! /usr/bin/env python
-import sys
-.path
+
-
-from setuptools import setup
-from pkg_resources import require
+from cheesecake import __version__ as VERSION
+
+# Instruct nose to use doctests.
+os.environ['NOSE_WITH_DOCTEST'] = 'True'
+os.environ['NOSE_DOCTEST_TESTS'] = 'True'
+os.environ['NOSE_INCLUDE'] = 'unit'
+os.environ['NOSE_INCLUDE_EXE'] = 'True'
-
-setup(
-        name = 'Cheesecake',
-'0.1'
+VERSION
-
-        # metadata for upload to PyPI
-
-
+ and Michal Kwiatkowski
+ and ruby@joker.linuxstuff.pl
-        description = 'Computes "goodness" index for Python packages based on various empirical "kwalitee" factors',
-        license = "PSF",
-        keywords = "cheesecake quality index kwalitee cheeseshop pypi",
-tracos.org/cheesecake",  
+pycheesecake.org/",
-
-        packages = ['cheesecake',
@@ -22 +29 @@
-        scripts = ['cheesecake_index',
-                    ],
+        entry_points = {
+            'console_scripts': [
+                'cheesecake_index = cheesecake.cheesecake_index:main',
+            ]
+        },
-        test_suite = 'nose.collector',
-      
+

trunk/tests/data/module1.py

@@ -1 +1 @@
-"""
-Docstring for module1
+
+@summary: Code used inside test_code_parser.py unit test.
-"""
-
@@ -6 +8 @@
-    """
-    Docstring for Class1
+
+    @see how.Tests#are(performed)
-    """
-
-    def __init__(self):
-        """
-
+s
-        """
-        pass
@@ -36 +40 @@
-        pass
-
+    def method5(self):
+        """Method with few definitions.
+
+        :Word: And its definition.
+        """
+        pass
+
-class Class2:
-
@@ -42 +53 @@
-    """
-    pass
+
-
-def func1():
@@ -66 +78 @@
-    """
-    return
+
+def func6():
+    """
+    """
+    pass
+
+def func7():
+    "Time to get *a bit* of reST."
+    pass
+
+def func8(argument):
+    """This is test function for the epytext parser.
+
+    @param argument: And you really can't say if this is
+        epytext or javadoc! We count both.
+    """
+    pass
+
+
+class Class3(object):
+    """
+    New-style class with epytext link: U{http://pycheesecake.org}.
+    """
+    pass
+
+
+def outer_function(*args):
+    x = 42
+
+    def inner_function():
+        """Short docstring."""
+        pass
+
+    return x