lemon 0.9.0 → 0.9.1

data/work/deprecated/command/abstract.rb

@@ -1,29 +0,0 @@
-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/work/deprecated/command/coverage.rb

@@ -1,115 +0,0 @@
-module Lemon
-module Command
-  require 'lemon/command/abstract'
-
-  # Lemon Coverage Command-line tool.
-  class Coverage < Abstract
-    require 'yaml'
-    require 'lemon/coverage'
-
-    def self.subcommand
-      'coverage' #['-c', '--coverage']
-    end
-
-    # Initialize and run.
-    def self.run
-      new.run
-    end
-
-    # New Command instance.
-    def initialize
-      @format      = nil
-      @requires    = []
-      @includes    = []
-      @namespaces  = []
-      @public_only = false
-    end
-
-    #
-    attr_accessor :format
-
-    #
-    attr_accessor :public_only
-
-    #
-    def public_only?
-      @public_only
-    end
-
-    # Get or set librarires to pre-require.
-    def requires(*paths)
-      @requires.concat(paths) unless paths.empty?
-      @requires
-    end
-
-    # Get or set paths to include in $LOAD_PATH.
-    def includes(*paths)
-      @includes.concat(paths) unless paths.empty?
-      @includes
-    end
-
-    # Get or set paths to include in $LOAD_PATH.
-    def namespaces(*names)
-      @namespaces.concat(names) unless names.empty?
-      @namespaces
-    end
-
-    # Instance of OptionParser.
-    def parser
-      @parser ||= OptionParser.new do |opt|
-        opt.banner = "lemon coverage [OPTIONS]"
-        opt.separator("Produce test coverage report.")
-        opt.on('--verbose', '-v', "select verbose report format") do |type|
-          self.format = :verbose
-        end
-        #opt.on('--outline', '-o', "select outline report format") do |type|
-        #  self.format = :outline
-        #end
-        #opt.on('--format', '-f [TYPE]', "select report format") do |type|
-        #  self.format = type
-        #end
-        opt.on('--namespace', '-n [NAME]', "limit coverage to this namespace") do |name|
-          namespaces(name)
-        end
-        opt.on('--public', '-p', "only include public methods") do
-          self.public_only = true
-        end
-        opt.on("-r [FILES]" , 'library files to require') do |files|
-          files = files.split(/[:;]/)
-          requires(*files)
-        end
-        opt.on("-I [PATH]" , 'include in $LOAD_PATH') do |path|
-          path = path.split(/[:;]/)
-          includes(*path)
-        end
-        opt.on("--debug" , 'turn on debugging mode') do
-          $DEBUG = true
-        end
-        opt.on_tail('--help', '-h', 'show this help message') do
-          puts opt
-          exit
-        end
-      end
-    end
-
-    #
-    def run
-      parser.parse!
-
-      test_files = ARGV.dup
-      load_files = []
-
-      includes.each{ |path| $LOAD_PATH.unshift(path) }
-      requires.each{ |path| require(path) }
-
-      suite    = Lemon::Test::Suite.new(test_files, :cover=>true)
-      coverage = Lemon::Coverage.new(suite, namespaces, :public=>public_only?)
-
-      coverage.format(format)
-    end
-
-  end
-
-end
-end
-

data/work/deprecated/command/generate.rb

@@ -1,124 +0,0 @@
-module Lemon
-module Command
-  require 'lemon/command/abstract'
-
-  # Lemon Generate Command-line tool.
-  class Generate < Abstract
-    require 'lemon/coverage'
-
-    #
-    def self.subcommand
-      'generate' #['-g', '--generate']
-    end
-
-    # Initialize and run.
-    def self.run
-      new.run
-    end
-
-    # New Command instance.
-    def initialize
-      @requires    = []
-      @includes    = []
-      @namespaces  = []
-      @public_only = false
-      @uncovered   = false
-    end
-
-    # 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?
-      @requires
-    end
-
-    # Get or set paths to include in $LOAD_PATH.
-    def includes(*paths)
-      @includes.concat(paths) unless paths.empty?
-      @includes
-    end
-
-    #
-    def namespaces(*names)
-      @namespaces.concat(names) unless names.empty?
-      @namespaces
-    end
-
-    # Instance of OptionParser.
-    def parser
-      @parser ||= OptionParser.new do |opt|
-        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("--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)
-        end
-        opt.on("-I [PATH]" , "include in $LOAD_PATH") do |path|
-          path = path.split(/[:;]/)
-          includes(*path)
-        end
-        opt.on("--debug" , "turn on debugging mode") do
-          $DEBUG = true
-        end
-        opt.on_tail("--help", "-h", "show this help message") do
-          puts opt
-          exit
-        end
-      end
-    end
-
-    # Generate test skeletons.
-    def run
-      parser.parse!
-
-      test_files = ARGV.dup
-
-      includes.each{ |path| $LOAD_PATH.unshift(path) }
-      requires.each{ |path| require(path) }
-
-      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
-
-end
-end
-

data/work/deprecated/command/test.rb

@@ -1,112 +0,0 @@
-module Lemon
-module Command
-  require 'lemon/command/abstract'
-
-  # Lemon Test Command-line tool.
-  class Test < Abstract
-    require 'lemon/runner'
-
-    def self.subcommand
-      'test'
-    end
-
-    # Initialize and run.
-    def self.run
-      new.run
-    end
-
-    # New Command instance.
-    def initialize
-      @format      = nil
-      @cover       = false
-      @requires    = []
-      @includes    = []
-      @namespaces  = []
-    end
-
-    #
-    attr_accessor :format
-
-    #
-    attr_accessor :cover
-
-    # Get or set librarires to pre-require.
-    def requires(*paths)
-      @requires.concat(paths) unless paths.empty?
-      @requires
-    end
-
-    # Get or set paths to include in $LOAD_PATH.
-    def includes(*paths)
-      @includes.concat(paths) unless paths.empty?
-      @includes
-    end
-
-    #
-    def namespaces(*names)
-      @namespaces.concat(names) unless names.empty?
-      @namespaces
-    end
-
-    # Instance of OptionParser.
-    def parser
-      @parser ||= OptionParser.new do |opt|
-        opt.banner = "lemon [options] [test-files ...]"
-        opt.separator("Run unit tests.")
-        opt.separator("OPTIONS:")
-        #opt.on('--coverage', '-c', "include coverage informarton") do
-        #  self.cover = true
-        #end
-        opt.on('--verbose', '-v', "select verbose report format") do |type|
-          self.format = :verbose
-        end
-        opt.on('--outline', '-o', "select outline report format") do |type|
-          self.format = :outline
-        end
-        opt.on('--format', '-f [TYPE]', "select report format") do |type|
-          self.format = type
-        end
-        opt.on("--namespace", "-n [NAME]", "limit testing to this namespace") do |name|
-          namespaces(name)
-        end
-        opt.on("-r [FILES]" , 'library files to require') do |files|
-          files = files.split(/[:;]/)
-          requires(*files)
-        end
-        opt.on("-I [PATH]" , 'include in $LOAD_PATH') do |path|
-          paths = path.split(/[:;]/)
-          includes(*paths)
-        end
-        opt.on("--debug" , 'turn on debugging mode') do
-          $DEBUG = true
-        end
-        opt.on_tail('--help', '-h', 'show this help message') do
-          puts opt
-          exit
-        end
-      end
-    end
-
-    # Run unit tests.
-    def run
-      parser.parse!
-
-      files = ARGV.dup
-
-      includes.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)
-
-      suite  = Lemon::Test::Suite.new(files)
-      runner = Lemon::Runner.new(suite, :format=>format, :namespaces=>namespaces)
-
-      runner.run
-    end
-
-  end
-
-end
-end
-

data/work/deprecated/cucumber.yml

@@ -1,3 +0,0 @@
-default: features
-profile: --format profile features
-log: --format progress --format html --out=log/cucumber/index.html features

data/work/deprecated/features/coverage.feature

@@ -1,65 +0,0 @@
-Feature: Coverage
-  As a developer
-  In order to improve test coverge
-  I want to able to write tests with coverage in mind
-  And receive effective coverage reports
-
-  Scenario: Complete Example Case
-    Given a directory named "example"
-    Given a file named "example/lib/example.rb" with:
-      """
-      class X
-        def a; "a"; end
-        def b; "b"; end
-        def c; "c"; end
-      end
-      class Y
-        def q; "q"; end
-      end
-      """
-    Given a file named "example/test/case_complete.rb" with:
-      """
-      Covers 'example'
-      TestCase X do
-        Unit :a => "Returns a String" do ; end
-        Unit :b => "Returns a String" do ; end
-        Unit :c => "Returns a String" do ; end
-      end
-      TestCase Y do
-        Unit :q => "Returns a String" do ; end
-      end
-      """
-    When I cd to "example"
-    And I run "lemon -c -Ilib test/case_complete.rb"
-    Then the stdout should contain "0 uncovered cases"
-    And the stdout should contain "0/4 uncovered"
-    And the stdout should contain "0 undefined units"
-
-  Scenario: Incomplete Example Case
-    Given a directory named "example"
-    Given a file named "example/lib/example.rb" with:
-      """
-      class X
-        def a; "a"; end
-        def b; "b"; end
-        def c; "c"; end
-      end
-      class Y
-        def q; "q"; end
-      end
-      """
-    Given a file named "example/test/case_incomplete.rb" with:
-      """
-      Covers 'example'
-      TestCase X do
-        Unit :a => "Returns a String" do ; end
-        Unit :b => "Returns a String" do ; end
-        Unit :d => "Returns a String" do ; end
-      end
-      """
-    When I cd to "example"
-    And I run "lemon -c -Ilib test/case_incomplete.rb"
-    Then the stdout should contain "1 uncovered cases"
-    And the stdout should contain "1/4 uncovered"
-    And the stdout should contain "1 undefined units"
-