lemon 0.6 → 0.7.0

data/HISTORY

@@ -1,6 +1,37 @@
 = RELEASE HISTORY
 
-== 0.5 / 2009-12-31
+== 0.7.0 / 2010-05-04
+
+This release fixes issue with coverage reports. To do this
+we have interoduced the +Covers+ method. This allows Lemon
+to distingush between code that is inteded to be covered
+by the tests and mere support code.
+
+Keep in mind that there is no perfect way to handle coverage.
+Even with the distiction the +Covers+ method provides, coverage
+might not be reported exactly as desired. Other techinques can
+be used to refine coverage however, such a preloading embedded
+support libraries.
+
+Changes:
+
+* Add +Covers+ method to solidify coverage reporting.
+* New Snapshot class improves encapsulation to coverage state.
+
+
+== 0.6.0 / 2010-03-06
+
+This release adds coverage reporting to testing and improves
+the generator.
+
+Changes:
+
+* Runner can provide uncovered and undefined testunit list.
+* Generator can exclude already covered testunits with -u option.
+* Suite class has Coverage instance.
+
+
+== 0.5.0 / 2009-12-31
 
 This is the initial public release of Lemon. Lemon is
 still under development and should be considered betaware,

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2009 Thomas Sawyer
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -1,26 +1,28 @@
 = Lemon
 
-* http://proutils.github.com/lemon
-* http://github.com/proutils/lemon
+* home: http://proutils.github.com/lemon
+* work: http://github.com/proutils/lemon
 
 
 == DESCRIPTION
 
-Lemon is a Unit Testing Framework that enforces a testcase 
-construction mirroring the class or module and method design
+Lemon is a Unit Testing Framework that enforces a test case 
+construction mirroring the class/module and method design
 of the target system. Arguably this promotes the proper
-technique for unit testing, since it helps ensure good test
+technique for unit testing and helps ensure good test
 coverage.
 
 The difference between unit testing and functional testing, and
 all other forms of testing for that matter, lies in where the
 *concern* lies. The concern of unit testing are the concerns
-of unit tests.
+of unit tests -- the individual methods.
 
 
 == HOW TO USE
 
-Say our library consists of the class X:
+=== Writing Tests
+
+Say our library 'mylib.rb' consists of the class X:
 
   class X
     def a; "a"; end
@@ -28,6 +30,8 @@ Say our library consists of the class X:
 
 The simplist test case would be written as follows:
 
+  Covers 'mylib'
+
   TestCase X do
     Unit :a => "method #a does something expected" do
       x = X.new
@@ -35,12 +39,17 @@ The simplist test case would be written as follows:
     end
   end
 
-As tests grow, we need to organize them into concerns. For this
-Lemon provides the #Concern method.
+The +Covers+ method works just like +require+ with the exception
+that loading the file does not occur until just before the tests
+are run. This allows Lemon to cacluate accurate coverage reports.
+
+As tests grow, we might need to organize them into special concerns.
+For this Lemon provides the #Concern method.
+
+  Covers 'mylib'
 
   TestCase X do
-    Concern "Description of a concern that the following unit",
-            "tests address."
+    Concern "Description of a concern that the following unit tests address."
 
     Unit :a => "method #a does something expected" do
       x = X.new
@@ -48,27 +57,25 @@ Lemon provides the #Concern method.
     end
   end
 
+=== Running Tests
+
 To run tests use the +lemon+ command-line utility.
 
   $ lemon test/cases/name_case.rb
 
-Normal output is typical <i>dot-progress</i>. For verbose output, use the <tt>--verbose</tt>
-or <tt>-v</tt> option.
+Normal output is typical <i>dot-progress</i>. For verbose output, use
+the <tt>--verbose</tt> or <tt>-v</tt> option.
 
   $ lemon -v test/cases/name_case.rb
 
-
-== Checking Test Coverage
+=== Checking Test Coverage
 
 Lemon can check test coverage by loading your target system and 
 comparing it to your tests.
 
-  $ lemon --coverage -Ilib -rmyapp test/cases/
-
-
-== Generating Test Skeletons
+  $ lemon --coverage -Ilib test/cases/
 
-NOTE: This feature is not yet fully implemented!
+=== Generating Test Skeletons
 
 Because of the one to one correspondance of case-unit to class-method, Lemon can
 also generate test scaffolding for previously written code. To do this, use the
@@ -76,7 +83,7 @@ also generate test scaffolding for previously written code. To do this, use the
 scripts for which to generate test scaffolding, and the output location for
 the test scripts.
 
-  $ lemon --generate -rlib/ test/cases/
+  $ lemon --generate -Ilib test/cases/
 
 Generating test case scaffodling from code will undoubtedly strike test-driven developers
 as a case of putting the cart before the horse. However, it is not unreasonable to argue
@@ -89,20 +96,9 @@ applications.
 
 == COPYRIGHT
 
-(LGPL License)
+(MIT License)
 
 Copyright (c) 2009 Thomas Sawyer
 
-This program is free software: you can redistribute it and/or modify
-it under the terms of the Lesser General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program 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
-Lesser General Public License for more details.
-
-You should have received a copy of the Lesser General Public License
-along with this program. If not, see <http://www.gnu.org/licenses/>.
+See LICENSE file for details.
 

data/lib/lemon/command.rb

@@ -1,45 +1,22 @@
-require 'optparse'
-
-#require 'lemon'
-#require 'yaml'
+require 'lemon/command/test'
+require 'lemon/command/coverage'
+require 'lemon/command/generate'
 
 module Lemon
-
-  # Lemon Command-line tool base class.
-  class Command
-
-    # Used to map command-line options to command classes.
-    # This must be overridden in subclasses, and return an
-    # array of of options, e.g. [ '-g', '--generate'].
-    def self.options
-      raise "not implemented"
-    end
-
-    # Stores a list of command classes.
-    def self.commands
-      @commands ||= []
-    end
-
-    # When this class is inherited, it is registered to the commands list.
-    def self.inherited(command_class)
-      commands << command_class
+module Command
+
+  # Factory method to initialize and run choosen sub-command.
+  def self.run
+    cmd = Abstract.commands.find do |command_class|
+      /^#{ARGV.first}/ =~ command_class.subcommand
+      #[command_class.options].flatten.find do |subcmd|
+      #  #ARGV.delete(opt)
+      #  /^#{ARGV.first}/ =~ subcmd
+      #end
     end
-
-    # Factory method to initialize and run choosen sub-command.
-    def self.run
-      cmd = commands.find do |command_class|
-        [command_class.options].flatten.find do |opt|
-          ARGV.delete(opt)
-        end
-      end
-      cmd ? cmd.run : Commands::Test.run
-    end
-
+    ARGV.shift if cmd
+    cmd ? cmd.run : Command::Test.run
   end
 
 end
-
-require 'lemon/commands/test'
-require 'lemon/commands/coverage'
-require 'lemon/commands/generate'
-
+end

data/lib/lemon/command/abstract.rb

@@ -0,0 +1,29 @@
+module Lemon
+module Command
+  require 'optparse'
+
+  # Lemon Command-line tool base class.
+  class Abstract
+
+    # Used to map command-line options to command classes.
+    # This must be overridden in subclasses, and return an
+    # array of of options, e.g. [ '-g', '--generate'].
+    def self.options
+      raise "not implemented"
+    end
+
+    # Stores a list of command classes.
+    def self.commands
+      @commands ||= []
+    end
+
+    # When this class is inherited, it is registered to the commands list.
+    def self.inherited(command_class)
+      commands << command_class
+    end
+
+  end
+
+end
+end
+

data/lib/lemon/{commands → command}/coverage.rb

@@ -1,13 +1,14 @@
 module Lemon
-module Commands
+module Command
+  require 'lemon/command/abstract'
 
   # Lemon Coverage Command-line tool.
-  class Coverage < Command
+  class Coverage < Abstract
     require 'yaml'
     require 'lemon/coverage'
 
-    def self.options
-      ['-c', '--coverage']
+    def self.subcommand
+      'coverage' #['-c', '--coverage']
     end
 
     # Initialize and run.
@@ -52,9 +53,9 @@ module Commands
     # Instance of OptionParser.
     def parser
       @parser ||= OptionParser.new do |opt|
-        opt.banner = "lemon -c [OPTIONS]"
-        opt.separator("Produce test coverage reports.")
-        opt.on('--namespace', '-n [NAME]', "include namespace") do |name|
+        opt.banner = "lemon coverage [OPTIONS]"
+        opt.separator("Produce test coverage report.")
+        opt.on('--namespace', '-n [NAME]', "limit coverage to this namespace") do |name|
           namespaces(name)
         end
         opt.on('--public', '-p', "only include public methods") do
@@ -85,15 +86,13 @@ module Commands
       test_files = ARGV.dup
       load_files = []
 
-      includes.each do |path|
-        $LOAD_PATHS.unshift(path)
-      end
-
+      includes.each{ |path| $LOAD_PATH.unshift(path) }
       requires.each{ |path| require(path) }
 
-      cover  = Lemon::Coverage.new(load_files, namespaces, :public => public_only?)
-      suite  = Lemon::Test::Suite.new(test_files)
-      puts cover.coverage(suite).to_yaml
+      suite    = Lemon::Test::Suite.new(test_files, :cover=>true)
+      coverage = Lemon::Coverage.new(suite, namespaces, :public => public_only?)
+
+      puts coverage.checklist.to_yaml
     end
 
   end

data/lib/lemon/{commands → command}/generate.rb

@@ -1,13 +1,14 @@
 module Lemon
-module Commands
+module Command
+  require 'lemon/command/abstract'
 
   # Lemon Generate Command-line tool.
-  class Generate < Command
+  class Generate < Abstract
     require 'lemon/coverage'
 
     #
-    def self.options
-      ['-g', '--generate']
+    def self.subcommand
+      'generate' #['-g', '--generate']
     end
 
     # Initialize and run.
@@ -21,19 +22,28 @@ module Commands
       @includes    = []
       @namespaces  = []
       @public_only = false
+      @uncovered   = false
     end
 
-    #
-    attr_accessor :output
+    # TODO: Support output ? perhaps complex scaffolding
+    #attr_accessor :output
 
     #
     attr_accessor :public_only
 
+    #
+    attr_accessor :uncovered
+
     #
     def public_only?
       @public_only
     end
 
+    #
+    def uncovered_only?
+      @uncovered
+    end
+
     # Get or set librarires to pre-require.
     def requires(*paths)
       @requires.concat(paths) unless paths.empty?
@@ -46,7 +56,7 @@ module Commands
       @includes
     end
 
-    # Get or set paths to include in $LOAD_PATH.
+    #
     def namespaces(*names)
       @namespaces.concat(names) unless names.empty?
       @namespaces
@@ -55,17 +65,20 @@ module Commands
     # Instance of OptionParser.
     def parser
       @parser ||= OptionParser.new do |opt|
-        opt.banner = "lemon -g [OPTIONS]"
-        opt.separator("Generate test scaffolding.")
-        opt.on("--namespace", "-n [NAME]", "include namespace") do |name|
+        opt.banner = "lemon generate [OPTIONS]"
+        opt.separator("Generate unit test scaffolding.")
+        opt.on("--namespace", "-n [NAME]", "limit tests to this namespace") do |name|
           namespaces(name)
         end
         opt.on("--public", "-p", "only include public methods") do
           self.public_only = true
         end
-        opt.on("--output", "-o [PATH]", "output directory") do |path|
-          self.output = path
+        opt.on("--uncovered", "-u", "only include uncovered methods") do
+          self.uncovered = true
         end
+        #opt.on("--output", "-o [PATH]", "output directory") do |path|
+        #  self.output = path
+        #end
         opt.on("-r [FILES]" , "library files to require") do |files|
           files = files.split(/[:;]/)
           requires(*files)
@@ -90,15 +103,18 @@ module Commands
 
       test_files = ARGV.dup
 
-      includes.each do |path|
-        $LOAD_PATHS.unshift(path)
-      end
-
+      includes.each{ |path| $LOAD_PATH.unshift(path) }
       requires.each{ |path| require(path) }
 
-      cover  = Lemon::Coverage.new([], namespaces, :public=>public_only?)
-      suite  = Lemon::Test::Suite.new(*test_files)
-      puts cover.generate(output) #(suite).to_yaml
+      suite = Lemon::Test::Suite.new(test_files, :cover=>true)
+      cover = Lemon::Coverage.new(suite, namespaces, :public=>public_only?)
+      #cover  = Lemon::Coverage.new([], namespaces, :public=>public_only?, :uncovered=>uncovered_only?)
+
+      if uncovered_only?
+        puts cover.generate_uncovered #(output)
+      else
+        puts cover.generate #(output)
+      end
     end
 
   end