Changeset 150

Timestamp:

08/25/06 15:30:34 (2 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):
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+