macros4cuke 0.0.01

data/HISTORY.md

@@ -0,0 +1,4 @@
+## [0.0.01]
+
+### New features
+* Initial public working version

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2013 Dimitri Geshef
+
+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.md

@@ -0,0 +1,10 @@
+Macros4Cuke
+===========
+
+## Add macros to your Cucumber feature files. ##
+[Homepage](https://github.com/famished-tiger/Macros4Cuke)
+
+
+Copyright
+---------
+Copyright (c) 2013, Dimitri Geshef. See [LICENSE.txt](https://github.com/famished-tiger/Macros4Cuke/blob/master/LICENSE.txt) for details.

data/cucumber.yml

@@ -0,0 +1,10 @@
+default: --strict -v -b  --format progress features
+html: --strict -v -b  --format html --out result.html features
+pdf: --strict -v -b  --format pdf --out result.pdf features
+stepdefs: --strict -v -b  --format stepdefs --out stepdefs.txt features
+rerun: --strict -v -b  --format rerun --out rerun.txt features
+tag_cloud: --strict -v -b  --format tag_cloud --out tag_cloud.txt features
+usage: --strict -v -b  --format usage --out usage.txt features
+
+
+

data/features/demo01.feature

@@ -0,0 +1,35 @@
+# File: demo01.feature
+
+Feature: Show the use of a basic macro
+  As a Cuke user
+  So that I enjoy writing scenario.
+
+# The background section is THE good place to define your macros.
+# Since the steps from this section are pre-pended to the steps of every scenario (outline),
+# the macros will be available to every scenario in the feature file.
+Background:
+  # The next step creates a macro(-step)
+  # The syntax of the new macro-step is specified between the < ... > delimiters.
+  # The steps to execute when the macro is used/invoked are listed in the multiline triple quotes arguments.
+  Given I define the step <When I [log in]> to mean:
+  """
+  Given I landed in the homepage
+  When I click "Sign in"
+  And I fill in "Username" with "johndoe"
+  And I fill in "Password" with "unguessable"
+  And I click "Submit"
+  """
+
+Scenario: Let's use the macro we created above
+  # Here the macro is invoked
+  When I [log in]
+
+  # The next step verifies that the steps from the macro were effectively executed.
+  Then I expect the following step trace:
+  """
+Invoked step: ... I landed in the homepage
+Invoked step: ... I click "Sign in"
+Invoked step: ... I fill in "Username" with "johndoe"
+Invoked step: ... I fill in "Password" with "unguessable"
+Invoked step: ... I click "Submit"
+  """

data/features/demo02.feature

@@ -0,0 +1,36 @@
+# File: demo02.feature
+
+Feature: Show the use of a basic macro with one argument
+  As a Cuke user
+  So that I enjoy writing scenario.
+
+# The background section is THE good place to define your macros.
+# Since the steps from this section are pre-pended to the steps of every scenario (outline),
+# the macros will be available to every scenario in the feature file.
+Background:
+  # The next step creates a macro(-step)
+  # The syntax of the new macro-step is specified between the < ... > delimiters.
+  # The steps to execute when the macro is used/invoked are listed in the multiline triple quotes arguments.
+  # The macro argument is put between double(triple) curly braces {{...}} as required by the Mustache template library.
+  Given I define the step <When I [log in as {{userid}}]> to mean:
+  """
+  Given I landed in the homepage
+  When I click "Sign in"
+  And I fill in "Username" with "{{userid}}"
+  And I fill in "Password" with "unguessable"
+  And I click "Submit"
+  """
+
+Scenario: Let's use the macro we created above
+  # Here the macro is invoked. Actual value for the argument is put between double quotes.
+  When I [log in as "guest"]
+
+  # The next step verifies that the steps from the macro were effectively executed.
+  Then I expect the following step trace:
+  """
+Invoked step: ... I landed in the homepage
+Invoked step: ... I click "Sign in"
+Invoked step: ... I fill in "Username" with "guest"
+Invoked step: ... I fill in "Password" with "unguessable"
+Invoked step: ... I click "Submit"
+  """

data/features/demo03.feature

@@ -0,0 +1,56 @@
+# File: demo03.feature
+
+Feature: Show the use of a basic macro with multiple arguments
+  As a Cuke user
+  So that I enjoy writing scenario.
+
+# The background section is THE good place to define your macros.
+# Since the steps from this section are pre-pended to the steps of every scenario (outline),
+# the macros will be available to every scenario in the feature file.
+Background:
+  # The next step creates a macro(-step)
+  # The syntax of the new macro-step is specified between the < ... > delimiters.
+  # The steps to execute when the macro is used/invoked are listed in the multiline triple quotes arguments.
+  # The macro argument is put between double(triple) curly braces {{...}} as required by the Mustache template library.
+  Given I define the step <When I [enter my userid {{userid}} and password {{password}}]> to mean:
+  """
+  Given I landed in the homepage
+  When I click "Sign in"
+  And I fill in "Username" with "{{userid}}"
+  And I fill in "Password" with "{{password}}"
+  And I click "Submit"
+  """
+
+Scenario: Let's use the macro we created above
+  # Here the macro is invoked. Actual value for the argument is put between double quotes.
+  When I [enter my userid "guest" and password "unguessable"]
+
+  # The next step verifies that the steps from the macro were effectively executed.
+  Then I expect the following step trace:
+  """
+Invoked step: ... I landed in the homepage
+Invoked step: ... I click "Sign in"
+Invoked step: ... I fill in "Username" with "guest"
+Invoked step: ... I fill in "Password" with "unguessable"
+Invoked step: ... I click "Submit"
+  """
+
+Scenario: A macro invoking another macro (YES, it's possible!)
+  Given I define the step <When I [enter my credentials]> to mean:
+  """
+  {{! Notice that the next step is invoking the first macro above}}
+  When I [enter my userid "guest" and password "unguessable"]
+  """
+
+  # Invoking our lastly-created macro
+  When I [enter my credentials]
+
+  # Check that the nested macro still works
+  Then I expect the following step trace:
+  """
+Invoked step: ... I landed in the homepage
+Invoked step: ... I click "Sign in"
+Invoked step: ... I fill in "Username" with "guest"
+Invoked step: ... I fill in "Password" with "unguessable"
+Invoked step: ... I click "Submit"
+  """

data/features/demo04.feature

@@ -0,0 +1,38 @@
+# File: demo04.feature
+
+Feature: Show the use of a macro with multiple arguments in a table
+  As a Cuke user
+  So that I enjoy writing scenario.
+
+# The background section is THE good place to define your macros.
+# Since the steps from this section are pre-pended to the steps of every scenario (outline),
+# the macros will be available to every scenario in the feature file.
+Background:
+  # The next step creates a macro(-step)
+  # The syntax of the new macro-step is specified between the < ... > delimiters.
+  # The steps to execute when the macro is used/invoked are listed in the multiline triple quotes arguments.
+  # The macro argument is put between double(triple) curly braces {{...}} as required by the Mustache template library.
+  Given I define the step <When I [enter my credentials as]:> to mean:
+  """
+  Given I landed in the homepage
+  When I click "Sign in"
+  And I fill in "Username" with "{{userid}}"
+  And I fill in "Password" with "{{password}}"
+  And I click "Submit"
+  """
+
+Scenario: # Let's use the macro we created above
+  # Here the macro is invoked. Actual value for the argument are passed in a table argument.
+  When I [enter my credentials as]:
+  |userid|guest|
+  |password|unguessable|
+
+  # The next step verifies that the steps from the macro were effectively executed.
+  Then I expect the following step trace:
+  """
+Invoked step: ... I landed in the homepage
+Invoked step: ... I click "Sign in"
+Invoked step: ... I fill in "Username" with "guest"
+Invoked step: ... I fill in "Password" with "unguessable"
+Invoked step: ... I click "Submit"
+  """

data/features/step_definitions/demo_steps.rb

@@ -0,0 +1,38 @@
+# File: demo_steps.rb
+# A few step definitions for demo and testing purpose.
+
+When(/^I landed in the homepage$/) do
+  trace_steps << %Q|Invoked step: ... I landed in the homepage|
+end
+
+When(/^I click "([^"]*)"$/) do |element|
+  trace_steps << %Q|Invoked step: ... I click "#{element}"|
+end
+
+
+When(/^I fill in "(.*?)" with "(.*?)"$/) do |element, text|
+  trace_steps << %Q|Invoked step: ... I fill in "#{element}" with "#{text}"|
+end
+
+
+Then(/^I expect the following step trace:$/) do |step_text|
+  trace_steps.should == step_text.split(/\r?\n|\n/)
+end
+
+
+When(/^I leave (.+)$/) do |city|
+  trace_steps << %Q|Invoked step: ... I leave #{city}|
+end
+
+
+When(/^I visit (.+)$/) do |city|
+  trace_steps << %Q|Invoked step: ... I visit #{city}|
+end
+
+
+When(/^I arrive in (.+)$/) do |city|
+  trace_steps << %Q|Invoked step: ... I arrive in #{city}|
+end
+
+
+# End of file

data/features/step_definitions/use_macro_steps.rb

@@ -0,0 +1,8 @@
+# File: use_macro_steps.rb
+# Place a copy of this file in the feature/step_definitions folder of your own Cucumber-based project.
+
+# The following require will load the step definitions from Macros4Cuke.
+# This allows feature file authors to use macro steps in their Cucumber scenarios.
+require 'macros4cuke/../macro_steps'
+
+# End of file

data/features/support/env.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8	You should see a paragraph character: §
+# File: env.rb
+# Purpose: Allow Cucumber to load the sample application configuration and hooks.
+# It also demonstrate what to do in your env.rb file to use the Macros4Cuke gem.
+
+
+# Macros4Cuke step one: Load modules and classes from the gem.
+require 'macros4cuke'  
+
+
+module Macros4Cuke  # Use the module as a namespace
+
+=begin 
+ Class created just for testing and demonstration purposes.
+ Its instance, will record the output emitted by the steps.
+=end
+class TracingWorld
+  # Will contain the text emitted by the steps
+  attr_reader(:trace_steps)
+  
+  
+  def initialize()
+    # Constructor  
+    @trace_steps = []
+  end
+  
+public
+
+  
+end # class
+
+end # module
+
+# For testing purpose we override the default Cucumber behaviour
+# making our world object an instance of the TracingWorld class
+World { Macros4Cuke::TracingWorld.new }
+
+
+
+# Macros4Cuke step two: extend the world object with the mix-in module
+# that adds the support for macros in Cucumber.
+World(Macros4Cuke::MacroStepSupport)
+
+# That's all folks!...
+
+
+# End of file

data/lib/macro_steps.rb

@@ -0,0 +1,72 @@
+# File: macro_steps.rb
+# Purpose: step definitions that help to build macro-steps (i.e. a step that is equivalent to a sequence of steps)
+
+
+
+=begin This step is used to define a macro-step
+Example:
+  Given I define the step <When I [create the following {{contactType}} contact]:> to mean:
+  """
+  # In the next step we use triple curly brace in order to get un-escaped text
+  When I select "<type>" from "type"
+	When I fill in "name" with "{{{name}}}"
+	And I fill in "companyName" with "{{companyName}}"
+	And I fill in "companyName2" with "{{companyName2}}"
+  """
+=end
+Given(/^I define the step <When I \[([^\]]+\]:?)> to mean:$/) do |macro_phrase, template|
+  add_macro(macro_phrase, template)
+end
+
+=begin This step is used to invoke a simple macro-step
+# Example:
+  # Here we define a simple macro-step
+  Given I define the step <When I [fly from {{origin}} to {{destination}} via {{waypoint}}]> to mean:
+  """ 
+    When I display the text "Departure: {{origin}}."
+    When I display the text "Stop at: {{waypoint}}."
+    When I display the text "Destination {{destination}}."
+  """
+=end
+When(/^I \[([^\]]+\])$/) do |macro_phrase|
+  macro = find_macro(macro_phrase) 
+  raise StandardError, "Undefined macro step for '[#{macro_phrase}'." if macro.nil?
+  
+  # Retrieve macro argument names and their associated value from the table
+  params = macro.validate_params(macro_phrase, nil)
+
+  # Render the steps
+  rendered_steps = macro.expand(params)
+  
+  # Execute the steps
+  steps(rendered_steps)
+end
+
+
+# This step is used to invoke a macro-step with a table argument.
+# Example:
+#  When I [create the following "Registrant" contact]:
+#  |name|John Doe|
+#  |city|Gotham City|
+#  |street| Main street|
+#  |street3| Small street|
+When(/^I \[([^\]]+\]:)$/) do |macro_phrase, table_argument|
+  macro = find_macro(macro_phrase) 
+  raise StandardError, "Undefined macro step for '#{macro_phrase}'." if macro.nil?
+  
+  unless table_argument.kind_of?(Cucumber::Ast::Table)
+     raise StandardError, "This step must have a table as an argument."
+  end
+  
+  # Retrieve macro argument names and their associated value from the table
+  params = macro.validate_params(macro_phrase, table_argument.rows_hash())
+
+  # Render the steps
+  rendered_steps = macro.expand(params)
+  
+  # Execute the steps
+  steps(rendered_steps)
+end
+
+
+# End of file

data/lib/macros4cuke/constants.rb

@@ -0,0 +1,21 @@
+# File: constants.rb
+# Purpose: definition of Macros4Cuke constants.
+
+module Macros4Cuke # Module used as a namespace
+	# This constant keeps the current version of the gem.
+	Version = '0.0.01'
+  
+  Description = "Macros for Cucumber"
+	
+	# Constant Macros4Cuke::RootDir contains the absolute path of Rodent's root directory. Note: it also ends with a slash character.
+	unless defined?(RootDir)
+    # The initialisation of constant RootDir is guarded in order to avoid multiple initialisation (not allowed for constants)  
+		RootDir = begin
+      require 'pathname'	# Load Pathname class from standard library
+      rootdir = Pathname(__FILE__).dirname.parent.parent.expand_path()
+      rootdir.to_s() + '/'	# Append trailing slash character to it     
+    end
+	end
+end # module
+
+# End of file

data/lib/macros4cuke/macro-step-support.rb

@@ -0,0 +1,50 @@
+# File: macro-step-support.rb
+
+require_relative "macro-step"
+
+module Macros4Cuke # Module used as a namespace
+
+# Mix-in module that should be extending World objects of Cucumber.
+# Synopsis (in env.rb): 
+module MacroStepSupport 
+
+  # Callback invoked when a World object is extend(ed) with this module.
+  def self.extended(world)
+    # Add & initialize an instance variable for macro support.
+    world.clear_macro_steps()
+  end
+
+  
+public
+  # Remove all macro steps
+  def clear_macro_steps()
+    @macro_steps = {}
+  end
+  
+  # Return true iff the host has a macro with the given key.
+  def has_macro?(aMacroPhrase, mode)
+    key = MacroStep::macro_key(aMacroPhrase, mode)
+    return @macro_steps.include? key
+  end
+  
+  # Add a new macro.
+  # Pre-condition: there is no existing macro with the same key.
+  def add_macro(aPhrase, aTemplate)
+    if has_macro?(aPhrase, :definition)
+      raise StandardError, "Macro step for '[#{aPhrase}' already exist."
+    else
+      new_macro = MacroStep.new(aPhrase, aTemplate)
+      @macro_steps[new_macro.name] = new_macro
+    end
+  end
+  
+  # Retrieve the macro, given a phrase.
+  def find_macro(aMacroPhrase)
+    return @macro_steps[MacroStep::macro_key(aMacroPhrase, :invokation)]
+  end
+
+end # module
+
+end # module
+
+# End of file

data/lib/macros4cuke/macro-step.rb

@@ -0,0 +1,221 @@
+# File: macro-step.rb
+# Purpose: Implementation of the MacroStep class.
+
+require 'mustache'  # Load the Mustache template library
+
+module Macros4Cuke # Module used as a namespace
+
+# In essence, a macro step object represents a Cucumber step that stands for a sequence of steps.
+class MacroStep
+  # A Mustache instance that expands the steps upon request.
+  attr_reader(:renderer)
+  
+  # Name of the macro as derived from the macro phrase.
+  attr_reader(:name)
+  
+  # The list of macro arguments that appears in the macro phrase.
+  attr_reader(:phrase_args)
+  
+  # The list of macro argument names (as appearing in the Mustache template and in the macro phrase).
+  attr_reader(:args)
+  
+  # Constructor.
+  # [aMacroPhrase]
+  # [aTemplate] The source text of the steps to be expanded upon macro invokation.
+  def initialize(aMacroPhrase, aTemplate)
+    @name = self.class.macro_key(aMacroPhrase, :definition)
+    
+    # Retrieve the macro arguments embedded in the phrase.
+    @phrase_args = scan_arguments(aMacroPhrase, :definition)
+    @args = @phrase_args.dup()
+    
+    # The expansion text is a Mustache template
+    @renderer = Mustache.new
+    renderer.template = aTemplate
+    
+    # Retrieve the Mustache tag names from the template and add them as macro arguments    
+    add_tags_multi(renderer.template.tokens())
+    @args = @args.flatten.uniq.sort
+  end
+  
+  
+  # Compute the identifier of the macro from the given macro phrase.
+  # A macro phrase is a text that must start with a recognised verb and may contain zero or more placeholders.
+  # In definition mode, a placeholder is delimited by double or triple mustaches (accolades)
+  # In invokation mode, a placeholder is delimited by double quotes.
+  # The rule for building the identifier are:
+  # - Leading and trailing space(s) are removed.
+  # - Every sequence of one or more space(s) is converted into an underscore
+  # - Each placeholder (i.e. = delimiters + enclosed text) is converted into a letter X.
+  # - The endings are transformed as follows: ] => '', ]: => _T 
+  # Example:
+  # Consider the macro phrase: 'create the following "contactType" contact]:'
+  # The resulting macro_key is: 'create_the_following_X_contact_T'
+  def self.macro_key(aMacroPhrase, mode)
+    stripped_phrase = aMacroPhrase.strip # Remove leading ... trailing space(s)
+    
+    
+    # Replace all consecutive whitespaces by an underscore    
+    stripped_phrase.gsub!(/\s+/, '_')
+    
+    
+    # Determine the pattern to isolate each argument/paramter with its delimiters
+    pattern = case mode
+      when :definition
+        /\{{2,3}[^}]*\}{2,3}/
+      when :invokation
+        /"[^"]*"/
+    end
+    
+    # Each text between quotes or mustaches is replaced by the letter X
+    normalized = stripped_phrase.gsub(pattern, 'X')
+    
+    # Drop the "]" ending or replace the "]:# ending by "_T"
+    key = if normalized.end_with?("]")
+      normalized.chop()
+    else
+      normalized.sub(/\]:/, '_T')
+    end
+    
+    return key
+  end  
+  
+  
+  # Render the steps from the template, given the values
+  # taken by the parameters
+  # [macro_parameters] a Hash with pairs of the kind: macro argument name => value
+  def expand(macro_parameters)
+    return renderer.render(macro_parameters)
+  end
+
+  
+  # Build a Hash from the given raw data.
+  # [aPhrase] an instance of the macro phrase.
+  # [rawData] An Array of couples.
+  # Each couple is of the form: argument name, a value.
+  # Multiple rows with same argument name are acceptable.
+  def validate_params(aPhrase, rawData)
+    macro_parameters = {}
+    
+    # Retrieve the value(s) per variable in the phrase.
+    quoted_values = scan_arguments(aPhrase, :invokation)
+    quoted_values.each_with_index do |val, index|
+      macro_parameters[phrase_args[index]] = val
+    end
+    
+
+    unless rawData.nil?
+      rawData.each do |(key, value)|
+        raise StandardError,"Unknown macro argument #{key}." unless @args.include? key
+        if macro_parameters.include? key
+          if macro_parameters[key].kind_of?(Array)
+             macro_parameters[key] << value
+          else
+            macro_parameters[key] = [macro_parameters[key], value]
+          end
+        else
+          macro_parameters[key] = value
+        end
+      end
+    end
+    
+    return macro_parameters
+  end
+
+  
+private
+  # Retrieve from the macro phrase, all the text between "mustaches" or double quotes.
+  # Returns an array. Each of its elements corresponds to quoted text.
+  # Example:
+  # aMacroPhrase = 'a "qualifier" text with "quantity" placeholders.'
+  # Results in : ["qualifier", "quantity"]
+  # [aMacroPhrase] A phrase
+  # [mode] one of the following: :definition, :invokation
+  def scan_arguments(aMacroPhrase, mode)
+    # determine the syntax of the arguments/parameters
+    # as a regular expression with one capturing group
+    pattern = case mode
+      when :definition
+        /{{{([^}]*)}}}|{{([^}]*)}}/ # Two capturing groups!...
+      when :invokation
+        /"([^"]*)"/
+      else
+        raise Standard, "Internal error: Unknown mode argument #{mode}"
+    end
+    raw_result = aMacroPhrase.scan(pattern)
+    return raw_result.flatten.compact
+  end
+
+  # Visit an array of tokens of which the first element is the :multi symbol.
+  # Every found template variable is added to the 'args' attribute.
+  # [tokens] An array that begins with the :multi symbol
+  def add_tags_multi(tokens)
+    first_token = tokens.shift
+    unless first_token == :multi
+      raise StandardError, "Expecting a :multi token instead of a #{first_token}"
+    end
+    
+    tokens.each do |an_opcode|
+      case an_opcode[0]
+        when :static
+          # Do nothing...
+          
+        when :mustache
+          add_tags_mustache(an_opcode)
+          
+        when String
+          #Do nothing...
+        else
+          raise StandardError, "Unknown Mustache token type #{an_opcode.first}"
+      end
+    end
+  end
+  
+  # [mustache_opcode] An array with the first element being :mustache
+  def add_tags_mustache(mustache_opcode)
+    mustache_opcode.shift() # Drop the :mustache symbol
+    
+    case mustache_opcode[0]
+      when :etag
+        triplet = mustache_opcode[1]
+        raise StandardError, "expected 'mustache' token instead of '#{triplet[0]}'" unless triplet[0] == :mustache
+        raise StandardError, "expected 'fetch' token instead of '#{triplet[1]}'" unless triplet[1] == :fetch
+        @args << triplet.last
+        
+      when :fetch
+        @args << mustache_opcode.last
+      
+      when :section
+        add_tags_section(mustache_opcode)
+
+      else
+        raise StandardError, "Unknown Mustache token type #{mustache_opcode.first}"        
+    end
+  end
+  
+  
+  def add_tags_section(opcodes)
+    opcodes.shift() # Drop the :section symbol
+    
+    opcodes.each do |op|
+      case op[0]
+        when :mustache
+          add_tags_mustache(op)
+          
+        when :multi
+          add_tags_multi(op)
+          
+        when String
+          return
+        else
+          raise StandardError, "Unknown Mustache token type #{op.first}"
+      end
+    end
+  end
+  
+end # class
+
+end # module
+
+
+# End of file

data/lib/macros4cuke.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8 -- You should see a paragraph character: §
+# File: macros4cuke.rb
+# This file acts as a jumping-off point for loading dependencies expected for a Macros4Cuke user.
+
+require_relative './macros4cuke/constants'
+require_relative './macros4cuke/macro-step-support'
+
+# End of file

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: macros4cuke
+version: !ruby/object:Gem::Version
+  version: 0.0.01
+  prerelease: 
+platform: ruby
+authors:
+- Dimitri Geshef
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mustache
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "\tMacros4Cuke is a lightweight library that adds a macro facility
+  your Cucumber scenarios.\n  In short, you will be able to create new steps that
+  will replace a sequence of lower-level steps. \n"
+email: famished.tiger@yahoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- cucumber.yml
+- HISTORY.md
+- LICENSE.txt
+- README.md
+- lib/macros4cuke.rb
+- lib/macro_steps.rb
+- lib/macros4cuke/constants.rb
+- lib/macros4cuke/macro-step-support.rb
+- lib/macros4cuke/macro-step.rb
+- features/demo01.feature
+- features/demo02.feature
+- features/demo03.feature
+- features/demo04.feature
+- features/step_definitions/demo_steps.rb
+- features/step_definitions/use_macro_steps.rb
+- features/support/env.rb
+homepage: https://github.com/famished-tiger/Macros4Cuke
+licenses: []
+post_install_message: ! '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  Thank you for installing Macros4Cuke...
+
+  Enjoy using Cucumber with macros...
+
+  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+'
+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.24
+signing_key: 
+specification_version: 3
+summary: Macros for Cucumber
+test_files: []