lemon 0.8.5 → 0.9.0

data/lib/lemon/cli/coverage.rb

@@ -0,0 +1,52 @@
+module Lemon
+
+  module CLI
+
+    require 'lemon/cli/base'
+
+    # Coverage Command
+    class Coverage < Base
+
+      # Ouput coverage report.
+      def command_run(test_files)
+        require 'lemon/coverage/analyzer'
+
+        #loadpath = options[:loadpath] || []
+        #requires = options[:requires] || []
+
+        #loadpath.each{ |path| $LOAD_PATH.unshift(path) }
+        #requires.each{ |path| require(path) }
+
+        $stderr.print "Calculating... "
+        $stderr.flush
+
+        cover = Lemon::CoverageAnalyzer.new(test_files, options)
+
+        cover.calculate  # this just helps calcs get done up front
+
+        $stderr.puts
+
+        cover.render
+      end
+
+      #
+      def command_parse(argv)
+        option_parser.banner = "Usage: lemonade coverage [options] [files ...]"
+        #option_parser.separator("Check test coverage.")
+
+        option_namespaces
+        option_private
+        option_zealous
+        option_output
+        option_format
+        option_loadpath
+        option_requires
+
+        option_parser.parse!(argv)
+      end
+
+    end
+
+  end
+
+end

data/lib/lemon/cli/generate.rb

@@ -0,0 +1,51 @@
+module Lemon
+
+  module CLI
+
+    require 'lemon/cli/base'
+
+    # Generate Command
+    class Generate < Base
+
+      # Generate test templates.
+      def command_run(test_files)
+        require 'lemon/generator'
+
+        loadpath = options[:loadpath] || []
+        requires = options[:requires] || []
+
+        loadpath.each{ |path| $LOAD_PATH.unshift(path) }
+        requires.each{ |path| require(path) }
+
+        #cover = options[:uncovered]
+        #suite = Lemon::TestSuite.new(test_files, :cover=>cover) #, :cover_all=>true)
+        generator = Lemon::Generator.new(test_files, options)
+
+        #if uncovered
+        #  puts cover.generate_uncovered #(output)
+        #else
+          puts generator.generate #(output)
+        #end
+      end
+
+      #
+      def command_parse(argv)
+        option_parser.banner = "Usage: lemonade generate [options] [files ...]"
+        #option_parser.separator("Generate test scaffolding.")
+
+        option_namespaces
+        option_covered
+        option_uncovered
+        option_all
+        option_private
+        option_loadpath
+        option_requires
+
+        option_parser.parse!(argv)
+      end
+
+    end
+
+  end
+
+end

data/lib/lemon/cli/test.rb

@@ -0,0 +1,50 @@
+module Lemon
+
+  module CLI
+
+    require 'lemon/cli/base'
+
+    # Test Command
+    class Test < Base
+
+      # Run unit tests.
+      def command_run(scripts)
+        require 'lemon/runner'
+
+        loadpath = options[:loadpath] || ['lib']  # + ['lib'] ?
+        requires = options[:requires] || []
+
+        loadpath.each{ |path| $LOAD_PATH.unshift(path) }
+        requires.each{ |path| require(path) }
+
+        #suite  = Lemon::Test::Suite.new(files, :cover=>cover)
+        #runner = Lemon::Runner.new(suite, :format=>format, :cover=>cover, :namespaces=>namespaces)
+
+        runner = Lemon::TestRunner.new(
+          scripts, :format=>options[:format], :namespaces=>options[:namespaces]
+        )
+
+        success = runner.run
+
+        exit -1 unless success
+      end
+
+      #
+      def command_parse(argv)
+        option_parser.banner = "Usage: lemonade test [options] [files ...]"
+        #option_parser.separator("Run unit tests.")
+
+        option_format
+        option_verbose
+        option_namespaces
+        option_loadpath
+        option_requires
+
+        option_parser.parse!(argv)
+      end
+
+    end
+
+  end
+
+end

data/lib/lemon/core_ext.rb

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

data/lib/lemon/core_ext/kernel.rb

@@ -0,0 +1,20 @@
+module Kernel
+
+  unless method_defined?(:qua_class)
+
+    def qua_class(&block)
+      if block_given?
+        (class << self; self; end).class_eval(&block)
+      else
+        (class << self; self; end)
+      end
+    end
+
+    alias :quaclass :qua_class
+  end
+
+  unless method_defined?(:singleton_class)
+    alias :singleton_class :quaclass
+  end
+
+end

data/lib/lemon/core_ext/omission.rb

@@ -0,0 +1,18 @@
+# The Omission class is a subclass of NotImplementedError with 
+# it's assertion flag set to true. This will be recognized by
+# Ruby Test as a test omission.
+#
+# @example
+#   test "some feature" do
+#     raise Omission, "feature can't be tested"
+#   end
+#
+class Omission < NotImplementedError
+  def assertion?
+    true
+  end
+  def to_proc
+    error = self
+    lambda{ raise error }
+  end
+end

data/lib/lemon/{controller/coverage_analyzer.rb → coverage/analyzer.rb}

@@ -1,5 +1,5 @@
-require 'lemon/model/snapshot'
-require 'lemon/model/main'
+require 'lemon'
+require 'lemon/coverage/snapshot'
 
 module Lemon
 
@@ -38,13 +38,15 @@ module Lemon
 
       @reporter   = reporter_find(@format)
 
+      reset_suite
+
       initialize_prerequisites(options)
 
-      @canonical  = Snapshot.capture #system #@suite.canonical
+      @canonical = Snapshot.capture #system #@suite.canonical
 
       #@suite = Lemon.suite
-      @suite      = Lemon::TestSuite.new(files, :cover=>true)  #@suite = suite
-      Lemon.suite = @suite
+      #@suite      = Lemon::TestSuite.new(files, :cover=>true)  #@suite = suite
+      #Lemon.suite = @suite
 
       files = files.map{ |f| Dir[f] }.flatten
       files = files.map{ |f| 
@@ -57,6 +59,8 @@ module Lemon
       files = files.map{ |f| File.expand_path(f) }
 
       files.each{ |s| load s } #require s }
+
+      @suite = $TEST_SUITE.dup
     end
 
     # Load in prerequisites
@@ -69,7 +73,14 @@ module Lemon
     end
 
     #
-    attr :suite
+    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
@@ -131,19 +142,31 @@ module Lemon
     def covered_units
       @covered_units ||= (
         list = []
-        suite.each do |testcase|
-          testcase.testunits.each do |unit|
-            list << Snapshot::Unit.new(
-              unit.testcase.target,
-              unit.target,
-              :function=>unit.function?
-            )
-          end
+        suite.each do |test|
+          covered_unit(test, list)
         end
         list.uniq
       )
     end
 
+    #
+    def covered_unit(test, list)
+      case test
+      when Lemon::TestModule
+        test.each do |t|
+          covered_unit(t, list)
+        end
+      when Lemon::TestMethod
+        list << Snapshot::Unit.new(
+          test.context.target,
+          test.target,
+          :function=>test.function?
+        )      
+      else
+        # ignore
+      end
+    end
+
     #
     def covered_namespaces
       @covered_namespaces ||= covered_units.map{ |u| u.namespace }.uniq
@@ -325,19 +348,18 @@ module Lemon
         /^#{format}/ =~ name
       end
       raise "unsupported format" unless format
-      require "lemon/view/cover_reports/#{format}"
+      require "lemon/coverage/formats/#{format}"
       reporter = Lemon::CoverReports.const_get(format.capitalize)
       reporter.new(self)
     end
 
     #
     def reporter_list
-      Dir[File.dirname(__FILE__) + '/../view/cover_reports/*.rb'].map do |rb|
+      Dir[File.dirname(__FILE__) + '/formats/*.rb'].map do |rb|
         File.basename(rb).chomp('.rb')
       end
     end
 
-  end#class Coverage
-
-end#module Lemon
+  end
 
+end

data/lib/lemon/{view/cover_reports → coverage/formats}/compact.rb

@@ -1,4 +1,4 @@
-require 'lemon/view/cover_reports/abstract'
+require 'lemon/coverage/formats/abstract'
 
 module Lemon::CoverReports
 

data/lib/lemon/{view/cover_reports → coverage/formats}/outline.rb

@@ -1,4 +1,4 @@
-require 'lemon/view/cover_reports/abstract'
+require 'lemon/coverage/formats/abstract'
 
 module Lemon::CoverReports
 

data/lib/lemon/{view/cover_reports → coverage/formats}/verbose.rb

@@ -1,4 +1,4 @@
-require 'lemon/view/cover_reports/abstract'
+require 'lemon/coverage/formats/abstract'
 
 module Lemon::CoverReports
 

data/lib/lemon/{view/cover_reports → coverage/formats}/yaml.rb

@@ -1,4 +1,4 @@
-require 'lemon/view/cover_reports/abstract'
+require 'lemon/coverage/formats/abstract'
 
 module Lemon::CoverReports
 

data/lib/lemon/{controller/scaffold_generator.rb → generator.rb}

@@ -1,12 +1,33 @@
-require 'lemon/controller/coverage_analyzer'
-
 module Lemon
 
+  require 'lemon/coverage/analyzer'
+
+  #--
+  # TODO: Generator options for selecting all, covered and uncovered still
+  #       need some clarification.
+  #++
+
+  # Test Scaffold Generator.
   #
-  class ScaffoldGenerator
+  class Generator
 
     # New Scaffold Generator.
     #
+    # @option options [Array] :namespaces
+    #   List of class/module names to limit scaffolding.
+    #
+    # @option options [Boolean] :private
+    #   Include private methods in scaffolding.
+    #
+    # @option options [Boolean] :covered
+    #   Include covered targets in scaffolding.
+    #
+    # @option options [Boolean] :uncovered
+    #   Include uncovered targets in scaffolding.
+    #
+    # @option options [Boolean] :all
+    #   Include all possible targets in scaffolding.
+    #
     def initialize(files, options={})
       @files      = files
 
@@ -15,8 +36,16 @@ module Lemon
 
       @namespaces = options[:namespaces]
       @private    = options[:private]
+      @covered    = options[:covered]
       @uncovered  = options[:uncovered]
       @all        = options[:all]
+
+      if @namespaces
+        unless @covered or @uncovered
+          @all = true 
+        end
+      end
+
     end
 
     # Returns CoverageAnalyzer instance.
@@ -24,22 +53,22 @@ module Lemon
       @coverage
     end
 
-    #
+    # List of class and module namespaces to limit scaffolding.
     def namespaces
       @namespaces
     end
 
-    #
+    # Include all targets.
     def all?
       @all
     end
 
-    #
+    # Include targets that are already covered.
     def covered?
       @covered
     end
 
-    # Include only uncovered methods.
+    # Include only uncovered targrts.
     def uncovered?
       @uncovered
     end
@@ -60,22 +89,22 @@ module Lemon
       end
     end
 
-    #
+    # Generate code template for covered.
     def generate_target
       render(filter(coverage.target.units))
     end
 
-    #
+    # Generate code template for uncovered.
     def generate_uncovered
       render(filter(coverage.uncovered))
     end
 
-    # Generate code template.
+    # Generate code template for all.
     def generate_all
       render(Snapshot.capture(namespaces).units)
     end
 
-    #
+    # Filter targets to include only specified namespaces.
     def filter(units)
       return units if namespaces.nil? or namespaces.empty?
       units.select do |u|
@@ -90,13 +119,23 @@ module Lemon
       code = []
       mods = units.group_by{ |u| u.namespace }
       mods.each do |mod, units|
-        code << "TestCase #{mod} do"
+        if Class === mod
+          code << "TestClass #{mod} do"
+        else
+          code << "TestModule #{mod} do"
+        end
         units.each do |unit|
           next unless private? or unit.public?
           if unit.function?
-            code << "\n  MetaUnit :#{unit.method} => '' do\n\n  end"
+            code << "\n  ClassMethod :#{unit.method} do"
+            code << "\n    Test '' do"
+            code << "\n    end"
+            code << "end"
           else
-            code << "\n  Unit :#{unit.method} => '' do\n\n  end"
+            code << "\n  Method :#{unit.method} do"
+            code << "\n    Test '' do"
+            code << "\n    end"
+            code << "\n  end"
           end
         end
         code << "\nend\n"