bee_python 0.0.1

data/lib/bee_task_python.rb

@@ -0,0 +1,390 @@
+require 'bee_task'
+require 'fileutils'
+
+module Bee
+  
+  module Task
+  
+    # Package for Python tasks.
+    class Python < Package
+    
+      # Compile Python source files, checking syntax and generating .pyc files.
+      # Parameter is a glob or list of globs for files to compile.
+      # 
+      # Example
+      # 
+      #  - python.compile: "**/*.py"
+      def compile(globs)
+        error "python.compile parameter is a String or Array of Strings" unless
+          globs.kind_of?(String) or globs.kind_of?(Array)
+        for glob in globs
+          error "python.compile parameter is a String or Array of Strings" unless
+            glob.kind_of?(String)
+          files = Dir.glob(glob)
+          size = (files.kind_of?(Array) ? files.size : 1)
+          puts "Compiling #{size} Python source file(s)" if files.length > 0
+          script = File.join(File.expand_path(File.dirname(__FILE__)),
+                             '..', 'tools', 'compile', 'compile.py')
+          for file in files
+            puts "Compiling Python source file '#{file}'" if
+              @build.listener.verbose
+            ok = system("python #{script} #{file}")
+            error "Error compiling Python source file '#{file}'" unless ok
+          end
+        end
+      end
+
+      # Run a given Python source file. Parameter is the source file to run.
+      # Source file must be an existing readable file.
+      #
+      # Example
+      #
+      #  - python.python: "my_script.py"
+      def python(source)
+        error "python.python parameter is a String" unless
+          source.kind_of?(String)
+        error "python.python parameter must be an existing file" unless
+          File.exists?(source) and File.readable?(source)
+        ok = system("python #{source}")
+        error "Error running Python source file '#{source}'" unless ok
+      end
+
+      # Check source files using Pychecker tool. You may find documentation
+      # about this tool at this URL: http://pychecker.sourceforge.net/.
+      #
+      # - src: directory or list of directories containing Python source
+      #   files to check.
+      # - options: custom options to use on command line (optional).
+      # - installed: ask to use Pychecker installed in Python VM. Optional,
+      #   defaults to false.
+      # - lenient: if set to true, doesn't interrupt the build on error.
+      #   Optional, defaults to false.
+      # - only: Tells if we must only check sources passed as parameters.
+      #   Optional, defaults to true.
+      #
+      # Example
+      #
+      #  - python.pychecker:
+      #      src:     ["lib", "test"]
+      #      options: "--keepgoing"
+      def pychecker(params)
+        # check parameters
+        params_desc = {
+          :src       => { :mandatory => true,  :type => :string_or_array },
+          :options   => { :mandatory => false, :type => :string },
+          :installed => { :mandatory => false, :type => :boolean,
+                          :default   => false },
+          :lenient   => { :mandatory => false, :type => :boolean,
+                          :default   => false },
+          :only      => { :mandatory => false, :type => :boolean,
+                          :default   => true }
+        }
+        check_parameters(params, params_desc)
+        src       = params[:src]
+        options   = params[:options]
+        installed = params[:installed]
+        lenient   = params[:lenient]
+        only      = params[:only]
+        # build the list of python source files
+        src = Array(src)
+        files = []
+        for dir in src
+          files += Dir.glob("#{dir}/**/*.py")
+        end
+        files.map! { |file| "\"#{file}\"" }
+        files.uniq!
+        # run pychecker command
+        puts "Checking #{files.length} Python source file(s)"
+        if installed
+          command = "pychecker"
+        else
+          pychecker = "#{File.dirname(__FILE__)}/../tools/pychecker"
+          command = "python #{pychecker}/checker.py"
+        end
+        command += " #{options}" if options
+        command += " --only" if only
+        command += " #{files.join(' ')}"
+        ok = system(command)
+        error "Error checking Python source files" unless ok or lenient
+      end
+
+      # Check source files using Pylint tool. You may find documentation
+      # about this tool at: http://www.logilab.org/card/pylint_tutorial.
+      #
+      # - src: directory or list of directories containing Python source
+      #   files to check.
+      # - files: a list of Python source files to check.
+      # - path: a list of additional directories to include in Python path.
+      #   Optional, defaults to no directory.
+      # - options: custom options to use on command line (optional).
+      # - installed: ask to use Pylint installed in Python VM. Optional,
+      #   defaults to false.
+      # - lenient: if set to true, doesn't interrupt the build on error.
+      #   Optional, defaults to false.
+      # - config: configuration file name. Optional.
+      #
+      # Example
+      #
+      #  - python.pylint:
+      #      src: "lib"
+      def pylint(params)
+        # check parameters
+        params_desc = {
+          :src       => { :mandatory => false, :type => :string_or_array },
+          :files     => { :mandatory => false, :type => :string_or_array },
+          :path      => { :mandatory => false, :type => :string_or_array },
+          :options   => { :mandatory => false, :type => :string },
+          :installed => { :mandatory => false, :type => :boolean,
+                          :default   => false },
+          :lenient   => { :mandatory => false, :type => :boolean,
+                          :default   => false },
+          :config    => { :mandatory => false, :type => :string_or_array },
+        }
+        check_parameters(params, params_desc)
+        src       = params[:src]
+        files     = params[:files]
+        path      = params[:path]
+        options   = params[:options]
+        installed = params[:installed]
+        lenient   = params[:lenient]
+        config    = params[:config]
+        # build the list of python source files
+        error "Must set at least one of 'src' or 'files' in python.pylint" if 
+            not src and not files
+        if files
+            files = Array(files)
+        else
+            files = []
+        end
+        if src
+            src = Array(src)
+            for dir in src
+                files += Dir.glob("#{dir}/**/*.py")
+            end
+        end
+        # build the list of source directory to include them in PYTHONPATH
+        dirs = []
+        for file in files
+            dir = File.expand_path(File.dirname(file))
+            dirs << dir if not dirs.include?(dir)
+        end
+        dirs += path if path
+        add_python_path(dirs)
+        files.map! { |file| "\"#{file}\"" }
+        files.uniq!
+        # run pylint command
+        puts "Checking #{files.length} Python source file(s)"
+        if installed
+          command = "pylint"
+        else
+          pylint = "#{File.dirname(__FILE__)}/../tools/pylint2/pylint.py"
+          command = "python #{pylint}"
+        end
+        command += " --rcfile=#{config}" if config
+        command += " #{options}" if options
+        command += " #{files.join(' ')}"
+        ok = system(command)
+        error "Error checking Python source files" unless ok or lenient
+      end
+
+      # Generate documentation using Epydoc tool.
+      #
+      # - src: directory or list of directories containing Python source
+      #   files to doc for.
+      # - dest: destination directory for generated documentation.
+      # - options: custom options to use on command line (optional).
+      # - installed: ask to use Pychecker installed in Python VM. Optional,
+      #   defaults to false.
+      #
+      # Example
+      #
+      #  - python.pychecker:
+      #      src:  ["lib", "test"]
+      #      dest: "build/doc"
+      def epydoc(params)
+        # check parameters
+        params_desc = {
+          :src       => { :mandatory => true,  :type => :string_or_array },
+          :dest      => { :mandatory => true,  :type => :string },
+          :options   => { :mandatory => false, :type => :string },
+          :installed => { :mandatory => false, :type => :boolean, :default => false }
+        }
+        check_parameters(params, params_desc)
+        src       = params[:src]
+        dest      = params[:dest]
+        options   = params[:options]
+        installed = params[:installed]
+        # build the list of python source files
+        src = Array(src)
+        files = []
+        for dir in src
+          files += Dir.glob("#{dir}/**/*.py")
+        end
+        files.map! { |file| "\"#{file}\"" }
+        files.uniq!
+        # make destination directory if it doesn't exist
+        FileUtils.makedirs(dest) if not File.exists?(dest)
+        error "epydoc 'dest' parameter must be a writable directory" unless
+          File.directory?(dest) and File.writable?(dest)
+        # run epydoc command
+        puts "Generating doc for #{files.length} Python source file(s)"
+        if installed
+          command = "epydoc"
+        else
+          epydoc = "#{File.dirname(__FILE__)}/../tools/epydoc"
+          add_python_path("#{epydoc}/..")
+          command = "python #{epydoc}/cli.py"
+        end
+        command += " -o #{dest}"
+        command += " #{options}" if options
+        command += " #{files.join(' ')}"
+        ok = system(command)
+        error "Error generating documentation for Python source files" unless
+          ok
+      end
+
+      # Run python test files. Parameter is a glob or list of globs for test
+      # files to run.
+      # 
+      # Example
+      # 
+      #  - python.test: "test/test_*.py"
+      def test(globs)
+        error "python.test parameter is a String or Array of Strings" unless
+          globs.kind_of?(String) or globs.kind_of?(Array)
+        for glob in globs
+          error "python.test parameter is a String or Array of Strings" unless
+            glob.kind_of?(String)
+          files = Dir.glob(glob)
+          files.map! {|f| File.expand_path(f)}
+          size = (files.kind_of?(Array) ? files.size : 1)
+          puts "Running #{size} Python test file(s)" if files.length > 0
+          script = File.join(File.expand_path(File.dirname(__FILE__)),
+                             '..', 'tools', 'test', 'suite.py')
+          command = "python #{script} #{files.join(' ')}"
+          ok = system(command)
+          error "Error running Python test(s)" unless ok
+        end
+      end
+
+      # Generate test coverage report.
+      #
+      # - src: directory or list of directories containing Python source
+      #   files to measure test coverage for.
+      # - test: glob or list of globs for tests to run while measuring
+      #   coverage.
+      # - dir: directory where to run unit tests. Optional, defaults to
+      #   current directory. 
+      # - dest: destination directory where to generate coverage report.
+      #   Optional, will print report on console if not set.
+      # - data: file where to write coverage data. Optional, defaults to
+      #   file .coverage in current directory.
+      # - path: a list of directories to add to Python path to run tests.
+      #
+      # Example
+      #
+      #  - python.coverage:
+      #      src:   "src"
+      #      test:  "test/suite.py"
+      #      dir:   "test"
+      #      dest:  "build/coverage"
+      #      data:  "build/.coverage"
+      #      path:  "lib"
+      def coverage(params)
+        # check parameters
+        params_desc = {
+          :src  => { :mandatory => true,  :type => :string_or_array },
+          :test => { :mandatory => true,  :type => :string_or_array },
+          :dir  => { :mandatory => true,  :type => :string },
+          :dest => { :mandatory => false, :type => :string },
+          :data => { :mandatory => false, :type => :string },
+          :path => { :mandatory => false, :type => :string_or_array },
+        }
+        check_parameters(params, params_desc)
+        src  = params[:src]
+        test = params[:test]
+        dir  = params[:dir]
+        dest = params[:dest]
+        data = File.expand_path(params[:data] || '.coverage')
+        path = params[:path]
+        path = path.map {|d| File.expand_path(d)} if path
+        # manage directories and files
+        src_files = []
+        for src_dir in src
+          error "Coverage 'src' parameter must be existing directories" unless
+            File.exists?(src_dir) and File.directory?(src_dir)
+          src_files += Dir.glob("#{src_dir}/**/*.py")
+        end
+        src_files = src_files.map {|f| File.expand_path(f)}.uniq.sort
+        sources = src_files.join(' ')
+        test_files = []
+        for test_glob in test
+          test_files += Dir.glob(test_glob)
+        end
+        test_files = test_files.map {|f| File.expand_path(f)}.uniq.sort
+        error "Coverage 'dir' parameter must be an existing directory" unless
+          File.exists?(dir) and File.directory?(dir)
+        if dest
+          dest = File.expand_path(dest)
+          FileUtils.makedirs(dest) if not File.exists?(dest)
+          report = File.join(dest, 'report.txt')
+        end
+        if path
+          for path_dir in path
+            error "Coverage 'path' parameter must be existing directories" unless
+              File.exists?(path_dir) and File.directory?(path_dir)
+          end
+        end
+        # build the python path
+        if path and path.length > 0
+          if ENV['PYTHONPATH']
+            ENV['PYTHONPATH'] = ENV['PYTHONPATH'] + File::PATH_SEPARATOR +
+              path.join(File::PATH_SEPARATOR)
+          else
+            ENV['PYTHONPATH'] = path.join(File::PATH_SEPARATOR)
+          end
+        end
+        # run coverage command
+        puts "Generating coverage report for #{test_files.length} test(s)..."
+        coverage = "#{File.dirname(__FILE__)}/../tools/coverage/coverage.py"
+        File.delete(data) if File.exists?(data)
+        prev_dir = Dir.pwd
+        for test_file in test_files
+          begin
+            Dir.chdir(dir)
+            command = "python #{coverage} -x -f #{data} #{test_file}"
+            system(command) || error("Error running coverage report")
+          ensure
+            Dir.chdir(prev_dir)
+          end
+        end
+        if dest
+          command = "python #{coverage} -r -f #{data} -m #{sources} > #{report}"
+          system(command) || error("Error generating coverage report")
+          command = "python #{coverage} -a -f #{data} -d #{dest} #{sources}"
+          system(command) || error("Error generating coverage report")
+        else
+          command = "python #{coverage} -r -f #{data} -m #{sources}"
+          system(command) || error("Error generating coverage report")
+        end
+      end
+
+      private
+
+      # Add directories to the Python path environment variable.
+      # - dirs: directory (string) or list of directories to add to path.
+      def add_python_path(dirs)
+        dirs = Array(dirs)
+        if ENV['PYTHONPATH']
+            ENV['PYTHONPATH'] = dirs.join(File::PATH_SEPARATOR) +
+                File::PATH_SEPARATOR + ENV['PYTHONPATH'] if dirs.length > 0
+        else
+            ENV['PYTHONPATH'] = dirs.join(File::PATH_SEPARATOR)
+        end
+      end
+
+    end
+
+  end
+
+end

data/test/build.yml

@@ -0,0 +1,16 @@
+- build: package_test
+  default: all
+  description: Build file to test generated and installed package
+
+- target: task
+  description: Test task for generated package
+  script:
+  - python.hello: "World"
+
+- target: egg
+  description: Test egg for generated package
+  script:
+  - "bee -t 'python.hello'"
+
+- target: all
+  depends: [task, egg]

data/test/tc_bee_task_python.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require 'bee'
+require 'test/unit'
+$:.unshift(File.join(File.expand_path(File.dirname(__FILE__))))
+require 'test_build'
+require 'test_build_listener'
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'bee_task_python'
+
+# Test case for bee task.
+class TestBeeTaskPython < Test::Unit::TestCase
+
+  # Create a context object and load tasks in it.
+  def setup
+    super
+    @context = Bee::Context.new(nil)
+    @listener = TestBuildListener.new
+    @build = TestBuild.new(@context, @listener)
+    @package = Bee::Task::Python.new(@build)
+  end
+
+  def test_compile
+    # TODO: write unit test
+  end
+
+end

data/test/test_build.rb

@@ -0,0 +1,26 @@
+# Copyright 2006-2008 Michel Casabianca <michel.casabianca@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Empty build for testing purpose. Contains a single context.
+class TestBuild
+  
+  attr_reader :context
+  attr_reader :listener
+  
+  def initialize(context, listener)
+    @context = context
+    @listener = listener
+  end
+  
+end

data/test/test_build_listener.rb

@@ -0,0 +1,62 @@
+# Copyright 2006-2008 Michel Casabianca <michel.casabianca@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Test build listener.
+class TestBuildListener
+
+  attr_reader :started
+  attr_reader :finished
+  attr_reader :targets
+  attr_reader :tasks
+  attr_reader :success
+  attr_reader :errors
+  attr_accessor :output
+  attr_reader :verbose
+  
+  def initialize
+    @targets = []
+    @tasks = []
+    @output = ''
+    @verbose = false
+  end
+  
+  def build_started(build)
+    @started = true
+  end
+
+  def build_finished(build)
+    @finished = true
+  end
+
+  def target(target)
+    @targets << target
+  end
+
+  def task(task)
+    @tasks << tasks
+  end
+
+  def error(exception)
+    @errors = exception
+  end
+
+  def print(text)
+    @output << text
+  end
+
+  def puts(text)
+    @output << text + "\n"
+  end
+
+end

data/test/ts_bee_python.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+# Copyright 2006-2008 Michel Casabianca <michel.casabianca@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Script that runs all tests in current directory (and subdirectories) 
+# in a single test suite.
+
+require 'find'
+
+Find.find(File.dirname(__FILE__)) do |path|
+  if File.file?(path) and path =~ /tc_.+\.rb$/
+    load path
+  end
+end

data/tools/common/__init__.py

@@ -0,0 +1,5 @@
+"""generated file, don't modify or your data will be lost"""
+try:
+    __import__('pkg_resources').declare_namespace(__name__)
+except ImportError:
+    pass

data/tools/common/common/__init__.py

@@ -0,0 +1,140 @@
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option) any
+# later version.
+#
+# logilab-common is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+"""Logilab common library (aka Logilab's extension to the standard library).
+
+:type STD_BLACKLIST: tuple
+:var STD_BLACKLIST: directories ignored by default by the functions in
+  this package which have to recurse into directories
+
+:type IGNORED_EXTENSIONS: tuple
+:var IGNORED_EXTENSIONS: file extensions that may usually be ignored
+"""
+__docformat__ = "restructuredtext en"
+from logilab.common.__pkginfo__ import version as __version__
+
+STD_BLACKLIST = ('CVS', '.svn', '.hg', 'debian', 'dist', 'build')
+
+IGNORED_EXTENSIONS = ('.pyc', '.pyo', '.elc', '~')
+
+# set this to False if you've mx DateTime installed but you don't want your db
+# adapter to use it (should be set before you got a connection)
+USE_MX_DATETIME = True
+
+
+class attrdict(dict):
+    """A dictionary for which keys are also accessible as attributes."""
+    def __getattr__(self, attr):
+        try:
+            return self[attr]
+        except KeyError:
+            raise AttributeError(attr)
+
+class dictattr(dict):
+    def __init__(self, proxy):
+        self.__proxy = proxy
+
+    def __getitem__(self, attr):
+        try:
+            return getattr(self.__proxy, attr)
+        except AttributeError:
+            raise KeyError(attr)
+
+class nullobject(object):
+    def __repr__(self):
+        return '<nullobject>'
+    def __nonzero__(self):
+        return False
+
+# flatten -----
+# XXX move in a specific module and use yield instead
+# do not mix flatten and translate
+#
+# def iterable(obj):
+#    try: iter(obj)
+#    except: return False
+#    return True
+#
+# def is_string_like(obj):
+#    try: obj +''
+#    except (TypeError, ValueError): return False
+#    return True
+#
+#def is_scalar(obj):
+#    return is_string_like(obj) or not iterable(obj)
+#
+#def flatten(seq):
+#    for item in seq:
+#        if is_scalar(item):
+#            yield item
+#        else:
+#            for subitem in flatten(item):
+#               yield subitem
+
+def flatten(iterable, tr_func=None, results=None):
+    """Flatten a list of list with any level.
+
+    If tr_func is not None, it should be a one argument function that'll be called
+    on each final element.
+
+    :rtype: list
+
+    >>> flatten([1, [2, 3]])
+    [1, 2, 3]
+    """
+    if results is None:
+        results = []
+    for val in iterable:
+        if isinstance(val, (list, tuple)):
+            flatten(val, tr_func, results)
+        elif tr_func is None:
+            results.append(val)
+        else:
+            results.append(tr_func(val))
+    return results
+
+
+# XXX is function below still used ?
+
+def make_domains(lists):
+    """
+    Given a list of lists, return a list of domain for each list to produce all
+    combinations of possibles values.
+
+    :rtype: list
+
+    Example:
+
+    >>> make_domains(['a', 'b'], ['c','d', 'e'])
+    [['a', 'b', 'a', 'b', 'a', 'b'], ['c', 'c', 'd', 'd', 'e', 'e']]
+    """
+    domains = []
+    for iterable in lists:
+        new_domain = iterable[:]
+        for i in range(len(domains)):
+            domains[i] = domains[i]*len(iterable)
+        if domains:
+            missing = (len(domains[0]) - len(iterable)) / len(iterable)
+            i = 0
+            for j in range(len(iterable)):
+                value = iterable[j]
+                for dummy in range(missing):
+                    new_domain.insert(i, value)
+                    i += 1
+                i += 1
+        domains.append(new_domain)
+    return domains