lemon 0.9.0 → 0.9.1

data/lib/lemon/cli/scaffold.rb

@@ -0,0 +1,116 @@
+module Lemon
+
+  module CLI
+
+    require 'lemon/cli/generate'
+    require 'fileutils'
+
+    # Scaffold Command
+    class Scaffold < Generate
+
+      # TODO: To be on the safe side, maybe require a --force option in order
+      #       to write into a test directory that already has content.
+
+      #
+      # Unlike the Generate command, the Scaffold commnad writes output
+      # to test files.
+      #
+      def generate_output(render_map)
+        render_map.each do |group, test|
+          file = test_file(group)
+
+          if File.exist?(file)
+            append_test(file, test)
+          else
+            write_test(file, test)
+          end
+        end
+      end
+
+      #
+      #
+      #
+      def command_parse(argv)
+        option_parser.banner = "Usage: lemons scaffold [options] [files ...]"
+        setup_options
+        option_parser.parse!(argv)
+      end
+
+      #
+      #
+      #
+      def setup_options
+        option_output
+        option_dryrun
+        super
+      end
+
+      #
+      # Output directory, default is `test`.
+      #
+      def output
+        options[:output] || 'test'
+      end
+
+      #
+      #
+      #
+      def dryrun?
+        options[:dryrun]
+      end
+
+      #
+      # Given the group name, convert it to a suitable test file name.
+      #
+      def test_file(group)
+        if options[:group] == :file
+          file = group
+        else
+          file = group.gsub('::', '/').downcase
+        end
+
+        dirname, basename = File.split(file)
+
+        if i = dirname.index('/')
+          dirname = dirname[i+1..-1]
+          file = File.join(dirname, output, "case_#{basename}")
+        else
+          file = File.join(output, "case_#{basename}")
+        end
+      end
+
+      #
+      # Write test file.
+      #
+      def write_test(file, test)
+        return if test.strip.empty?
+        if dryrun?
+          puts "[DRYRUN] write #{file}"
+        else
+          dir = File.dirname(file)
+          FileUtils.mkdir_p(dir) unless File.directory?(dir)
+          File.open(file, 'w'){ |f| f << test.to_s }
+          puts "write #{file}"
+        end       
+      end
+
+      #
+      # Append tests to file.
+      #
+      def append_test(file, test)
+        return if test.strip.empty?
+        if dryrun?
+          puts "[DRYRUN] append #{file}"
+        else
+          dir = File.dirname(file)
+          FileUtils.mkdir_p(dir) unless File.directory?(dir)
+          File.open(file, 'a'){ |f| f << "\n" + test.to_s }
+          puts "append #{file}"
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/lemon/core_ext.rb

@@ -1,7 +1,7 @@
 if RUBY_VERSION > '1.9'
   require_relative 'core_ext/kernel'
-  require_relative 'core_ext/omission'
+  require_relative 'core_ext/module'
 else
   require 'lemon/core_ext/kernel'
-  require 'lemon/core_ext/omission'
+  require 'lemon/core_ext/module'
 end

data/lib/lemon/core_ext/module.rb

@@ -0,0 +1,9 @@
+class Module
+
+  #
+  def namespace
+    i = name.rindex('::')
+    i ? name[0...i] : name
+  end
+
+end

data/lib/lemon/coverage/analyzer.rb

@@ -24,6 +24,7 @@ module Lemon
     #  @public    = options[:public]
     #end
 
+    #
     # New Coverage object.
     #
     #   CoverageAnalyzer.new(suite, :MyApp, :public => true)
@@ -63,7 +64,9 @@ module Lemon
       @suite = $TEST_SUITE.dup
     end
 
+    #
     # Load in prerequisites
+    #
     def initialize_prerequisites(options)
       loadpath = [options[:loadpath] || []].compact.flatten
       requires = [options[:requires] || []].compact.flatten
@@ -72,56 +75,80 @@ module Lemon
       requires.each{ |path| require(path) }
     end
 
+    #
+    #
     #
     def reset_suite
       $TEST_SUITE = []
     end
 
+    #
+    #
     #
     def suite
       @suite
     end
 
+    #
     # Paths of lemon tests and/or ruby scripts to be compared and covered.
     # This can include directories too, in which case all .rb scripts below
     # then directory will be included.
+    #
     attr :files
 
-    ## Conical snapshot of system (before loading libraries to be covered).
-    #attr :canonical
-
+    #
     # Report format.
+    #
     attr :format
 
+    #
+    #
     #
     attr :namespaces
 
+    #
+    ## Conical snapshot of system (before loading libraries to be covered).
+    #
+    #attr :canonical
+
+    #
+    #
     #
     def canonical
       @canonical #= Snapshot.capture
     end
 
+    #
+    #
     #
     def suite=(suite)
       raise ArgumentError unless TestSuite === suite
       @suite = suite
     end
 
+    #
     # Only use public methods for coverage.
+    #
     def public_only?
       !@private
     end
 
+    #
+    #
     #
     def private?
       @private
     end
 
+    #
     # Include methods of uncovered cases in uncovered units.
+    #
     def zealous?
       @zealous
     end
 
+    #
+    #
     #
     def namespaces
       @namespaces
@@ -138,6 +165,8 @@ module Lemon
       uncovered_cases # that should be all it takes
     end
 
+    #
+    #
     #
     def covered_units
       @covered_units ||= (
@@ -149,6 +178,8 @@ module Lemon
       )
     end
 
+    #
+    #
     #
     def covered_unit(test, list)
       case test
@@ -160,33 +191,43 @@ module Lemon
         list << Snapshot::Unit.new(
           test.context.target,
           test.target,
-          :function=>test.function?
-        )      
+          :singleton=>test.class_method?
+        )
       else
         # ignore
       end
     end
 
+    #
+    #
     #
     def covered_namespaces
       @covered_namespaces ||= covered_units.map{ |u| u.namespace }.uniq
     end
 
+    #
+    #
     #
     def target_namespaces
       @target_namespaces ||= filter(covered_namespaces)
     end
 
+    #
     # Target system snapshot.
+    #
     def target
       @target ||= Snapshot.capture(target_namespaces)
     end
 
+    #
     # Current system snapshot.
+    #
     def current
       @current ||= Snapshot.capture
     end
 
+    #
+    #
     #
     def uncovered_units
       @uncovered_units ||= (
@@ -200,12 +241,16 @@ module Lemon
       )
     end
 
+    #
+    #
     #
     def undefined_units
       @undefined_units ||= covered_units - target.units
     end
 
+    #
     # List of modules/classes not covered.
+    #
     def uncovered_cases
       @uncovered_cases ||= (
         list = current.units - (target.units + canonical.units)
@@ -214,22 +259,30 @@ module Lemon
       )
     end
 
+    #
+    #
     #
     def uncovered_system
       @uncovered_system ||= Snapshot.capture(uncovered_cases)
     end
 
+    #
+    #
     #
     def canonical_cases
       @canonical_cases ||= canonical.units.map{ |u| u.namespace }.uniq
     end
 
+    #
+    #
     #
     alias_method :covered,   :covered_units
     alias_method :uncovered, :uncovered_units
     alias_method :undefined, :undefined_units
 
+    #
     # Reset coverage data for recalcuation.
+    #
     def reset!
       @covered_units      = nil
       @covered_namespaces = nil
@@ -240,12 +293,16 @@ module Lemon
       @current            = nil
     end
 
+    #
     # Iterate over covered units.
+    #
     def each(&block)
       covered_units.each(&block)
     end
 
+    #
     # Number of covered units.
+    #
     def size
       covered_units.size
     end
@@ -289,6 +346,8 @@ module Lemon
 
   private
 
+    #
+    #
     #
     def system(*namespaces)
       namespaces = nil if namespaces.empty?
@@ -300,7 +359,9 @@ module Lemon
     #  Snapshot.capture
     #end
 
+    #
     # Filter namespaces.
+    #
     def filter(ns)
       return ns if namespaces.nil? or namespaces.empty?
       #units = units.reject do |u|
@@ -311,6 +372,8 @@ module Lemon
       end
     end
 
+    #
+    #
     #
     def filter_units(units)
       return units if namespaces.nil? or namespaces.empty?
@@ -327,12 +390,16 @@ module Lemon
 
   public
 
+    #
+    #
     #
     def render
       reporter.render
     end
 
+    #
     # All output is handled by a reporter.
+    #
     def reporter
       @reporter ||= reporter_find(format)
     end
@@ -341,6 +408,8 @@ module Lemon
 
     DEFAULT_REPORTER = 'compact'
 
+    #
+    #
     #
     def reporter_find(format)
       format = format ? format.to_s.downcase : DEFAULT_REPORTER
@@ -353,6 +422,8 @@ module Lemon
       reporter.new(self)
     end
 
+    #
+    #
     #
     def reporter_list
       Dir[File.dirname(__FILE__) + '/formats/*.rb'].map do |rb|

data/lib/lemon/coverage/cover_unit.rb

@@ -5,45 +5,60 @@ module Lemon
   class CoverUnit
 
     attr :target
+
     attr :method
-    attr :function
 
+    attr :singleton
+
+    #
     def initialize(target, method, props={})
-      @target   = target
-      @method   = method.to_sym
-      @function = props[:function] ? true : false
-      @covered  = props[:covered]
+      @target    = target
+      @method    = method.to_sym
+      @covered   = props[:covered]
+      @singleton = props[:singleton] ? true : false
 
-      if @function
+      if @singleton
         @private = !@target.public_methods.find{ |m| m.to_sym == @method }
       else
         @private = !@target.public_instance_methods.find{ |m| m.to_sym == @method }
       end
     end
 
+    #
     # Method access is private or protected?
+    #
     def private?
       @private
     end
 
+    #
     # Marked as covered?
+    #
     def covered?
       @covered
     end
 
     #
-    def function?
-      @function
+    #
+    #
+    def singleton?
+      @singleton
     end
 
+    alias class_method? singleton?
+
+    #
+    #
     #
     def hash
-      @target.hash ^ @method.hash ^ @function.hash
+      @target.hash ^ @method.hash ^ singleton.hash
     end
 
+    #
+    #
     #
     def to_s
-      if @function
+      if singleton?
         "#{@target}.#{@method}"
       else
         "#{@target}##{@method}"
@@ -51,23 +66,32 @@ module Lemon
     end
     alias to_str to_s
 
+    #
+    #
+    #
     def eql?(other)
       return false unless Unit === other
       return false unless target == other.target
       return false unless method == other.method
-      return false unless function == other.function
+      return false unless singleton == other.singleton
       return true
     end
 
+    #
+    #
+    #
     def inspect
-      "#{target}#{function ? '.' : '#'}#{method}"
+      "#{target}#{singleton? ? '.' : '#'}#{method}"
     end
 
+    #
+    #
+    #
     def <=>(other)
       c = (target.name <=> other.target.name)
       return c unless c == 0
-      return -1 if function  && !other.function
-      return  1 if !function && other.function
+      return -1 if singleton  && !other.singleton
+      return  1 if !singleton && other.singleton
       method.to_s <=> other.method.to_s
     end
   end