macros4cuke 0.3.42 → 0.4.00

data/lib/macros4cuke/macro-step.rb

@@ -23,6 +23,9 @@ class MacroStep
   # A template engine that expands the sub-steps upon request.
   attr_reader(:renderer)
   
+  # The sentence fragment that defines the syntax of the macro-step
+  attr_reader(:phrase)
+  
   # Unique key of the macro as derived from the macro phrase.
   attr_reader(:key)
   
@@ -30,7 +33,7 @@ class MacroStep
   attr_reader(:phrase_args)
   
   # The list of macro argument names (as appearing in the substeps 
-  # and in the macro phrase).
+  # AND in the macro phrase).
   attr_reader(:args)
   
   # Constructor.
@@ -41,15 +44,12 @@ class MacroStep
   # @param useTable [boolean] A flag indicating whether a data table 
   #   must be used to pass actual values.
   def initialize(aMacroPhrase, theSubsteps, useTable)
+    @phrase = aMacroPhrase
     @key = self.class.macro_key(aMacroPhrase, useTable, :definition)
 
     # Retrieve the macro arguments embedded in the phrase.
     @phrase_args = scan_arguments(aMacroPhrase, :definition)
-
-    # Manipulate the substeps source text
-    substeps_processed = preprocess(theSubsteps)
-
-    @renderer = Templating::Engine.new(substeps_processed)
+    @renderer = Templating::Engine.new(theSubsteps)
     substeps_vars = renderer.variables
 
 
@@ -165,17 +165,15 @@ private
   # @param params [Hash] The pairs phrase argument name => value
   def validate_row(a_row, params)
     (a_key, value) = a_row
-    raise UnknownArgumentError.new(a_key) unless args.include? a_key
+    fail(UnknownArgumentError.new(a_key)) unless args.include? a_key
     if (phrase_args.include? a_key) && (params[a_key] != value)
-      raise AmbiguousArgumentValue.new(a_key, params[a_key], value)        
+      fail(AmbiguousArgumentValue.new(a_key, params[a_key], value))       
     end 
     
     return a_row
   end
 
 
-
-
   # Retrieve from the macro phrase, all the text between <..> or double quotes.
   # Returns an array. Each of its elements corresponds to quoted text.
   # Example:
@@ -201,20 +199,6 @@ private
     
     return args
   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 is 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
   
   # Check for inconsistencies between the argument names 
   # in the phrase and the substeps part.
@@ -222,7 +206,7 @@ private
     # Error when the phrase names an argument that never occurs in the substeps
     thePhraseArgs.each do |phrase_arg|
       unless substepsVars.include? phrase_arg
-        raise UselessPhraseArgument.new(phrase_arg)
+        fail(UselessPhraseArgument.new(phrase_arg))
       end
     end 
     # Error when a substep has an argument that never appears in the phrase 
@@ -231,7 +215,7 @@ private
       substepsVars.each do |substep_arg|
         unless thePhraseArgs.include?(substep_arg) ||
         BuiltinParameters.include?(substep_arg)
-          raise UnreachableSubstepArgument.new(substep_arg) 
+          fail(UnreachableSubstepArgument.new(substep_arg))
         end
       end      
     end

data/lib/macros4cuke/templating/engine.rb

@@ -38,6 +38,34 @@ class StaticText
 end # class
 
 
+# Class used internally by the template engine.  
+# Represents a comment from a template.  
+# A static text is a text that is reproduced verbatim 
+# when rendering a template.
+class Comment
+  # The comment as extracted from the original template.
+  attr_reader(:source)
+  
+
+  # @param aSourceText [String] A piece of text extracted 
+  #   from the template that must be rendered verbatim.
+  def initialize(aSourceText)
+    @source = aSourceText
+  end
+
+  public
+
+  # Render the comment.
+  # Comments are rendered as empty text. This is necessary because
+  # Cucumber::RbSupport::RbWorld#steps complains when it sees a comment.
+  # This method has the same signature as the {Engine#render} method.
+  # @return [String] Empty string ("as is")
+  def render(aContextObject, theLocals)
+    return ''
+  end
+end # class
+
+
 # Class used internally by the template engine.  
 # Represents an end of line that must be rendered as such.
 class EOLine
@@ -160,7 +188,7 @@ class Section  < UnaryElement
   #   Returns an empty string when no value is assigned to the placeholder.
   def render(aContextObject, theLocals)
     msg = "Method Section.#{__method__} must be implemented in subclass."
-    raise NotImplementedError, msg
+    fail(NotImplementedError, msg)
   end    
 
 end # class
@@ -239,6 +267,9 @@ class Engine
   # The original text of the template is kept here.
   attr_reader(:source)
   
+  # The internal representation of the template text
+  attr_reader(:representation)
+  
   # Builds an Engine and compiles the given template text into
   #  an internal representation.
   # @param aSourceTemplate [String] The template source text. 
@@ -260,11 +291,19 @@ public
   #  the passed argument values.
   def render(aContextObject = Object.new, theLocals)
     return '' if @representation.empty?
-    
+
+    prev = nil
     result = @representation.each_with_object('') do |element, subResult|
-      subResult << element.render(aContextObject, theLocals)
+      # Output compaction rules:
+      # -In case of consecutive eol's only one is rendered.
+      # -In case of comment followed by one eol, both aren't rendered
+      unless element.is_a?(EOLine) && 
+        (prev.is_a?(EOLine) || prev.is_a?(Comment))
+        subResult << element.render(aContextObject, theLocals)
+      end
+      prev = element
     end
-    
+
     return result
   end
 
@@ -295,24 +334,28 @@ public
 
   # Class method. Parse the given line text into a raw representation.
   # @return [Array] Couples of the form:
-  # [:static, text] or [:dynamic, tag text]
+  # [:static, text], [:comment, text] or [:dynamic, tag text]
   def self.parse(aTextLine)
     scanner = StringScanner.new(aTextLine)
     result = []
-    
-    until scanner.eos?
-      # Scan tag at current position...
-      tag_literal = scanner.scan(/<(?:[^\\<>]|\\.)*>/)
-      unless tag_literal.nil?
-        result << [:dynamic, tag_literal.gsub(/^<|>$/, '')] 
+
+    if scanner.check(/\s*#/)  # Detect comment line
+      result << [:comment, aTextLine]
+    else
+      until scanner.eos?
+        # Scan tag at current position...
+        tag_literal = scanner.scan(/<(?:[^\\<>]|\\.)*>/)
+        unless tag_literal.nil?
+          result << [:dynamic, tag_literal.gsub(/^<|>$/, '')] 
+        end
+        
+        # ... or scan plain text at current position
+        literal = scanner.scan(/(?:[^\\<>]|\\.)+/)
+        result << [:static, literal] unless literal.nil? 
+        identify_parse_error(aTextLine) if tag_literal.nil? && literal.nil?
       end
-      
-      # ... or scan plain text at current position
-      text_literal = scanner.scan(/(?:[^\\<>]|\\.)+/)
-      result << [:static, text_literal] unless text_literal.nil? 
-      identify_parse_error(aTextLine) if tag_literal.nil? && text_literal.nil?
     end
-    
+
     return result
   end
 
@@ -336,11 +379,11 @@ private
       when '>' then unbalance -= 1              
       end
       
-      raise StandardError, "Nested opening chevron '<'." if unbalance > 1
-      raise StandardError, "Missing opening chevron '<'." if unbalance < 0
+      fail(StandardError, "Nested opening chevron '<'.") if unbalance > 1
+      fail(StandardError, "Missing opening chevron '<'.") if unbalance < 0
     end
     
-    raise StandardError, "Missing closing chevron '>'." if unbalance == 1 
+    fail(StandardError, "Missing closing chevron '>'.") if unbalance == 1 
   end
   
   
@@ -355,7 +398,7 @@ private
       line_items.each do |(kind, text)|
         # A tag text cannot be empty nor blank
         if (kind == :dynamic) && text.strip.empty?
-          raise EmptyArgumentError.new(line.strip)
+          fail(EmptyArgumentError.new(line.strip))
         end
       end
       
@@ -390,7 +433,7 @@ private
         false
       end
     end
-    if line_to_squeeze && ! section_item.nil?
+    if line_to_squeeze && !section_item.nil?
       line_rep = [section_item]
     else
       line_rep_ending(line_rep)
@@ -398,7 +441,7 @@ private
     
     return line_rep
   end
-  
+
 
   # Apply rule: if last item in line is an end of section marker, 
   # then place eoline before that item. 
@@ -418,15 +461,17 @@ private
   # Where kind must be one of :static, :dynamic
   def compile_couple(aCouple)
     (kind, text) = aCouple
-    
+
     result = case kind
     when :static then StaticText.new(text)
+    when :comment then Comment.new(text)
     when :dynamic then parse_tag(text)
     end
 
     return result
   end
-  
+
+
   # Parse the contents of a tag entry.
   # @param aText [String] The text that is enclosed between chevrons.
   def parse_tag(aText)
@@ -437,7 +482,7 @@ private
       # Disallow punctuation and delimiter signs in tags.
       matching = DisallowedSigns.match(aText)
     end
-    raise InvalidCharError.new(aText, matching[0]) if matching
+    fail(InvalidCharError.new(aText, matching[0])) if matching
     
     result = case aText[0, 1]
       when '?'
@@ -477,7 +522,7 @@ private
     
     unless open_sections.empty?
       error_message =  "Unterminated section #{open_sections.last}."
-      raise StandardError, error_message
+      fail(StandardError, error_message)
     end
     
     return compiled
@@ -490,11 +535,11 @@ private
     
     if sections.empty?
       msg = 'found while no corresponding section is open.'
-      raise StandardError, msg_prefix + msg
+      fail(StandardError, msg_prefix + msg)
     end
     if marker.name != sections.last.name
       msg = "doesn't match current section '#{sections.last.name}'."
-      raise StandardError, msg_prefix + msg
+      fail(StandardError, msg_prefix + msg)
     end
   end
  

data/spec/macros4cuke/coll-walker-factory_spec.rb

@@ -0,0 +1,269 @@
+# File: collection-walker_spec.rb
+
+require_relative '../spec_helper'
+
+# Load mix-in module for creating a sample collection of macro-steps
+require_relative 'use-sample-collection'
+
+# Load the class under test
+require_relative '../../lib/macros4cuke/coll-walker-factory'
+
+module Macros4Cuke # Open this namespace to avoid module qualifier prefixes
+
+describe CollWalkerFactory do
+  include UseSampleCollection # Add convenience methods for sample collection
+
+
+  before(:all) do
+    # Fill the collection of macro-steps with sample steps
+    fill_collection
+  end
+
+  after(:all) do
+  # Clear the collection to prevent interference between spec files 
+    macro_coll.clear
+  end
+
+  context 'Initialization:' do
+    it 'should be created without parameter' do
+      expect { CollWalkerFactory.new }.not_to raise_error
+    end
+
+  end # context
+
+  context 'Provided factory services:' do
+    # Default factory instantiation
+    subject { CollWalkerFactory.new }
+
+    it 'should build a walker for the given macro collection' do
+      walker = subject.build_walker(macro_coll)
+      expect(walker).to be_kind_of(Enumerator)
+    end
+  end # context
+
+  context 'Provided walker services:' do
+    # Default walker instantiation
+    subject do
+      factory = CollWalkerFactory.new
+      factory.build_walker(macro_coll)
+    end
+
+
+    it 'should notify the start of the visit of the collection' do
+      initial_event = subject.next
+      expect(initial_event).to eq([:on_collection, 0, macro_coll])
+    end
+
+    it 'should notify the visit of a first macro step' do
+       1.times { subject.next }
+      first_step = subject.next
+      step1 = macro_coll.macro_steps.values[0]
+      expect(first_step).to eq([:on_step, 1, step1])
+    end
+
+    it 'should notify the visit of the phrase of the first macro step' do
+      2.times { subject.next }
+      first_phrase = subject.next
+      sample_phrase1 = UseSampleCollection::SamplePhrase1
+      expect(first_phrase).to eq([:on_phrase, 2, sample_phrase1, true])
+    end
+
+    it 'should notify the visit of the substeps renderer of the first step' do
+      3.times { subject.next }
+      first_step = macro_coll.macro_steps.values[0]
+      first_renderer = subject.next
+      expectation = [:on_renderer, 2, first_step.renderer]
+      expect(first_renderer).to eq(expectation)
+    end
+
+    it 'should notify the visit of the internal representation of substeps' do
+      first_step = macro_coll.macro_steps.values[0]
+      substep_chunks = first_step.renderer.representation
+      4.times { subject.next }
+      text_representation = subject.next
+      expectation = [:on_source, 3, first_step.renderer.source]
+      expect(text_representation).to eq(expectation)
+
+      first_substep_piece = subject.next
+      expectation = [:on_static_text, 3, substep_chunks[0].source]
+      expect(first_substep_piece).to eq(expectation)
+
+      second_substep_piece = subject.next
+      expect(second_substep_piece).to eq([:on_eol, 3, nil])
+
+      third_substep_piece = subject.next
+      expectation = [:on_static_text, 3, substep_chunks[2].source]
+      expect(third_substep_piece).to eq(expectation)
+
+      fourth_substep_piece = subject.next
+      expect(fourth_substep_piece).to eq([:on_eol, 3, nil])
+
+      fifth_substep_piece = subject.next
+      expectation = [:on_static_text, 3, substep_chunks[4].source]
+      expect(fifth_substep_piece).to eq(expectation)
+
+      sixth_substep_piece = subject.next
+      expectation = [:on_placeholder, 3, substep_chunks[5].name]
+      expect(sixth_substep_piece).to eq(expectation)
+
+      seventh_substep_piece = subject.next
+      expectation = [:on_static_text, 3, substep_chunks[6].source]
+      expect(seventh_substep_piece).to eq(expectation)
+
+      eighth_substep_piece = subject.next
+      expect(eighth_substep_piece).to eq([:on_eol, 3, nil])
+
+      ninth_substep_piece = subject.next
+      expectation = [:on_static_text, 3, substep_chunks[8].source]
+      expect(ninth_substep_piece).to eq(expectation)
+
+      tenth_substep_piece = subject.next
+      expectation = [:on_placeholder, 3, substep_chunks[9].name]
+      expect(tenth_substep_piece).to eq(expectation)
+
+      eleventh_substep_piece = subject.next
+      expectation = [:on_static_text, 3, substep_chunks[10].source]
+      expect(eleventh_substep_piece).to eq(expectation)
+
+      twelfth_substep_piece = subject.next
+      expect(twelfth_substep_piece).to eq([:on_eol, 3, nil])
+
+      thirtieth_substep_piece = subject.next
+      expectation = [:on_static_text, 3, substep_chunks[12].source]
+      expect(thirtieth_substep_piece).to eq(expectation)
+
+      fourteenth_substep_piece = subject.next
+      expect(fourteenth_substep_piece).to eq([:on_eol, 3, nil])
+      
+      fifteenth_substep_piece = subject.next
+      expect(fifteenth_substep_piece).to eq([:on_renderer_end, 2, nil])
+    end
+
+    it 'should notify the visit of a following macro step' do
+      (4 + 15 + 1).times { subject.next }
+      end_step = subject.next
+      expect(end_step).to eq([:on_step_end, 1, nil])
+      a_step = subject.next
+      expect(a_step).to eq([:on_step, 1, macro_coll.macro_steps.values[1]])
+    end
+
+    it 'should notify the visit of the phrase of a following macro step' do
+      (4 + 16 + 2).times { subject.next }
+      phrase = subject.next
+      sample_phrase = UseSampleCollection::SamplePhrase2
+      expect(phrase).to eq([:on_phrase, 2, sample_phrase, true])
+    end
+
+    it 'should notify the visit of the substeps of a following step' do
+      (4 + 16 + 3).times { subject.next }
+      a_renderer = subject.next
+      second_step = macro_coll.macro_steps.values[1]
+      expect(a_renderer).to eq([:on_renderer, 2, second_step.renderer])
+    end
+
+    it 'should notify the visit in substeps of following step' do
+      second_step = macro_coll.macro_steps.values[1]
+      substep_chunks = second_step.renderer.representation.dup
+      substep_chunks.map! do |ck|
+        if ck.kind_of?(Templating::Section)
+          [ck, ck.children, ck].flatten
+        else
+          ck
+        end
+      end
+      substep_chunks.flatten!
+
+      (4 + 16 + 4).times { subject.next }
+      substeps_text = subject.next
+      expectation = [:on_source, 3, second_step.renderer.source]
+      expect(substeps_text).to eq(expectation)
+
+      first_substep_piece = subject.next
+      expectation = [:on_static_text, 3, substep_chunks[0].source]
+      expect(first_substep_piece).to eq(expectation)
+
+      [
+        [:on_placeholder, 3, :name], # 0
+        [:on_static_text, 3, :source], # 1
+        [:on_eol, 3, nil],  # 2
+        [:on_static_text, 3, :source], # 3
+        [:on_placeholder, 3, :name], # 4
+        [:on_static_text, 3, :source],  # 5
+        [:on_eol, 3, nil],  # 6
+        [:on_static_text, 3, :source],  # 7
+        [:on_placeholder, 3, :name],  # 8
+        [:on_static_text, 3, :source],  # 9
+        [:on_eol, 3, nil],  # 10
+        [:on_static_text, 3, :source],  # 11
+        [:on_placeholder, 3, :name],  # 12
+        [:on_static_text, 3, :source],  # 13
+        [:on_eol, 3, nil],  # 14
+        [:on_static_text, 3, :source],  # 15
+        [:on_placeholder, 3, :name],  # 16
+        [:on_static_text, 3, :source],  # 17
+        [:on_eol, 3, nil],  # 18
+        [:on_static_text, 3, :source],  # 19
+        [:on_placeholder, 3, :name],  # 20
+        [:on_static_text, 3, :source],  # 21
+        [:on_eol, 3, nil],  # 22
+        [:on_eol, 3, nil],  # 23
+        [:on_comment, 3, :source], # 24
+        [:on_eol, 3, nil],  # 25
+        [:on_comment, 3, :source], # 26
+        [:on_eol, 3, nil],  # 27
+        [:on_comment, 3, :source], # 28
+        [:on_eol, 3, nil],  # 29
+        [:on_section, 3, :name],  # 30
+        [:on_static_text, 4, :source],  # 31
+        [:on_placeholder, 4, :name],  # 32
+        [:on_static_text, 4, :source],  # 33
+        [:on_eol, 4, nil],  # 34
+        [:on_section_end, 3, nil],  # 35
+        [:on_eol, 3, nil],  # 36
+        [:on_comment, 3, :source], # 37
+        [:on_eol, 3, nil],  # 38
+        [:on_comment, 3, :source], # 39
+        [:on_eol, 3, nil],  # 40
+        [:on_comment, 3, :source], # 41
+        [:on_eol, 3, nil],  # 42
+        [:on_section, 3, :name],  # 43
+        [:on_static_text, 4, :source],  # 44
+        [:on_placeholder, 4, :name],  # 45
+        [:on_static_text, 4, :source],  # 46
+        [:on_eol, 4, nil],  # 47
+        [:on_section_end, 3, nil],  # 48
+        [:on_static_text, 3, :source],  # 49
+        [:on_eol, 3, nil], # 50
+        [:on_renderer_end, 2, nil],  # 51
+        [:on_step_end, 1, nil],  # 52
+        [:on_collection_end, 0, nil] # 53
+      ].each_with_index do |event, i|
+        actual = subject.next
+        expect(actual[0]).to eq(event[0])
+        expect(actual[1]).to eq(event[1])
+        unless event[2].nil?
+          expected_obj = substep_chunks[i + 1]
+          expect(actual[2]).to eq(expected_obj.send(event[2]))
+        end
+      end
+      expect { subject.next }.to raise_error(StopIteration)
+
+    end
+    
+    # Must be last test script since it pollutes the macro-collection
+    it 'should complain when visiting an unsupported node' do
+      first_step = macro_coll.macro_steps.values[0]
+      first_step.renderer.representation.insert(2, :not_a_valid_element)
+      err_type = Macros4Cuke::InternalError
+      err_msg = "Don't know how to format a Symbol."
+      expect { subject.each { |x| } }.to raise_error(err_type, err_msg)
+    end
+
+  end # context
+
+end # describe
+
+end # module
+
+
+# End of file