macros4cuke 0.1.07 → 0.2.00

data/HISTORY.md

@@ -1,3 +1,15 @@
+## [0.2.00] Version number was bumped
+### Changes:
+* Replaced the Mustache template engine by own lightweight TemplateEngine
+* Macro-step arguments have a syntax that is closer to Gherkin's scenario outlines.
+* Upgraded TemplateEngine class to become a simple templating system.
+* Remove dependency to mustache gem.
+
+### Documentation:
+* All demos updated to new syntax.
+* Updated the examples in README.md
+
+
 ## [0.1.07]
 ### Changes:
 * Added new class TemplateEngine.

data/README.md

@@ -19,19 +19,18 @@ To each macro-step, it is possible to associate a sequence of sub-steps
 ## Synopsis ##
 Here is an example taken from our demo files:  
 ```cucumber
-  Given I define the step "When I [enter my userid {{userid}} and password {{password}}]" to mean:  
+  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 fill in "Username" with "<userid>"  
+  And I fill in "Password" with "<password>"  
   And I click "Submit"  
   """  
 ```
 
-Notice how the arguments are enclosed between curly braces {{..}}. In its current incarnation,
-Macros4Cuke relies on the [Mustache](http://mustache.github.io/mustache.5.html) template engine
- for generating the sub-steps.
+Notice how the arguments _userid_ and _password_ are enclosed between chevrons (angle brackets) <...>.
+
 
 That macro-step can then be used in a scenario like this:  
 ```cucumber
@@ -73,7 +72,7 @@ World(Macros4Cuke::MacroStepSupport)
   
 * Step 3: Import the macro-management steps  
 In your /features/step_definitions/ folder:  
-  - Create a ruby file (say, 'use\_macro\_steps.rb') with the following line:  
+  - Create a Ruby file (say, 'use\_macro\_steps.rb') with the following line:  
   
 ```ruby  
 require 'macros4cuke/../macro_steps'

data/features/demo02.feature

@@ -9,12 +9,12 @@ Scenario: Creating a basic scenario with one argument
   # The next step creates a macro(-step)
   # The syntax of the new macro-step is specified between the double quotes.
   # 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:
+  # The macro argument is put between chevrons <...>.
+  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 "Username" with "<userid>"
   And I fill in "Password" with "unguessable"
   And I click "Submit"
   """

data/features/demo03.feature

@@ -8,13 +8,13 @@ Feature: Show the use of a basic macro with multiple arguments
 Scenario: defining basic macro with multiple arguments
   # The next step creates a macro(-step)double quotes.
   # 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:
+  # The macro-step arguments are put between chevrons <...>.
+  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 fill in "Username" with "<userid>"
+  And I fill in "Password" with "<password>"
   And I click "Submit"
   """
 
@@ -35,7 +35,7 @@ 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}}
+  # Notice that the next step is invoking the first macro above
   When I [enter my userid "guest" and password "unguessable"]
   """
 

data/features/demo04.feature

@@ -9,13 +9,13 @@ Scenario: Defining a macro to be used with multiple arguments in a table
   # The next step creates a macro(-step)
   # The syntax of the new macro-step is specified between double quotes.
   # 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.
+  # The macro arguments are put between chevrons <...>.
   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 fill in "Username" with "<userid>"
+  And I fill in "Password" with "<password>"
   And I click "Submit"
   """
 

data/features/travelling-demo.feature

@@ -6,10 +6,10 @@ Feature: Show -visually- the several ways to use macros
 
 
 Scenario: Definition of a simple macro-step with two arguments
-  Given I define the step "When I [travel from {{origin}} to {{destination}}]" to mean:
+  Given I define the step "When I [travel from <origin> to <destination>]" to mean:
   """
-  When I leave {{origin}}
-  And I arrive in {{destination}}
+  When I leave <origin>
+  And I arrive in <destination>
   """
 
 Scenario: Do a simple travel
@@ -23,16 +23,15 @@ Scenario: Do a simple travel
   # Actual values can have embedded double quotes provided they are escaped.
   When I [travel from "Tampa" to "\"Little Italy\""]  
   
-  # Notice the HTML-escaping done by Mustache
 
 
 
 Scenario: Defining a macro calling other macro(s)
-  Given I define the step "When I [travel from {{origin}} to {{destination}} and back]" to mean:
+  Given I define the step "When I [travel from <origin> to <destination> and back]" to mean:
   """
   # The next two steps are, in fact, macro-step invokations
-  When I [travel from "{{origin}}" to "{{destination}}"]
-  When I [travel from "{{destination}}" to "{{origin}}"]
+  When I [travel from "<origin>" to "<destination>"]
+  When I [travel from "{{destination}}" to "<origin>"]
   """
 
 Scenario: Do a travel back and forth
@@ -48,12 +47,12 @@ Scenario: Do a travel back and forth
 Scenario: Defining a macro that requires a data table
   Given I define the step "When I [fill in the form with]:" to mean:
   """
-  When I type "{{firstname}}"
-  And I type "{{lastname}}"
-  And I type "{{street_address}}"
-  And I type "{{postcode}}"
-  And I type "{{city}}"
-  And I type "{{country}}"
+  When I type "<firstname>"
+  And I type "<lastname>"
+  And I type "<street_address>"
+  And I type "<postcode>"
+  And I type "<city>"
+  And I type "<country>"
   """
 
 Scenario: Using a macro-step with a data table
@@ -96,10 +95,10 @@ Scenario: Demonstrate that it is possible to use a sub-step with a data table
   Given I define the step "When I [fill in, as a Londonian, the form with]:" to mean:
   """
   When I [fill in the form with]:
-  |firstname| {{firstname}}|
-  |lastname | {{lastname}} |
-  |street_address| {{street_address}}|
-  |postcode|{{postcode}} |
+  |firstname| <firstname>|
+  |lastname | <lastname> |
+  |street_address| <street_address>|
+  |postcode|<postcode> |
   # The next two lines have hard-coded values
   |city    |London   |  
   |country | U.K.    |

data/lib/macro_steps.rb

@@ -5,11 +5,11 @@
 
 # This step is used to define a macro-step
 # Example:
-#  Given I define the step "When I [log in as {{userid}}]" to mean:
+#  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 "Username" with "<userid>"
 #  And I fill in "Password" with "unguessable"
 #  And I click "Submit"
 #  """

data/lib/macros4cuke/constants.rb

@@ -3,7 +3,7 @@
 
 module Macros4Cuke # Module used as a namespace
 	# This constant keeps the current version of the gem.
-	Version = '0.1.07'
+	Version = '0.2.00'
   
   Description = "Macros for Cucumber"
 	

data/lib/macros4cuke/macro-step.rb

@@ -1,243 +1,174 @@
-# 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 is itself
-# an aggregation of lower-level Cucumber 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] The text from the macro step definition that is between the square brackets.
-  # [theSubsteps] The source text of the steps to be expanded upon macro invokation.
-  def initialize(aMacroPhrase, theSubsteps)
-    @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()
-    
-    # Manipulate the substeps source text (e.g. remove comment lines)
-    substeps_processed = preprocess(theSubsteps)
-    
-    # The expansion text is a Mustache template
-    @renderer = Mustache.new
-    renderer.template = substeps_processed
-    
-    # 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.
-  # - Each underscore character is 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)
-    
-    # Remove every underscore
-    stripped_phrase.gsub!(/_/, '')
-    
-    # Replace all consecutive whitespaces by an underscore    
-    stripped_phrase.gsub!(/\s+/, '_')
-    
-    
-    # Determine the pattern to isolate each argument/parameter 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 UnknownArgumentError.new(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 InternalError, "Internal error: Unknown mode argument #{mode}"
-    end
-    raw_result = aMacroPhrase.scan(pattern)
-    return raw_result.flatten.compact
-  end
-  
-  # Return the substeps text after some transformation
-  # [theSubstepsSource] The source text of the steps to be expanded upon macro invokation.
-  def preprocess(theSubstepsSource)
-    # Split text into lines
-    lines = theSubstepsSource.split(/\r\n?|\n/)
-    
-    # Reject comment lines. This necessary because Cucumber::RbSupport::RbWorld#steps complains when it sees a comment.
-    processed = lines.reject { |a_line| a_line =~ /\s*#/ }
-    
-    return processed.join("\n")
-  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 InternalError, "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 InternalError, "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 InternalError, "expected 'mustache' token instead of '#{triplet[0]}'" unless triplet[0] == :mustache
-        raise InternalError, "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 InternalError, "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 InternalError, "Unknown Mustache token type #{op.first}"
-      end
-    end
-  end
-  
-end # class
-
-end # module
-
-
+# File: macro-step.rb
+# Purpose: Implementation of the MacroStep class.
+
+
+require_relative 'template-engine'
+
+module Macros4Cuke # Module used as a namespace
+
+# In essence, a macro step object represents a Cucumber step that is itself
+# an aggregation of lower-level Cucumber steps.
+class MacroStep
+  # A template engine that expands the substeps 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 substeps and in the macro phrase).
+  attr_reader(:args)
+
+  
+  # Constructor.
+  # [aMacroPhrase] The text from the macro step definition that is between the square brackets.
+  # [theSubsteps] The source text of the steps to be expanded upon macro invokation.
+  def initialize(aMacroPhrase, theSubsteps)
+    @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()
+    
+    # Manipulate the substeps source text
+    substeps_processed = preprocess(theSubsteps)
+
+    @renderer = TemplateEngine.new(substeps_processed)
+    @args.concat(renderer.variables)
+    @args.uniq!
+  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 chevrons <..>
+  # In invokation mode, a placeholder is delimited by double quotes.
+  # The rule for building the identifier are:
+  # - Leading and trailing space(s) are removed.
+  # - Each underscore character is 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)
+    
+    # Remove every underscore
+    stripped_phrase.gsub!(/_/, '')
+    
+    # Replace all consecutive whitespaces by an underscore    
+    stripped_phrase.gsub!(/\s+/, '_')
+    
+    
+    # Determine the pattern to isolate each argument/parameter with its delimiters
+    pattern = case mode
+      when :definition
+        /<(?:[^\\<>]|\\.)*>/
+      when :invokation
+        /"([^\\"]|\\.)*"/
+
+    end
+    
+    # Each text between quotes or chevron 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(nil, 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 UnknownArgumentError.new(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 <..> 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 InternalError, "Internal error: Unknown mode argument #{mode}"
+    end
+    raw_result = aMacroPhrase.scan(pattern)
+    return raw_result.flatten.compact
+  end
+  
+  # Return the substeps text after some transformation
+  # [theSubstepsSource] The source text of the steps to be expanded upon macro invokation.
+  def preprocess(theSubstepsSource)
+    # Split text into lines
+    lines = theSubstepsSource.split(/\r\n?|\n/)
+    
+    # Reject comment lines. This necessary because Cucumber::RbSupport::RbWorld#steps complains when it sees a comment.
+    processed = lines.reject { |a_line| a_line =~ /\s*#/ }
+    
+    return processed.join("\n")
+  end
+
+end # class
+
+end # module
+
+
 # End of file

data/lib/macros4cuke/template-engine.rb

@@ -6,8 +6,88 @@ require 'strscan' # Use the StringScanner for lexical analysis.
 module Macros4Cuke # Module used as a namespace
 
 
+
+class StaticRep
+  attr_reader(:source)
+  
+  def initialize(aSourceText)
+    @source = aSourceText
+  end
+  
+public
+  def render(aContextObject = nil, theLocals)
+    return source
+  end
+end # class
+
+
+class VariableRep
+  attr_reader(:name)
+  
+  def initialize(aVarName)
+    @name = aVarName
+  end
+  
+public
+  # The signature of this method should comply to the Tilt API.
+  # Actual values from the 'locals' Hash take precedence over the context object.
+  def render(aContextObject, theLocals)
+    actual_value = theLocals[name]
+    if actual_value.nil?
+      actual_value = aContextObject.send(name.to_sym) if aContextObject.respond_to?(name.to_sym)
+      actual_value = '' if actual_value.nil?
+    end
+    
+    return actual_value.is_a?(String) ? actual_value : actual_value.to_s
+  end  
+  
+end # class
+
+
+class EOLRep
+public
+  def render(aContextObject, theLocals)
+    return "\n"
+  end
+end # class
+
+
 class TemplateEngine
+  # The original text of the template is kept here.
+  attr_reader(:source)
+  
+  # Constructor.
+  # [aSourceTemplate]
+  def initialize(aSourceTemplate)
+    @source = aSourceTemplate
+    @representation = compile(aSourceTemplate)
+  end
+
+public
+  def render(aContextObject = nil, theLocals)
+    return '' if @representation.empty?
+    context = aContextObject.nil? ? Object.new : aContextObject
+    
+    result = @representation.each_with_object('') do |element, subResult|
+      subResult << element.render(context, theLocals)
+    end
+    
+    return result
+  end
+  
+  # Return all variable names that appear in the template.
+  def variables()
+    # The result will be cached/memoized...
+    @variables ||= begin
+      vars = @representation.select { |element| element.is_a?(VariableRep) }
+      vars.map(&:name)
+    end
+    
+    return @variables
+  end
 
+  # Class method. Parse the given line text.
+  # Returns an array of couples.
   def self.parse(aTextLine)
     scanner = StringScanner.new(aTextLine)
     result = []
@@ -47,6 +127,43 @@ class TemplateEngine
     return result
   end
 
+private
+  # Create the internal representation of the given template.
+  def compile(aSourceTemplate)
+    # Split the input text into lines.
+    input_lines = aSourceTemplate.split(/\r\n?|\n/)
+    
+    # Parse the input text into raw data.
+    raw_lines = input_lines.map { |line| self.class.parse(line) }
+    
+    compiled_lines = raw_lines.map { |line| compile_line(line) }
+    return compiled_lines.flatten()
+  end
+  
+  
+  def compile_line(aRawLine)
+    line_rep = aRawLine.map { |couple| compile_couple(couple) }
+    line_rep << EOLRep.new
+  end
+
+  
+  # [aCouple] a two-element array of the form: [kind, text]
+  # Where kind must be one of :static, :dynamic
+  def compile_couple(aCouple)
+    (kind, text) = aCouple
+    
+    result = case kind
+      when :static
+        StaticRep.new(text) 
+      when :dynamic
+        VariableRep.new(text)
+      else
+        raise StandardError, "Internal error: Don't know template element of kind #{kind}"
+      end
+    
+    return result
+  end
+  
 end # class
 
 end # module

data/spec/macros4cuke/macro-step_spec.rb

@@ -0,0 +1,60 @@
+# File: macro-step_spec.rb
+
+
+require_relative '../spec_helper'
+require_relative '../../lib/macros4cuke/macro-step'	# The class under test
+
+
+
+module Macros4Cuke	# Open the module to avoid lengthy qualified names
+
+describe MacroStep do
+  let(:sample_phrase) { "enter my credentials as <userid>]:" }
+  let(:sample_template) do
+    snippet = <<-SNIPPET
+  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"
+SNIPPET
+
+  snippet
+end
+
+  # Default instantiation rule
+  subject { MacroStep.new(sample_phrase, sample_template) }
+
+
+  context "Creation & initialization" do
+    it "should be created with a phrase and a template" do
+      lambda { MacroStep.new(sample_phrase, sample_template) }.should_not raise_error
+    end
+
+  
+    it "should know its key/name" do
+      subject.name.should == "enter_my_credentials_as_X_T"
+    end
+  
+    it "should know the tags(placeholders) from its phrase" do
+      subject.phrase_args.should == %w[userid]
+    end
+    
+    it "should know the tags(placeholders) from its phrase and template" do
+      subject.args.should == %w[userid password]    
+    end
+    
+  end # context
+  
+  
+  context "Provided services" do
+    it "should render the substeps" do
+    end
+  end # context
+  
+
+end # describe
+
+end # module
+
+# End of file

data/spec/macros4cuke/template-engine_spec.rb

@@ -0,0 +1,205 @@
+# encoding: utf-8 -- You should see a paragraph character: §
+# File: template-engine_spec.rb
+
+require_relative '../spec_helper'
+require_relative '../../lib/macros4cuke/template-engine'	# Load the class under test
+
+module Macros4Cuke # Open this namespace to get rid of module qualifier prefixes
+
+describe TemplateEngine do
+  let(:sample_template) do
+      source = <<-SNIPPET
+  Given I landed in the homepage
+  # The credentials are entered here
+  And I fill in "Username" with "<userid>"
+  And I fill in "Password" with "<password>"
+  And I click "Sign in"
+SNIPPET
+    end
+
+  # Rule for default instantiation 
+  subject { TemplateEngine.new sample_template }
+
+
+  context "Class services" do
+    # Convenience method used to shorten method call.
+    def parse_it(aText)
+      return TemplateEngine::parse(aText)
+    end
+
+    # remove enclosing chevrons <..> (if any)
+    def strip_chevrons(aText)
+      return aText.gsub(/^<|>$/, '')
+    end
+
+    it "should parse an empty text line" do
+      # Expectation: result should be an empty array.
+      parse_it('').should be_empty
+    end
+
+    it "should parse a text line without tag" do
+      sample_text = 'Mary has a little lamb'
+      result = parse_it(sample_text)
+
+      # Expectation: an array with one couple: [:static, the source text]
+      result.should have(1).items
+      result[0].should == [:static, sample_text]
+    end
+
+    it "should parse a text line that consists of just a tag" do
+      sample_text = '<some_tag>'
+      result = parse_it(sample_text)
+
+      # Expectation: an array with one couple: [:static, the source text]
+      result.should have(1).items
+      result[0].should == [:dynamic, strip_chevrons(sample_text)]
+    end
+
+    it "should parse a text line with a tag at the start" do
+      sample_text = '<some_tag>some text'
+      result = parse_it(sample_text)
+
+      # Expectation: an array with two couples: [dynamic, 'some_tag'][:static, some text]
+      result.should have(2).items
+      result[0].should == [:dynamic, 'some_tag']
+      result[1].should == [:static,  'some text']
+    end
+
+    it "should parse a text line with a tag at the end" do
+      sample_text = 'some text<some_tag>'
+      result = parse_it(sample_text)
+
+      # Expectation: an array with two couples: [:static, some text] [dynamic, 'some_tag']
+      result.should have(2).items
+      result[0].should == [:static,  'some text']
+      result[1].should == [:dynamic, 'some_tag']
+    end
+
+    it "should parse a text line with a tag in the middle" do
+      sample_text = 'begin <some_tag> end'
+      result = parse_it(sample_text)
+
+      # Expectation: an array with three couples:
+      result.should have(3).items
+      result[0].should == [:static,  'begin ']
+      result[1].should == [:dynamic, 'some_tag']
+      result[2].should == [:static,  ' end']
+    end
+
+    it "should parse a text line with two tags in the middle" do
+      sample_text = 'begin <some_tag>middle<another_tag> end'
+      result = parse_it(sample_text)
+
+      # Expectation: an array with items couples:
+      result.should have(5).items
+      result[0].should == [:static ,  'begin ']
+      result[1].should == [:dynamic, 'some_tag']
+      result[2].should == [:static , 'middle']
+      result[3].should == [:dynamic, 'another_tag']
+      result[4].should == [:static,  ' end']
+
+      # Case: two consecutive tags
+      sample_text = 'begin <some_tag><another_tag> end'
+      result = parse_it(sample_text)
+
+      # Expectation: an array with four couples:
+      result.should have(4).items
+      result[0].should == [:static,  'begin ']
+      result[1].should == [:dynamic, 'some_tag']
+      result[2].should == [:dynamic, 'another_tag']
+      result[3].should == [:static,  ' end']
+    end
+
+    it "should parse a text line with escaped chevrons" do
+      sample_text = 'Mary has a \<little\> lamb'
+      result = parse_it(sample_text)
+
+      # Expectation: an array with one couple: [:static, the source text]
+      result.should have(1).items
+      result[0].should == [:static, sample_text]
+    end
+
+    it "should parse a text line with escaped chevrons in a tag" do
+      sample_text = 'begin <some_\<\\>weird\>_tag> end'
+      result = parse_it(sample_text)
+
+      # Expectation: an array with three couples:
+      result.should have(3).items
+      result[0].should == [:static,  'begin ']
+      result[1].should == [:dynamic, 'some_\<\\>weird\>_tag']
+      result[2].should == [:static,  ' end']
+    end
+
+    it "should complain if a tag misses an closing chevron" do
+      sample_text = 'begin <some_tag\> end'
+      error_message = "Missing closing chevron '>'."
+      lambda { parse_it(sample_text) }.should raise_error(StandardError, error_message)
+    end
+
+  end # context
+
+  context "Creation and initialization" do
+
+    it "should accept an empty template text" do
+      lambda { TemplateEngine.new '' }.should_not raise_error
+    end
+
+    it "should be created with a template text" do
+      lambda { TemplateEngine.new sample_template }.should_not raise_error
+    end
+
+    it "should know the source text" do
+      subject.source.should == sample_template
+
+      # Case of an empty template
+      instance = TemplateEngine.new ''
+      instance.source.should be_empty
+    end
+  end
+  
+  context "Provided services" do
+  
+    it "should know the variable(s) it contains" do
+      subject.variables == [:userid, :password]
+
+      # Case of an empty source template text
+      instance = TemplateEngine.new ''
+      instance.variables.should be_empty
+    end
+    
+    it "should render the text given the actuals" do
+      locals = {'userid' => "johndoe"}
+      
+      rendered_text = subject.render(nil, locals)
+      expected = <<-SNIPPET
+  Given I landed in the homepage
+  # The credentials are entered here
+  And I fill in "Username" with "johndoe"
+  And I fill in "Password" with ""
+  And I click "Sign in"
+SNIPPET
+
+      # Place actual value in context object
+      Context = Struct.new(:userid, :password)
+      context = Context.new("sherlock", "holmes")
+      rendered_text = subject.render(context, {'userid' => 'susan'})
+      expected = <<-SNIPPET
+  Given I landed in the homepage
+  # The credentials are entered here
+  And I fill in "Username" with "susan"
+  And I fill in "Password" with "holmes"
+  And I click "Sign in"
+SNIPPET
+      
+
+      # Case of an empty source template text
+      instance = TemplateEngine.new ''
+      instance.render(nil, {}).should be_empty
+    end
+  end
+
+end # describe
+
+end # module
+
+# End of file

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+# File: spec_helper.rb
+# Purpose: utility file that is loaded by all our RSpec files
+
+
+require 'rspec'	# Use the RSpec framework
+require 'pp'	# Use pretty-print for debugging purposes
+
+# End of file

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: macros4cuke
 version: !ruby/object:Gem::Version
-  version: 0.1.07
+  version: 0.2.00
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-24 00:00:00.000000000 Z
+date: 2013-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -43,25 +43,10 @@ dependencies:
     - - ! '>='
       - !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 can create new steps that replace a sequence
-  of lower-level steps. \n"
+  your Cucumber scenarios.\n  In short, you can create any new step that replaces
+  a sequence of lower-level steps.\n  All this can be done directly in your feature
+  files without programming step definitions.\n"
 email: famished.tiger@yahoo.com
 executables: []
 extensions: []
@@ -88,6 +73,9 @@ files:
 - features/step_definitions/use_macro_steps.rb
 - features/support/env.rb
 - features/support/macro_support.rb
+- spec/spec_helper.rb
+- spec/macros4cuke/macro-step_spec.rb
+- spec/macros4cuke/template-engine_spec.rb
 homepage: https://github.com/famished-tiger/Macros4Cuke
 licenses: []
 post_install_message: ! '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~