lemon 0.9.0 → 0.9.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6bc4b46bb63cecf471821a2b8997ba3f2d976917775f90eb28eab9b017051a8b
+  data.tar.gz: b55cc5338d2ed16736d51cc15e60458dd8ecca01aab1af0f9b8c6160ca6e2bef
+SHA512:
+  metadata.gz: 49acc3b4d7778393804c67097e96f96ff7461d86dc44768d6c599982d66a03e54ae006fdd108065219fcb0ffc50d874c44336870753688b48552330577e24fc0
+  data.tar.gz: aa0ab93ed5a3e4b6357793745f6e530ba09db52ad3ffa8034ab785577f5371807b7ef79e5495ef0829dd14b7f15f11122b1f1f87237d97e1ee4ec167dd898f3d

data/{HISTORY.rdoc → HISTORY.md}

@@ -1,6 +1,37 @@
-= RELEASE HISTORY
+# RELEASE HISTORY
 
-== 0.9.0 / 2011-08-11
+## 0.9.2 / 2026-03-31
+
+Maintenance release. Modernized project tooling and cleaned up documentation.
+
+Changes:
+
+* Replace custom Indexer system with standard gemspec.
+* Replace Travis CI with GitHub Actions.
+* Replace Assembly/Reapfile with Rakefile.
+* Simplify version handling (VERSION constant in module).
+* Fix typos and update URLs to HTTPS.
+* Move site from gh-pages to docs/.
+* Remove obsolete files.
+* Clean up .gitignore.
+
+
+## 0.9.1 / 2012-03-17
+
+Thie release fixes some evaluation scope issues, improves how omit and skip
+methods work, makes test generation usable and generally cleans-up internals.
+All in all, this release should be a fair bit more robust than previous releases
+and ready for the big 1.0 after one more good coding session.
+
+Changes:
+
+* Fix test scope so it's properly isolated.
+* Improve skip and omit methods w/ non-block forms.
+* Use Ripper instead of RubyParse for scaffolding.
+* Greatly improve usability of code generation tool.
+
+
+## 0.9.0 / 2011-08-11
 
 Version 0.9 is a huge release for Lemon. This release finally makes the transition
 to the new unit subcase syntax --a bit more verbose than the old style but a more
@@ -31,7 +62,7 @@ Changes:
 * Implemented new unit block syntax.
 
 
-== 0.8.5 / 2011-07-15
+## 0.8.5 / 2011-07-15
 
 This release fixes exit code status, which should be -1 if there
 are errors or failures.
@@ -41,7 +72,7 @@ Changes:
 * Fix exit code status.
 
 
-== 0.8.4 / 2011-07-11
+## 0.8.4 / 2011-07-11
 
 Fix reported issue #6 to get lemon passing it own tests. (Note: the
 tests need to be run with `test/fixtures` in the loadpath). There was 
@@ -57,7 +88,7 @@ Changes:
 * Lemon can test itself (albeit test are not complete).
 
 
-== 0.8.3 / 2011-05-19
+## 0.8.3 / 2011-05-19
 
 Looks like Lemon is pretty damn near 1.0 status. She probably won't get
 any major changes for a good while. This release simply adds TAP-Y/J reporters.
@@ -69,7 +100,7 @@ Changes:
 * Configuration directory can be `.lemon/`.
 
 
-== 0.8.2 / 2010-09-05
+## 0.8.2 / 2010-09-05
 
 This release overhauls how coverage is performed so it does not need to
 take a system snapshot after requiring each covered file. This greatly
@@ -84,7 +115,7 @@ Changes:
 * Improved output formats.
 
 
-== 0.8.1 / 2010-07-11
+## 0.8.1 / 2010-07-11
 
 This release adds a timer to the verbose output, which help isolate unit tests
 that are slow. It also fixed bug in Before and After advice that prevented them
@@ -95,7 +126,7 @@ Changes:
 * Add times to verbose reporter.
 
 
-== 0.8.0 / 2010-06-21
+## 0.8.0 / 2010-06-21
 
 This release removes coverage information from testing. Coverage can be time
 consuming, but running test should be as fast as possbile. For this reason 
@@ -108,7 +139,7 @@ Changes:
 * Test generator defaults to public methods only.
 
 
-== 0.7.0 / 2010-05-04
+## 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
@@ -125,7 +156,7 @@ Changes:
 * New Snapshot class improves encapsulation to coverage state.
 
 
-== 0.6.0 / 2010-03-06
+## 0.6.0 / 2010-03-06
 
 This release adds coverage reporting to testing and improves the generator.
 
@@ -136,7 +167,7 @@ Changes:
 * Suite class has Coverage instance.
 
 
-== 0.5.0 / 2009-12-31
+## 0.5.0 / 2009-12-31
 
 This is the initial public release of Lemon. Lemon is still under development
 and should be considered betaware, but it's API is stable and the system usable

data/LICENSE.txt

@@ -0,0 +1,27 @@
+Lemon - Pucker-Strength Unit Testing  
+
+Copyright (c) 2009 Rubyworks. All rights reserved
+
+Licensed (spdx) BSD-2-Clause
+
+Redistribution and use in source and binary forms, with or without modification, are
+permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice, this list of
+      conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright notice, this list
+      of conditions and the following disclaimer in the documentation and/or other materials
+      provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(http://rubyworks.github.com/lemon)

data/README.md

@@ -1,24 +1,26 @@
 # Lemon
 
-[Homepage](http://rubyworks.github.com/lemon) |
-[User Guide](http://wiki.github.com/rubyworks/lemon) |
-[Development](http://github.com/rubyworks/lemon) |
-[Issues](http://github.com/rubyworks/lemon/issues)
+[Homepage](https://rubyworks.github.io/lemon) |
+[Development](https://github.com/rubyworks/lemon) |
+[Issues](https://github.com/rubyworks/lemon/issues)
+
+[![Gem Version](https://img.shields.io/gem/v/lemon.svg?style=flat)](https://rubygems.org/gems/lemon)
+[![Build Status](https://github.com/rubyworks/lemon/actions/workflows/test.yml/badge.svg)](https://github.com/rubyworks/lemon/actions/workflows/test.yml)
 
 
 ## DESCRIPTION
 
 Lemon is a Unit Testing Framework that enforces a strict test structure mirroring the class/module and method structure of the target code. Arguably this promotes the proper technique for low-level 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, is simply a matter of where the testing *concern* lies. The concerns of unit testing are the concerns of unit tests --the individual methods.
+The difference between unit testing and functional testing, and all other forms of testing for that matter, is simply a matter of where the testing *concern* lies. The concerns of unit testing are the concerns of unit tests, which, in object-oriented design, drills down to individual methods.
 
-IMPORTANT! As of v0.9+ the API has changed. The `unit :name => "description"` notation is no longer supported.
+**IMPORTANT!** As of v0.9+ the API has changed. The `unit :name => "description"` notation is no longer supported.
 
 
 ## EXAMPLE
 
 Lemon tests are broken down into target class or module and target methods.
-Withn these lie the acutal tests.
+Within these lie the actual tests.
 
 Let's say we have a script 'mylib.rb' consisting of the class X:
 
@@ -28,23 +30,23 @@ class X
 end
 ```
 
-An test case for the class would be written:
+A test case for the class would be written:
 
 ``` ruby
-Covers 'mylib'
+covers 'mylib'
 
-TestCase X do
+testcase X do
 
-  Setup "Description of setup." do
+  setup "Description of setup." do
     @x = X.new
   end
 
-  Unit :a do
-    Test "method #a does something expected" do
+  method :a do
+    test "method #a does something expected" do
       @x.a.assert.is_a? String
     end
 
-    Test "method #a does something else expected" do
+    test "method #a does something else expected" do
       @x.a.assert == "x"
     end
   end
@@ -56,46 +58,58 @@ The `covers` method works just like `require` with the exception that it records
 
 The setup (also called the *concern*) is run for every subsequent test until a new setup is defined.
 
-In conjunction with the `#setup` method, there is a `#teardown` method which can be used "tidy-up" after each test if need be.
-
-You might have also notice by the documentation that the test methods do not have to be capitalized.
+In conjunction with the `#setup` method, there is a `#teardown` method which can be used "tidy-up" after each test.
 
-That is the bulk of the matter for writing Lemon tests. To learn about additonal features not mentioned here, check-out the [User Guide](http://wiki.github.com/rubyworks/lemon).
+The `#unit` method is also aliased as `#methed` which is actually a bit more readable. Along with that there is `class_unit` and its alias `class_method` for testing class-level methods. Also note that the test methods may be capitalized (e.g. `#TestCase`), if you prefer that style.
 
 
 ## USAGE
 
 ### Running Tests
 
-Tests can be run using the `lemonade` command line tool.
+Tests can be run using the `lemons` command line tool.
 
-    $ lemonade test test/cases/name_case.rb
+    $ lemons test test/cases/name_case.rb
 
-Lemon utilizes the Ruby Test system to run tests, the `lemonade test` command simply passes off the running of tests to `ruby-test`. So the `ruby-test` command-line utility can also be used directly:
+Lemon utilizes the RubyTest universal test harness to run tests, the `lemons test` command simply passes off control to `rubytest` command. So the `rubytest` command-line utility can also be used directly:
 
-    $ ruby-test -r lemon test/cases/name_case.rb
+    $ rubytest -r lemon test/cases/name_case.rb
 
-Normal output is typical _dot-progress_. Other output types can be specified by the `--format` or `-f` option.
+Normal output is typically a _dot progression_. Other output types can be specified by the `--format` or `-f` option.
 
-    $ ruby-test -r lemon -f tap test/cases/name_case.rb
+    $ rubytest -r lemon -f tapy test/cases/name_case.rb
 
-See [Ruby Test](http://rubyworks.github.com/test) for more information.
+See [RubyTest](https://github.com/rubyworks/rubytest) for more information.
 
 ### Checking Test Coverage
 
-Lemon can check test coverage by loading your target system and comparing it to your tests. To do this use the <code>lemonade coverage</code> command the utility.
+Lemon can check per-unit test coverage by loading your target system and comparing it to your tests. To do this use the `lemons coverage` command.
 
-    $ lemonade coverage -Ilib test/cases/*.rb
+    $ lemons coverage -Ilib test/cases/*.rb
 
-The coverage tool provides class/module and method coverage and is meant to as a "guidance system" for developers working toward complete test coverage. It is not an lines-of-code coverage tool and should not be considered a substitute for one.
+The coverage tool provides class/module and method coverage and is meant as a "guidance system" for developers working toward complete test coverage. It is not a LOC (lines of code) coverage tool and should not be considered a substitute for one.
 
 ### Generating Test Skeletons
 
-Because of the one to one correspondence of test case and unit test to class/module and method, Lemon can also generate test scaffolding for previously written code. To do this, use the <code>lemonade generate</code> command line utility and provide the lib location or files of the scripts for which to generate test scaffolding, and the output location for the test scripts.
+Because of the one-to-one correspondence of test case and unit test to class/module and method, Lemon can also generate test scaffolding for previously written code. To do this, use the `lemons generate` or `lemons scaffold` command line utilities.
+
+The `generate` command outputs test skeletons to the console. You can use this output as a simple reference or redirect the output to a file and then copy and paste portions into separate files as desired. The `scaffold` command will create actual files in your test directory. Other than that, and the options that go with it (e.g. `--output`), the two commands are the same.
+
+To get a set of test skeletons simply provide the files to be covered.
+
+    $ lemons generate lib/**/*.rb
+
+The generator can take into account tests already written, so as not to include units that already have tests. To do this provide a list of test files after a dash (`-`).
+
+    $ lemons generate -Ilib lib/**/*.rb - test/**/*.rb
+
+Test skeletons can be generated on a per-file or per-case bases. By case is the default. Use the `-f`/`--file` option to do otherwise.
+
+    $ lemon scaffold -f lib/foo.rb
 
-    $ lemonade generate -Ilib test/cases/*.rb
+The default output location is `test/`. You can change this with the `-o/--output` option.
 
-Generating test case scaffolding 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 that high-level, behavior-driven, functional testing frameworks, such as Q.E.D. and Cucumber are better suited to test-first methodologies. While test-driven development can obviously be done with Lemon, unit-testing is more appropriate for testing specific, critical portions of code, or for achieving full test coverage for mission critical applications.
+Generating test case scaffolding 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 that high-level, behavior-driven, functional testing frameworks, such as Q.E.D. and Cucumber, are better suited to test-first methodologies. While test-driven development can obviously be done with Lemon, unit-testing best suited to testing specific, critical portions of code, or for achieving full test coverage for mission critical applications.
 
 ### Test Directory
 
@@ -106,8 +120,8 @@ There is no special directory for Lemon tests. Since they are unit tests, `test/
 
 Lemon Unit Testing Framework
 
-Copyright (c) 2009 Thomas Sawyer 
+Copyright (c) 2009 Thomas Sawyer, Rubyworks
 
-Lemon is distributed according to the terms of the **FreeBSD** License.
+Lemon is distributable in accordance with the **BSD-2-Clause** license.
 
-See the COPYING.rdoc file for details.
+See the LICENSE.txt for details.

data/{spec/coverage/01_complete.rdoc → demo/coverage/01_complete.md}

@@ -1,6 +1,6 @@
-== Complete Coverage
+## Complete Coverage
 
-=== Complete Coverage of Public Interface
+### Complete Coverage of Public Interface
 
 Given an example script in 'lib/complete_example.rb' as follows:
 
@@ -76,7 +76,7 @@ In addition there should be no uncovered_cases or undefined_units.
     coverage.undefined_units.assert = []
     coverage.uncovered_cases.assert = []
 
-=== Including Private and Protected Methods
+### Including Private and Protected Methods
 
 We will use the same example classes as above, but in this case we will
 add coverage for private and protected methods as well, given a test case

data/{spec/coverage/02_incomplete.rdoc → demo/coverage/02_incomplete.md}

@@ -1,6 +1,6 @@
-== Incomplete Coverage
+## Incomplete Coverage
 
-=== Incomplete Coverage of Public Interface
+### Incomplete Coverage of Public Interface
 
 Given an example script in 'lib/incomplete_example.rb' as follows:
 

data/{spec/coverage/03_extensions.rdoc → demo/coverage/03_extensions.md}

@@ -1,6 +1,6 @@
-== Core Extension Coverage
+## Core Extension Coverage
 
-=== Kernel Extensions
+### Kernel Extensions
 
 Given an example script in 'lib/extensions_example.rb' as follows:
 

data/lib/lemon/cli/base.rb

@@ -2,17 +2,14 @@ module Lemon
 
   require 'optparse'
 
-  # TODO: What about a config file?
-
-  # CLI Interfaces handle all lemon sub-commands.
   module CLI
 
     # Base class for all commands.
     class Base
 
       #
-      def initialize(argv=ARGV)
-        @options = {}
+      def self.run(argv)
+        new.run(argv)
       end
 
       #
@@ -25,12 +22,28 @@ module Lemon
         begin
           command_parse(argv)
           command_run(argv)
-        rescue => err
-          raise err if $DEBUG
-          $stderr.puts('ERROR: ' + err.to_s)
+        #rescue => err
+        #  raise err if $DEBUG
+        #  $stderr.puts('ERROR: ' + err.to_s)
         end
       end
 
+    private
+
+      #
+      # Initialize new command instance. This will be overriden in subclasses.
+      #
+      def initialize(argv=ARGV)
+        @options = {}
+      end
+
+      #
+      # Parse command line argument. This is a no-op as it will be overridden
+      # in subclasses.
+      #
+      def command_parse(argv)
+      end
+
       #
       def option_parser
         @option_parser ||= (
@@ -54,7 +67,7 @@ module Lemon
         )
       end
 
-      #
+      # -n --namespace
       def option_namespaces
         option_parser.on('-n', '--namespace NAME', 'add a namespace to output') do |name|
           options[:namespaces] ||= []
@@ -68,54 +81,63 @@ module Lemon
       #  end
       #end
 
+      # -f --format
       def option_format
         option_parser.on('-f', '--format NAME', 'output format') do |name|
           options[:format] = name
         end
       end
 
+      # -v --verbose
       def option_verbose
         option_parser.on('-v', '--verbose', 'shortcut for `-f verbose`') do |name|
           options[:format] = 'verbose'
         end
       end
 
-      def option_covered
+      # -c --covered, -u --uncovered and -a --all
+      def option_coverage
         option_parser.on('-c', '--covered', 'include covered units') do
-          options[:covered] = true
+         if options[:coverage] == :uncovered
+            options[:coverage] = :all
+         else 
+           options[:coverage] = :covered
+         end
         end
-      end
-
-      def option_uncovered
         option_parser.on('-u', '--uncovered', 'include only uncovered units') do
-          options[:uncovered] = true
+          if options[:coverage] == :covered
+            options[:coverage] = :all
+          else
+            options[:coverage] = :uncovered
+          end
         end
-      end
-
-      def option_all
         option_parser.on('-a', '--all', 'include all namespaces and units') do
-          options[:all] = true
+          options[:coverage] = :all
         end
       end
 
+      # -p --private
       def option_private
         option_parser.on('-p', '--private', 'include private and protected methods') do
           options[:private] = true
         end
       end
 
+      # -z --zealous
       def option_zealous
         option_parser.on('-z', '--zealous', 'include undefined case methods') do
           options[:zealous] = true
         end
       end
 
+      # -o --output
       def option_output
-        option_parser.on('-o', '--output DIRECTORY', 'log directory') do |dir|
+        option_parser.on('-o', '--output DIRECTORY', 'output directory') do |dir|
           options[:output] = dir
         end
       end
 
+      # -I
       def option_loadpath
         option_parser.on("-I PATH" , 'add directory to $LOAD_PATH') do |path|
           paths = path.split(/[:;]/)
@@ -124,6 +146,7 @@ module Lemon
         end
       end
 
+      # -r
       def option_requires
        option_parser.on("-r FILE" , 'require file(s) (before doing anything else)') do |files|
           files = files.split(/[:;]/)
@@ -132,6 +155,13 @@ module Lemon
         end
       end
 
+      # --dryrun
+      def option_dryrun
+        option_parser.on('--dryrun', 'no disk writes') do
+          options[:dryrun] = true
+        end
+      end
+
     end
 
   end

data/lib/lemon/cli/generate.rb

@@ -5,11 +5,20 @@ module Lemon
     require 'lemon/cli/base'
 
     # Generate Command
+    #
     class Generate < Base
 
       # Generate test templates.
-      def command_run(test_files)
-        require 'lemon/generator'
+      def command_run(files)
+        if i = files.index('-')
+          options[:files] = files[0...i]
+          options[:tests] = files[i+1..-1]
+        else
+          options[:files] = files
+          options[:tests] = []
+        end
+
+        require 'lemon/coverage/generator'
 
         loadpath = options[:loadpath] || []
         requires = options[:requires] || []
@@ -17,31 +26,57 @@ module Lemon
         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)
+        generator = Lemon::Generator.new(options)
 
-        #if uncovered
-        #  puts cover.generate_uncovered #(output)
-        #else
-          puts generator.generate #(output)
-        #end
+        render_map = generator.generate
+
+        generate_output(render_map)
+      end
+
+      #
+      def generate_output(render_map)
+        render_map.each do |group, test|
+          puts "# --- #{group} ---"
+          puts
+          puts test
+          puts
+        end
       end
 
       #
       def command_parse(argv)
-        option_parser.banner = "Usage: lemonade generate [options] [files ...]"
-        #option_parser.separator("Generate test scaffolding.")
+        option_parser.banner = "Usage: lemons generate [options] [files ...]"
+
+        setup_options
+
+        option_parser.parse!(argv)
+      end
 
+      #
+      def setup_options
+        option_group
         option_namespaces
-        option_covered
-        option_uncovered
-        option_all
         option_private
+        option_caps
         option_loadpath
         option_requires
+      end
 
-        option_parser.parse!(argv)
+      # -f --file
+      def option_group
+        option_parser.on('-f', '--file', 'group tests by file') do
+          options[:group] = :file
+        end
+        #option_parser.on('-c', '--case', 'group tests by case') do
+        #  options[:group] = :case
+        #end
+      end
+
+      # -C --caps
+      def option_caps
+        option_parser.on('-C', '--caps', 'use capitalized test terms') do
+          options[:caps] = true
+        end
       end
 
     end