lime 0.2.0 → 0.3.0

data/.ruby

@@ -1,16 +1,15 @@
 ---
+source:
+- meta
 authors:
-- name: Thomas Sawyer
+- name: Trans
   email: transfire@gmail.com
 copyrights:
-- holder: Thomas Sawyer
+- holder: Rubyworks
   year: '2011'
   license: BSD-2-Clause
-replacements: []
-conflicts: []
 requirements:
-- name: test
-- name: ae
+- name: rubytest
 - name: detroit
   groups:
   - build
@@ -23,7 +22,13 @@ requirements:
   groups:
   - test
   development: true
+- name: ae
+  groups:
+  - test
+  development: true
 dependencies: []
+alternatives: []
+conflicts: []
 repositories:
 - uri: git://github.com/proutils/lime.git
   scm: git
@@ -31,18 +36,19 @@ repositories:
 resources:
   home: http://rubyworks.github.com/lime
   code: http://github.com/rubyworks/lime
-  mail: http://groups.google.com/group/rubyworks-mailinglist
+  bugs: http://github.com/rubyworks/lime/issues
+  mail: http://groups.google.com/groups/rubyworks-mailinglist
+extra: {}
 load_path:
 - lib
-extra:
-  manifest: MANIFEST
-alternatives: []
 revision: 0
+created: '2011-08-11'
+summary: Pure Ruby Gherkin-style Test Framework
 title: Lime
-suite: RubyWorks
-summary: Gherkin-style Test Framework
-description: Lime is a pure Ruby variation of Cucumber's Gherkin BDD test system that
-  runs on top of the Ruby Universal Test Harness.
-version: 0.2.0
+version: 0.3.0
 name: lime
-date: '2011-08-11'
+description: ! 'Lime is a pure Ruby variation of Cucumber''s Gherkin BDD test system
+
+  that runs on top of RubyTest, a Universal Test Harness for Ruby.'
+organization: Rubyworks
+date: '2012-03-03'

data/HISTORY.md

@@ -1,5 +1,18 @@
 # Release History
 
+## 0.3.0 / 2012-03-03
+
+Fix execution scope so that method definitions in Featurettes
+are visible to advice procedures. Also will automatically require
+any `*.rb` files in `featurettes` directory relative to feature
+file.
+
+Changes:
+
+* Fix execution scope so that featurettes are included.
+* Automatically require featurette files.
+* Alias #I to #We.
+
 
 ## 0.2.0 / 2011-08-11
 

data/LICENSE.txt

@@ -1,6 +1,8 @@
-BSD 2 Clause License
+Lime, Pure-Ruby Gherkin-style BDD Test Framework 
 
-Copyright 2011 Thomas Sawyer. All rights reserved.
+Copyright 2011 Rubyworks. All rights reserved.
+
+(BSD-2-Clause License)
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

data/README.md

@@ -1,16 +1,20 @@
 # Lime
 
-Author:: Thomas Sawyer
-License:: FreeBSD
-Copyright:: (c) 2011 Thomas Sawyer, Rubyworks
+[Website](http://rubyworks.github.com/lime) /
+[Source Code](http://github.com/rubyworks/lime) /
+[Report Issue](http://github.com/rubyworks/lime/issues) /
+[Mailing List](http://groups.google.com/groups/rubyworks-mailinglist)
 
 
 ## Description
 
-Lime is pure Ruby Gherkin-style test framework.
+Lime is pure-Ruby Gherkin-style test framework.
 
 
-## Example
+## Instruction
+
+Lime lets you write features scripts using Ruby, yet still do
+so with a close approximation to Gherkin domain language.
 
 ``` ruby
 Feature "Addition" do
@@ -54,12 +58,50 @@ Feature "Addition" do
 end
 ```
 
+The last set of `Given` and `When` procedures are called the *advice definitions*. These
+can be placed in their own modules and included into the Feature scope like any other module.
+They simply need to include the `Lime::Featurette` module to do so. For instance:
+
+```ruby
+module CalculatorAdvice
+  include Lime::Featurette
+
+  Given 'I have a calculator' do
+    require 'calculator'
+    @calculator = Calculator.new
+  end
+
+  Given 'I have entered (((\d+))) into the calculator' do |n|
+    @calculator.push n.to_i
+  end
+
+  When 'I press add' do
+    @result = @calculator.add
+  end
+
+  Then 'the result should be (((\d+))) on the screen' do |n|
+    @result.assert == n.to_i
+  end
+end
+```
+
+If you add such scripts to a subdirectory called `featurettes` relative to the
+feature that uses them, then they will be loaded automatically when features
+are run.
+
+Speaking of which, to run features use the `rubytest` command line tool.
+
+```
+$ rubytest -Ilib spec/feature_addition.rb
+```
+
+See [RubyTest](http://rubyworks.github.com/rubytest) to learn more.
+
 
 ## Copyrights
 
-Copyright (c) 2011 Thomas Sawyer, Rubyworks
+Copyright (c) 2011 Rubyworks
 
 Lime is distributed according to the terms of the *FreeBSD* license.
 
-See COPYING.rdoc for details.
-
+See LICENSE.txt for details.

data/lib/lime.rb

@@ -1,8 +1,8 @@
 # Ignore lime paths in backtraces
 ignore_path   = File.expand_path(File.dirname(__FILE__) + '/lime')
 ignore_regexp = Regexp.new(Regexp.escape(ignore_path))
-RUBY_IGNORE_CALLERS = [] unless defined? RUBY_IGNORE_CALLERS
-RUBY_IGNORE_CALLERS << ignore_regexp
+$RUBY_IGNORE_CALLERS ||= []
+$RUBY_IGNORE_CALLERS << ignore_regexp
 
 # Make sure the global test array is defined.
 $TEST_SUITE ||= []
@@ -15,15 +15,33 @@ module Lime
   require 'lime/step'
 
   # Toplevel DSL.
+  #
   module DSL
 
+    #
     # Define a feature.
+    #
     def Feature(label, &block)
+      require_featurettes(File.dirname(caller[0]))
+
       $TEST_SUITE << Lime::Feature.new(:label=>label, &block)
     end
 
     alias :feature :Feature
 
+    #
+    # Require any featurettes located in `{feature_dir}/featurettes` directory.
+    #
+    def require_featurettes(feature_dir)
+      featurettes_dir = File.join(feature_dir, 'featurettes')
+      if File.directory?(featurettes_dir)
+        featurette_files = Dir[File.join(featurettes_dir, '*.rb')]
+        featurette_files.each do |file|
+          require file
+        end
+      end
+    end
+
   end
 
 end

data/lib/lime/feature.rb

@@ -4,6 +4,7 @@ module Lime
   require 'lime/world'
   require 'lime/advice'
   require 'lime/scenario'
+  require 'lime/featurette'
 
   # Features contain scenarios.
   #
@@ -38,8 +39,11 @@ module Lime
       @story     = []
       @scenarios = []
 
-      @scope = Scope.new(self)
-      @scope.module_eval(&block)
+      @scope = Scope.new(self, &block)
+
+      @scenarios.each do |scenario|
+        scenario.scope.__send__(:extend, @scope)
+      end
     end
 
     # Convenience method for accessing advice, aka step definitions.
@@ -70,20 +74,22 @@ module Lime
 
     #
     def update(mixin)
-      @advice[:given].concat mixin[:given] || []
-      @advice[:when].concat  mixin[:when]  || []
-      @advice[:then].concat  mixin[:then]  || []
-      @scope.extend mixin if Module === mixin
+      @advice[:given].update( mixin[:given] || {} )
+      @advice[:when].update(  mixin[:when]  || {} )
+      @advice[:then].update(  mixin[:then]  || {} )
+
+      #@scope.__send__(:include, mixin) if Module === mixin
     end
 
     #
     class Scope < World
 
       #
-      def initialize(feature) #, &code)
+      def initialize(feature, &block)
         @_feature = feature
         @_skip    = false
-        #module_eval(&code)
+
+        module_eval(&block) if block
       end
 
       #
@@ -107,6 +113,11 @@ module Lime
 
       alias :we :We
 
+      alias :I  :We
+      alias :i  :I
+
+      #
+      # Define a Scenario.
       #
       def Scenario(label, &procedure)
         scenario = Scenario.new(
@@ -167,86 +178,22 @@ module Lime
         @_skip = reason
       end
 
-      # Is this necessary?
+      #
+      # Access to underlying feature instance.
+      #
       def _feature
         @_feature
       end
 
+      #
+      # Include module and if a Featurette, also update Feature instance.
       #
       def include(mixin)
-        if Featurable === mixin
+        if Featurette === mixin
           @_feature.update(mixin)
-          super(mixin)
-        else
-          super(mixin)
         end
+        super(mixin)
       end
-
-    end
-
-    # Convenience method for creating a feature mixin.
-    #
-    # @example
-    #
-    #   module MyStepDefinitions
-    #     include Lime::Featurette
-    #
-    #     Given "customer's name is '(((\s+)))'" do |name|
-    #       @name = name
-    #     end
-    #   end
-    #
-    #   Feature do
-    #     include MyStepDefinitions
-    #   end
-    #
-    module Featurette
-
-      def self.append_features(base)
-        base.extend(self)
-        base.module_eval %{
-          @_advice = Hash.new{ |h,k| h[k]={} }
-        }
-      end
-
-      # Given ...
-      #
-      # @param [String] description
-      #   A brief description of the _given_ criteria.
-      #
-      def Given(description, &procedure)
-        @_advice[:given][description] = procedure
-      end
-
-      alias :given :Given
-
-      # When ...
-      #
-      # @param [String] description
-      #   A brief description of the _when_ criteria.
-      #
-      def When(description, &procedure)
-        @_advice[:when][description] = procedure
-      end
-
-      alias :wence :When
-
-      # Then ...
-      #
-      # @param [String] description
-      #   A brief description of the _then_ criteria.
-      #
-      def Then(description, &procedure)
-        @_advice[:then][description] = procedure
-      end
-
-      alias :hence :Then
-
-      # Access to advice.
-      def [](key)
-        @_advice[key]
-      end
-
     end
 
   end

data/lib/lime/featurette.rb

@@ -0,0 +1,68 @@
+module Lime
+
+  # Convenience method for creating a feature mixin.
+  #
+  # @example
+  #
+  #   module MyStepDefinitions
+  #     include Lime::Featurette
+  #
+  #     Given "customer's name is '(((\s+)))'" do |name|
+  #       @name = name
+  #     end
+  #   end
+  #
+  #   Feature do
+  #     include MyStepDefinitions
+  #   end
+  #
+  module Featurette
+
+    def self.append_features(base)
+      base.extend(self)
+      base.module_eval %{
+        @_advice = Hash.new{ |h,k| h[k] = {} }
+      }
+    end
+
+    # Given ...
+    #
+    # @param [String] description
+    #   A brief description of the _given_ criteria.
+    #
+    def Given(description, &procedure)
+      @_advice[:given][description] = procedure
+    end
+
+    alias :given :Given
+
+    # When ...
+    #
+    # @param [String] description
+    #   A brief description of the _when_ criteria.
+    #
+    def When(description, &procedure)
+      @_advice[:when][description] = procedure
+    end
+
+    alias :wence :When
+
+    # Then ...
+    #
+    # @param [String] description
+    #   A brief description of the _then_ criteria.
+    #
+    def Then(description, &procedure)
+      @_advice[:then][description] = procedure
+    end
+
+    alias :hence :Then
+
+    # Access to advice.
+    def [](key)
+      @_advice[key]
+    end
+
+  end
+
+end

data/lib/lime/scenario.rb

@@ -14,8 +14,7 @@ module Lime
 
       @steps   = []
 
-      @scope = Scope.new(self)
-      @scope.module_eval(&block)
+      @scope = Scope.new(self, &block)
     end
 
     # Parent feature.
@@ -66,7 +65,9 @@ module Lime
     def topic
     end
 
+    #
     # Run a step in the context of this scenario.
+    #
     def run(step)
       type = step.type
       desc = step.label
@@ -82,6 +83,7 @@ module Lime
     #  features.clauses[@type].find{ |c| c =~ @description }
     #end
 
+    #
     # Convert matching string into a regular expression. If the string
     # contains parentheticals, e.g. `(.*?)`, the text within them is
     # treated as a case-insensitve back-referenceing regular expression
@@ -89,6 +91,7 @@ module Lime
     #
     # To use a regular expression, but leave the resulting match out of
     # the backreferences use `?:`, e.g. `(?:\d+)`.
+    #
     def match_regexp(str)
       ## the old way required double and triple parens
       #str = str.split(/(\(\(.*?\)\))(?!\))/).map{ |x|
@@ -102,15 +105,17 @@ module Lime
     end
 
     # TODO: Need to ensure the correct order of Given, When, Then.
+
+    #
     class Scope < Module
 
       #
-      def initialize(scenario) #, &code)
+      def initialize(scenario, &block)
         @scenario = scenario
 
-        extend(scenario.feature.scope)
+        #include(scenario.feature.scope)
 
-        #module_eval(&code)
+        module_eval(&block)
       end
 
       # Given ...