lime 0.1.0

data/.gitignore

@@ -0,0 +1,7 @@
+.yardoc
+doc
+log
+pkg
+tmp
+site/doc
+QED.rdoc

data/.ruby

@@ -0,0 +1,51 @@
+--- 
+authors: 
+- name: Thomas Sawyer
+  email: transfire@gmail.com
+copyrights: 
+- holder: Thomas Sawyer
+  year: "2011"
+  license: BSD-2-Clause
+replacements: []
+
+conflicts: []
+
+requirements: 
+- name: test
+- name: ae
+- name: detroit
+  groups: 
+  - build
+  development: true
+- name: reap
+  groups: 
+  - build
+  development: true
+- name: qed
+  groups: 
+  - test
+  development: true
+dependencies: []
+
+repositories: 
+- uri: git://github.com/proutils/lime.git
+  scm: git
+  name: upstream
+resources: 
+  home: http://rubyworks.github.com/lime
+  code: http://github.com/rubyworks/lime
+  mail: http://groups.google.com/group/rubyworks-mailinglist
+load_path: 
+- lib
+extra: 
+  manifest: MANIFEST
+alternatives: []
+
+revision: 0
+title: Lime
+suite: RubyWorks
+summary: Gherkin-style Test Framework
+description: Lime is a "Ruby DSL" knock-off of Cucumber's Gherkin BDD nomenclature that runs on top of ruby-test.
+version: 0.1.0
+name: lime
+date: "2011-07-29"

data/.yardopts

@@ -0,0 +1,7 @@
+--output-dir site
+--protected
+--readme README.md
+lib
+-
+[A-Z]*.*
+

data/Assembly

@@ -0,0 +1,46 @@
+---
+github:
+  active: true
+
+gem:
+  active: true
+
+dnote:
+  labels: ~
+  output: log/NOTES.rdoc
+
+yard:
+  yardopts: true
+
+qed:
+  files    : ~
+  #exclude : ~
+  #loadpath: ~
+  #requires: ~
+  #live    : false   
+  active   : false
+
+qedoc:
+  files : spec/
+  output: QED.rdoc
+  active: false
+
+vclog:
+  output: log/ChangeLog.rdoc
+  active: false
+
+email:
+  service: Email
+  file   : ~
+  subject: ~
+  mailto : 
+    - ruby-talk@ruby-lang.org
+    - rubyworks-mailinglist@googlegroups.com
+  from   : <%= ENV['EMAIL_ACCOUNT'] %>
+  server : <%= ENV['EMAIL_SERVER'] %>
+  port   : <%= ENV['EMAIL_PORT'] %>
+  account: <%= ENV['EMAIL_ACCOUNT'] %>
+  domain : <%= ENV['EMAIL_DOMAIN'] %>
+  login  : <%= ENV['EMAIL_LOGIN'] %>
+  secure : <%= ENV['EMAIL_SECURE'] %>
+

data/COPYING.rdoc

@@ -0,0 +1,59 @@
+= COPYRIGHT NOTICES
+
+== Lime Test Framework
+
+Copyright:: (c) 2011 Thomas Sawyer, RubyWorks
+License:: BSD-2-Clause
+Website:: http://rubyworks.github.com/ruby-test
+
+    Copyright 2011 Thomas Sawyer. All rights reserved.
+
+    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.
+
+
+== Gherkin
+
+Copyright:: (c) 2009-2011 Mike Sassak, Gregory Hnatiuk, Aslak Hellesøy
+License:: MIT
+Website:: https://github.com/cucumber/gherkin
+
+    Copyright (c) 2009-2011 Mike Sassak, Gregory Hnatiuk, Aslak Hellesøy
+
+    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/LICENSE.txt

@@ -0,0 +1,25 @@
+BSD 2 Clause License
+
+Copyright 2011 Thomas Sawyer. All rights reserved.
+
+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.
+

data/MANIFEST

@@ -0,0 +1,12 @@
+#!mast .ruby .yaropts bin lib spec test [A-Z][A-Z]*
+.ruby
+lib/lime/advice.rb
+lib/lime/feature.rb
+lib/lime/scenario.rb
+lib/lime/step.rb
+lib/lime.rb
+PROFILE
+LICENSE.txt
+README.md
+VERSION
+COPYING.rdoc

data/PROFILE

@@ -0,0 +1,29 @@
+--- 
+title  : Lime
+suite  : RubyWorks
+summary: Gherkin-style Test Framework
+authors:
+  - Thomas Sawyer <transfire@gmail.com>
+
+description:
+  Lime is a "Ruby DSL" knock-off of Cucumber's Gherkin
+  BDD nomenclature that runs on top of ruby-test.
+
+resources:
+  home: http://rubyworks.github.com/lime
+  code: http://github.com/rubyworks/lime
+  mail: http://groups.google.com/group/rubyworks-mailinglist
+
+repositories:
+  upstream: git://github.com/proutils/lime.git
+
+copyrights:
+  - 2011 Thomas Sawyer (BSD-2-Clause)
+
+requirements:
+  - test
+  - ae
+  - detroit  (build)
+  - reap     (build)
+  - qed      (test)
+

data/README.md

@@ -0,0 +1,65 @@
+# Lime
+
+Author:: Thomas Sawyer
+License:: FreeBSD
+Copyright:: (c) 2011 Thomas Sawyer, Rubyworks
+
+
+## Description
+
+Lime is pure Ruby Gherkin-style test framework.
+
+
+## Example
+
+``` ruby
+Feature "Addition" do
+  To "avoid silly mistakes"
+  As "a math idiot"
+  We "need to calculate the sum of numbers"
+
+  Scenario "Add two numbers" do
+    Given "I have a calculator"
+    Given "I have entered 50 into the calculator"
+    Given "I have entered 70 into the calculator"
+    When  "I press add"
+    Then  "the result should be 120 on the screen"
+  end
+
+  Scenario "Add three numbers" do
+    Given "I have a calculator"
+    Given "I have entered 50 into the calculator"
+    Given "I have entered 70 into the calculator"
+    Given "I have entered 90 into the calculator"
+    When  "I press add"
+    Then  "the result should be 2101 on the screen"
+  end
+
+  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
+```
+
+
+## Copyrights
+
+Copyright (c) 2011 Thomas Sawyer, Rubyworks
+
+Lime is distributed according to the terms of the *FreeBSD* license.
+
+See COPYING.rdoc for details.
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/lime.rb

@@ -0,0 +1,28 @@
+module Lime
+  $TEST_SUITE ||= []
+
+  require 'lime/advice'
+  require 'lime/feature'
+  require 'lime/scenario'
+  require 'lime/step'
+end
+
+# 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 << /bin\/ruby-test/
+
+module Test
+  extend self
+
+  # Define a general test case.
+  def Feature(label, &block)
+    $TEST_SUITE << Lime::Feature.new(:label=>label, &block)
+  end
+
+  alias :feature :Feature
+end
+
+extend Test

data/lib/lime/advice.rb

@@ -0,0 +1,31 @@
+module Lime
+
+  # Test Advice
+  class Advice
+
+    #
+    attr :table
+
+    # New case instance.
+    def initialize
+      @table = Hash.new{ |h,k| h[k] = {} }
+    end
+
+    #
+    def initialize_copy(original)
+      @table = original.table.clone
+    end
+
+    #
+    def [](type)
+      @table[type.to_sym]
+    end
+
+    ## Returns the description with newlines removed.
+    #def to_s
+    #  description.gsub(/\n/, ' ')
+    #end
+
+  end
+
+end

data/lib/lime/feature.rb

@@ -0,0 +1,251 @@
+#require 'lime/pending'
+require 'lime/advice'
+require 'lime/scenario'
+
+module Lime
+
+  # The TestFeature ...
+  #
+  # The `advice` are _given_, _when_ and _then_ rules.
+  #
+  class Feature
+
+    # Brief description of the feature.
+    attr :label
+
+    #
+    attr :story
+
+    # List of tests and sub-cases.
+    attr :scenarios
+
+    # Advice are labeled procedures, such as before
+    # and after advice.
+    attr :advice
+
+    # Module for evaluating tests.
+    attr :scope
+
+    #
+    def initialize(settings={}, &block)
+      @label   = settings[:label]
+      @setup   = settings[:setup]
+
+      @advice  = Advice.new
+      @scope   = Module.new
+
+      @story     = []
+      @scenarios = []
+
+      @scope.extend DSL.new(self, &block)
+    end
+
+    # Convenience method for accessing advice, aka step definitions.
+    def [](key)
+      @advice[key]
+    end
+
+    # Iterate over each scenario.
+    def each(&block)
+      scenarios.each(&block)
+    end
+
+    # Number of scenarios.
+    def size
+      scenarios.size
+    end
+
+    # Subclasses of TestCase can override this to describe
+    # the type of test case they define.
+    def type
+      'Feature'
+    end
+
+    #
+    def to_s
+      (["#{label}"] + story).join("\n")
+    end
+
+    #
+    def omit?
+      @omit
+    end
+
+    #
+    def omit=(boolean)
+      @omit = boolean
+    end
+
+    #
+    def update(mixin)
+      @advice[:given].concat mixin[:given] || []
+      @advice[:when].concat  mixin[:when]  || []
+      @advice[:then].concat  mixin[:then]  || []
+      @scope.extend mixin if Module === mixin
+    end
+
+    #
+    class DSL < Module
+
+      #
+      def initialize(feature, &code)
+        @_feature = feature
+
+        module_eval(&code)
+      end
+
+      #
+      def To(description)
+        @_feature.story << "To " + description
+      end
+      alias_method :to, :To
+
+      #
+      def As(description)
+        @_feature.story << "As " + description
+      end
+      alias_method :as, :As
+
+      #
+      def We(description)
+        @_feature.story << "We " + description
+      end
+      alias_method :we, :We
+
+      #
+      def Scenario(label, &procedure)
+        scenario = Scenario.new(@_feature, :label=>label, &procedure)
+        @_feature.scenarios << scenario
+        scenario
+      end
+      alias_method :scenario, :Scenario
+
+      # Omit a scenario from test runs.
+      #
+      #  omit unit :foo do
+      #    # ...
+      #  end
+      #
+      def Omit(scenario)
+        scenario.omit = true
+      end
+      alias_method :omit, :Omit
+
+      # Given ...
+      #
+      # @param [String] description
+      #   A brief description of the _given_ criteria.
+      #
+      def Given(description, &procedure)
+        @_feature[:given][description] = procedure
+      end
+      alias_method :given, :Given
+
+      # When ...
+      #
+      # @param [String] description
+      #   A brief description of the _when_ criteria.
+      #
+      def When(description, &procedure)
+        @_feature[:when][description] = procedure
+      end
+      alias_method :wence, :When
+
+      # Then ...
+      #
+      # @param [String] description
+      #   A brief description of the _then_ criteria.
+      #
+      def Then(description, &procedure)
+        @_feature[:then][description] = procedure
+      end
+      alias_method :hence, :Then
+
+      #
+      def _feature
+        @_feature
+      end
+
+      #
+      def include(mixin)
+        if Featurable === mixin
+          @_feature.update(mixin)
+          super(mixin)
+        else
+          super(mixin)
+        end
+      end
+
+    end
+
+    # Convenience method for creating a feature mixin.
+    #
+    # @example
+    #
+    #   module MySteps
+    #     include Lime::Featurable
+    #     Given "customer's name is '(((\s+)))'" do |name|
+    #       @name = name
+    #     end
+    #   end
+    #
+    #   Feature do
+    #     include MySteps
+    #   end
+    #
+    module Featurable
+
+      def self.append_features(base)
+        base.extend(self)
+        base.module_eval %{
+          @_advice = Hash.new { |h,k| h[k]={} }
+        }
+      end
+
+      #
+      #def initialize(&code)
+      #  @_advice = Hash.new { |h,k| h[k]={} }
+      # 
+      #  module_eval(&code)
+      #end
+
+      # Given ...
+      #
+      # @param [String] description
+      #   A brief description of the _given_ criteria.
+      #
+      def Given(description, &procedure)
+        @_advice[:given][description] = procedure
+      end
+      alias_method :given, :Given
+
+      # When ...
+      #
+      # @param [String] description
+      #   A brief description of the _when_ criteria.
+      #
+      def When(description, &procedure)
+        @_advice[:when][description] = procedure
+      end
+      alias_method :wence, :When
+
+      # Then ...
+      #
+      # @param [String] description
+      #   A brief description of the _then_ criteria.
+      #
+      def Then(description, &procedure)
+        @_advice[:then][description] = procedure
+      end
+      alias_method :hence, :Then
+
+      # Access to internal feature instance.
+      def [](key)
+        @_advice[key]
+      end
+
+    end
+
+  end
+
+end

data/lib/lime/scenario.rb

@@ -0,0 +1,160 @@
+require 'lime/step'
+
+module Lime
+
+  #
+  class Scenario
+
+    #
+    def initialize(feature, settings={}, &block)
+      @feature = feature
+
+      @label   = settings[:label]
+
+      @scope   = Module.new
+
+      @steps   = []
+
+      @scope.extend DSL.new(self, &block)
+    end
+
+    #
+    attr :feature
+
+    #
+    attr :label
+
+    #
+    attr :steps
+
+    #
+    attr :scope
+
+    #
+    def omit?
+      @omit
+    end
+
+    #
+    def omit=(boolean)
+      @omit = boolean
+    end
+
+    #
+    def each(&block)
+      @steps.each(&block)
+    end
+
+    #
+    def size(&block)
+      @steps.size
+    end
+
+    #
+    def type
+      "Scenario"
+    end
+
+    #
+    def to_s
+      @label.to_s
+    end
+
+    # FIXME
+    def subject
+    end
+
+    #
+    def run(step)
+      type = step.type
+      desc = step.label
+      feature.advice[type].each do |mask, proc|
+        if md = match_regexp(mask).match(desc)
+          scope.instance_exec(*md[1..-1], &proc)
+        end
+      end
+    end
+
+    #
+    #--
+    # TODO: Change so that the scope is the DSL
+    #       and includes the DSL of the context?
+    #++
+    #def scope
+    #  @scope ||= (
+    #    #if feature
+    #    #  scope = feature.scope || Object.new
+    #    #  scope.extend(dsl)
+    #    #else
+    #      scope = Object.new
+    #      scope.extend(dsl)
+    #    #end
+    #  )
+    #end
+
+    #
+    #def find
+    #  features.clauses[@type].find{ |c| c =~ @description }
+    #end
+
+    # Convert matching string into a regular expression. If the string
+    # contains double parenthesis, such as ((.*?)), then the text within
+    # them is treated as in regular expression and kept verbatium.
+    #
+    # TODO: Better way to isolate regexp. Maybe ?:(.*?) or /(.*?)/.
+    #
+    def match_regexp(str)
+      str = str.split(/(\(\(.*?\)\))(?!\))/).map{ |x|
+        x =~ /\A\(\((.*)\)\)\Z/ ? $1 : Regexp.escape(x)
+      }.join
+      str = str.gsub(/\\\s+/, '\s+')
+      Regexp.new(str, Regexp::IGNORECASE)
+    end
+
+    # TODO: Need to ensure the correct order of Given, When, Then.
+    class DSL < Module
+
+      #
+      def initialize(scenario, &code)
+        @scenario = scenario
+
+        extend(scenario.feature.scope)
+
+        module_eval(&code)
+      end
+
+      # Given ...
+      #
+      # @param [String] description
+      #   A matching description of the _given_ procedure.
+      #
+      def Given(label)
+        @scenario.steps << Step.new(@scenario, label, :type=>:given)
+      end
+      alias_method :given, :Given
+
+      # When ...
+      #
+      # @param [String] label
+      #   A matching description of the _when_ procedure.
+      #
+      def When(label)
+        @scenario.steps << Step.new(@scenario, label, :type=>:when)
+      end
+      alias_method :wence, :When
+
+      # Then ...
+      #
+      # @param [String] label
+      #   A matching description of the _then_ procedure.
+      #
+      def Then(label)
+        @scenario.steps << Step.new(@scenario, label, :type=>:then)
+      end
+      alias_method :hence, :Then
+
+    end
+
+  end
+
+end

data/lib/lime/step.rb

@@ -0,0 +1,64 @@
+module Lime
+
+  # Test step.
+  #
+  class Step
+
+    # New unit test procedure.
+    #
+    def initialize(scenario, label, settings={})
+      @scenario = scenario
+      @label    = label
+
+      @type     = settings[:type]
+
+      @omit     = false
+      #@tested   = false
+    end
+
+    # The type of step (:given, :when or :then).
+    attr :type
+
+    # The scenario to which this step belongs.
+    attr :scenario
+
+    # Label of test.
+    attr :label
+
+    #
+    def omit?
+      @omit
+    end
+
+    #
+    def omit=(boolean)
+      @omit = boolean
+    end
+
+    #
+    def to_s
+      "#{type.to_s.capitalize} #{label}"
+    end
+
+    # FIXME
+    def subject
+    end
+
+    #
+    def to_proc
+      lambda{ call }
+    end
+
+    #
+    #def match?(match)
+    #  match == target || match === label
+    #end
+
+    #
+    def call
+      scenario.run(self)
+    end
+
+  end
+
+end

data/lime.gemspec

@@ -0,0 +1,152 @@
+# encoding: utf-8
+
+require 'yaml'
+
+Gem::Specification.new do |gemspec|
+
+  manifest = Dir.glob('manifest{,.txt)', File::FNM_CASEFOLD).first
+
+  scm = case
+        when File.directory?('.git')
+          :git
+        end
+
+  files = case
+          when manifest
+           File.readlines(manifest).
+             map{ |line| line.srtip }.
+             reject{ |line| line.empty? || line[0,1] == '#' }
+          when scm == :git
+           `git ls-files -z`.split("\0")
+          else
+            Dir.glob('{**/}{.*,*}')  # TODO: be more specific using standard locations ?
+          end.select{ |path| File.file?(path) }
+
+  patterns = {
+    :bin_files  => 'bin/*',
+    :lib_files  => 'lib/{**/}*.rb',
+    :ext_files  => 'ext/{**/}extconf.rb',
+    :doc_files  => '*.{txt,rdoc,md,markdown,tt,textile}',
+    :test_files => '{test/{**/}*_test.rb,spec/{**/}*_spec.rb}'
+  }
+
+  glob_files = lambda { |pattern|
+    Dir.glob(pattern).select { |path|
+      File.file?(path) && files.include?(path)
+    }
+  }
+
+  #files = glob_files[patterns[:files]]
+
+  executables = glob_files[patterns[:bin_files]].map do |path|
+                  File.basename(path)
+                end
+
+  extensions = glob_files[patterns[:ext_files]].map do |path|
+                 File.basename(path)
+               end
+
+  metadata = YAML.load_file('.ruby')
+
+  # build-out the gemspec
+
+  case metadata['revision']
+  when 0
+    gemspec.name        = metadata['name']
+    gemspec.version     = metadata['version']
+    gemspec.summary     = metadata['summary']
+    gemspec.description = metadata['description']
+
+    metadata['authors'].each do |author|
+      gemspec.authors << author['name']
+
+      if author.has_key?('email')
+        if gemspec.email
+          gemspec.email << author['email']
+        else
+          gemspec.email = [author['email']]
+        end
+      end
+    end
+
+    gemspec.licenses = metadata['licenses']
+
+    metadata['requirements'].each do |req|
+      name    = req['name']
+      version = req['version']
+      groups  = req['groups'] || []
+
+      if md = /^(.*?)([+-~])$/.match(version)
+        version = case md[2]
+                    when '+' then ">= #{$1}"
+                    when '-' then "< #{$1}"
+                    when '~' then "~> #{$1}"
+                    else version
+                  end
+      end
+
+      #development = req['development']
+      #if development
+      #  # populate development dependencies
+      #  if gemspec.respond_to?(:add_development_dependency)
+      #    gemspec.add_development_dependency(name,*version)
+      #  else
+      #    gemspec.add_dependency(name,*version)
+      #  end
+      #else
+      #  # populate runtime dependencies  
+      #  if gemspec.respond_to?(:add_runtime_dependency)
+      #    gemspec.add_runtime_dependency(name,*version)
+      #  else
+      #    gemspec.add_dependency(name,*version)
+      #  end
+      #end
+
+      if groups.empty? or groups.include?('runtime')
+        # populate runtime dependencies  
+        if gemspec.respond_to?(:add_runtime_dependency)
+          gemspec.add_runtime_dependency(name,*version)
+        else
+          gemspec.add_dependency(name,*version)
+        end
+      else
+        # populate development dependencies
+        if gemspec.respond_to?(:add_development_dependency)
+          gemspec.add_development_dependency(name,*version)
+        else
+          gemspec.add_dependency(name,*version)
+        end
+      end
+    end
+
+    # convert external dependencies into a requirements
+    if metadata['external_dependencies']
+      ##gemspec.requirements = [] unless metadata['external_dependencies'].empty?
+      metadata['external_dependencies'].each do |req|
+        gemspec.requirements << req.to_s
+      end
+    end
+
+    # determine homepage from resources
+    homepage = metadata['resources'].find{ |key, url| key =~ /^home/ }
+    gemspec.homepage = homepage.last if homepage
+
+    gemspec.require_paths        = metadata['load_path'] || ['lib']
+    gemspec.post_install_message = metadata['install_message']
+
+    # RubyGems specific metadata
+    gemspec.files       = files
+    gemspec.extensions  = extensions
+    gemspec.executables = executables
+
+    if Gem::VERSION < '1.7.'
+      gemspec.default_executable = gemspec.executables.first
+    end
+
+    gemspec.test_files = glob_files[patterns[:test_files]]
+
+    unless gemspec.files.include?('.document')
+      gemspec.extra_rdoc_files = glob_files[patterns[:doc_files]]
+    end
+  end
+end

data/try/.testrb

@@ -0,0 +1,3 @@
+$:.unshift '.'
+require 'ae'
+require 'lime'

data/try/calculator.rb

@@ -0,0 +1,15 @@
+class Calculator
+
+  def initialize
+    @stack = []
+  end
+
+  def push(int)
+    @stack << int
+  end
+  
+  def add
+    @stack.inject(0){ |sum, val| sum += val; sum }
+  end
+
+end

data/try/feature_example.rb

@@ -0,0 +1,40 @@
+Test::Feature "Addition" do
+  To "avoid silly mistakes"
+  As "a math idiot"
+  We "need to calculate the sum of numbers"
+
+  Scenario "Add two numbers" do
+    Given "I have a calculator"
+    Given "I have entered 50 into the calculator"
+    Given "I have entered 70 into the calculator"
+    When  "I press add"
+    Then  "the result should be 120 on the screen"
+  end
+
+  Scenario "Add three numbers" do
+    Given "I have a calculator"
+    Given "I have entered 50 into the calculator"
+    Given "I have entered 70 into the calculator"
+    Given "I have entered 90 into the calculator"
+    When  "I press add"
+    Then  "the result should be 210 on the screen"
+  end
+
+  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
+

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification 
+name: lime
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Thomas Sawyer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-29 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: test
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ae
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: detroit
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: reap
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: qed
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Lime is a "Ruby DSL" knock-off of Cucumber's Gherkin BDD nomenclature that runs on top of ruby-test.
+email: 
+- transfire@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- COPYING.rdoc
+- README.md
+files: 
+- .gitignore
+- .ruby
+- .yardopts
+- Assembly
+- COPYING.rdoc
+- LICENSE.txt
+- MANIFEST
+- PROFILE
+- README.md
+- VERSION
+- lib/lime.rb
+- lib/lime/advice.rb
+- lib/lime/feature.rb
+- lib/lime/scenario.rb
+- lib/lime/step.rb
+- lime.gemspec
+- try/.testrb
+- try/calculator.rb
+- try/feature_example.rb
+homepage: http://rubyworks.github.com/lime
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.2
+signing_key: 
+specification_version: 3
+summary: Gherkin-style Test Framework
+test_files: []
+