cucumber 0.8.0 → 0.8.1

data/lib/cucumber/ast/table.rb

@@ -39,6 +39,9 @@ module Cucumber
           @rows = []
         end
 
+        def location(uri, offset)
+        end
+
         def row(row, line_number)
           @rows << row
         end
@@ -58,10 +61,10 @@ module Cucumber
         "table"
       end
 
-      def self.parse(text)
+      def self.parse(text, uri, offset)
         builder = Builder.new
         lexer = Gherkin::I18nLexer.new(builder)
-        lexer.scan(text)
+        lexer.scan(text, uri, offset)
         new(builder.rows)
       end
 

data/lib/cucumber/feature_file.rb

@@ -1,5 +1,6 @@
 require 'cucumber/parser/gherkin_builder'
 require 'gherkin/parser/filter_listener'
+require 'gherkin/parser/formatter_listener'
 require 'gherkin/parser/parser'
 require 'gherkin/i18n_lexer'
 
@@ -26,14 +27,15 @@ module Cucumber
     def parse(step_mother, options)
       filters = @lines || options.filters
 
-      builder         = Cucumber::Parser::GherkinBuilder.new
-      filter_listener = Gherkin::Parser::FilterListener.new(builder, filters)
-      parser          = Gherkin::Parser::Parser.new(filter_listener, true, "root")
-      lexer           = Gherkin::I18nLexer.new(parser, false)
+      builder            = Cucumber::Parser::GherkinBuilder.new
+      formatter_listener = Gherkin::Parser::FormatterListener.new(builder)
+      filter_listener    = Gherkin::Parser::FilterListener.new(formatter_listener, filters)
+      parser             = Gherkin::Parser::Parser.new(filter_listener, true, "root")
+      lexer              = Gherkin::I18nLexer.new(parser, false)
 
       begin
         s = ENV['FILTER_PML_CALLOUT'] ? source.gsub(C_CALLOUT, '') : source
-        lexer.scan(s)
+        lexer.scan(s, @path, 0)
         ast = builder.ast
         return nil if ast.nil? # Filter caused nothing to match
         ast.language = lexer.i18n_language

data/lib/cucumber/formatter/json.rb

@@ -69,7 +69,8 @@ module Cucumber
 
       def step_name(keyword, step_match, status, source_indent, background)
         @current_step[:status]          = status
-        @current_step[:name]            = "#{keyword}#{step_match.name || step_match.format_args}" # ?
+        @current_step[:keyword]         = "#{keyword}"
+        @current_step[:name]            = "#{step_match.name || step_match.format_args}"
         @current_step[:file_colon_line] = step_match.file_colon_line
       end
 
@@ -126,6 +127,17 @@ module Cucumber
         @io.flush
       end
 
+      def embed(file, mime_type)
+        obj = @current_step || @current_object
+        obj[:embedded] ||= []
+
+        obj[:embedded] << {
+          :file      => file,
+          :mime_type => mime_type,
+          :data      => [File.read(file)].pack("m*") # base64
+        }
+      end
+
       private
 
       def json_string

data/lib/cucumber/formatter/pdf.rb

@@ -3,21 +3,11 @@ require 'cucumber/formatter/io'
 require 'fileutils'
 
 begin
-  require 'htmlentities'
-rescue LoadError => e
-  e.message << "\nPlease gem install htmlentities"
-  raise e
-end
-
-begin
-  gem 'prawn', '=0.6.3'
-  require 'prawn'
+  require 'rubygems'
+  require 'prawn/core'
   require "prawn/layout"
-
-  gem 'prawn-format', '=0.2.3'
-  require "prawn/format"
 rescue LoadError => e
-  e.message << "\nPlease gem install prawn --version 0.6.3 && gem install prawn-format --version 0.2.3. Newer versions are not known to work."
+  e.message << "\nYou need the prawn gem. Please do 'gem install prawn'"
   raise e
 end
 
@@ -36,7 +26,6 @@ module Cucumber
       def initialize(step_mother, path_or_io, options)
         @step_mother = step_mother
         @file = ensure_file(path_or_io, "pdf")
-        @coder = HTMLEntities.new
 
         if(options[:dry_run])
           @status_colors = { :passed => BLACK, :skipped => BLACK, :undefined => BLACK, :failed => BLACK, :announced => GREY}
@@ -53,8 +42,8 @@ module Cucumber
         @buffer = []
         load_cover_page_image
         @pdf.text "\n\n\nCucumber features", :align => :center, :size => 32
-        @pdf.text "Generated: #{Time.now.strftime("%Y-%m-%d %H:%M")}", :size => 10, :at => [0, 24]
-        @pdf.text "Command: <code>cucumber #{ARGV.join(" ")}</code>", :size => 10, :at => [0,10]
+        @pdf.draw_text "Generated: #{Time.now.strftime("%Y-%m-%d %H:%M")}", :size => 10, :at => [0, 24]
+        @pdf.draw_text "$ cucumber #{ARGV.join(" ")}", :size => 10, :at => [0,10]
         unless options[:dry_run]
           @pdf.bounding_box [450,100] , :width => 100 do  
             @pdf.text 'Legend', :size => 10
@@ -153,7 +142,7 @@ module Cucumber
 
       def step_name(keyword, step_match, status, source_indent, background)
         return if @hide_this_step
-        line = "<b>#{keyword}</b> #{encode(step_match.format_args("%s"))}"
+        line = "#{keyword} #{step_match.format_args("%s")}"
         colorize(line, status)
       end
 
@@ -188,7 +177,7 @@ module Cucumber
         s = %{"""\n#{string}\n"""}.indent(10)
         s = s.split("\n").map{|l| l =~ /^\s+$/ ? '' : l}
         s.each do |line|
-          keep_with { @doc.text(encode(line), :size => 8) }
+          keep_with { @doc.text(line, :size => 8) }
         end
       end
 
@@ -211,11 +200,7 @@ module Cucumber
       end
       
       private
-      
-      def encode(text)
-        @coder.encode(text, :decimal)
-      end
-      
+
       def colorize(text, status)
         keep_with do
           @doc.fill_color(@status_colors[status] || BLACK)
@@ -252,9 +237,7 @@ module Cucumber
       end
       
       def print_table(table, row_colors)
-        rows = table.rows.map { |row| row.map{ |cell| encode(cell) }}
-        headers = table.headers.map { |text| encode(text) }
-        @doc.table(rows, :headers => headers, :position => :center, :row_colors => row_colors)
+        @doc.table(table.rows, :headers => table.headers, :position => :center, :row_colors => row_colors)
       end
     end
   end

data/lib/cucumber/parser/gherkin_builder.rb

@@ -1,4 +1,5 @@
 require 'cucumber/ast'
+require 'gherkin/rubify'
 
 module Cucumber
   module Parser
@@ -6,38 +7,29 @@ module Cucumber
     # "legacy" AST. It will be replaced later when we have a new "clean"
     # AST.
     class GherkinBuilder
+      include Gherkin::Rubify
 
       def ast
         @feature || @multiline_arg
       end
 
-      def tag(name, line)
-        @tags ||= []
-        @tags << name
-      end
-
-      def comment(content, line)
-        @comments ||= []
-        @comments << content
-      end
-
-      def feature(keyword, name, line)
+      def feature(comments, tags, keyword, name, description, uri)
         @feature = Ast::Feature.new(
           nil, 
-          Ast::Comment.new(grab_comments!('')), 
-          Ast::Tags.new(nil, grab_tags!('')),
+          Ast::Comment.new(comments.join("\n")), 
+          Ast::Tags.new(nil, tags),
           keyword,
-          name,
+          legacy_name_for(name, description),
           []
         )
       end
 
-      def background(keyword, name, line)
+      def background(comments, keyword, name, description, line)
         @background = Ast::Background.new(
-          Ast::Comment.new(grab_comments!('')), 
+          Ast::Comment.new(comments.join("\n")), 
           line, 
           keyword, 
-          name, 
+          legacy_name_for(name, description), 
           steps=[]
         )
         @feature.background = @background
@@ -45,15 +37,14 @@ module Cucumber
         @step_container = @background
       end
 
-      def scenario(keyword, name, line)
-        grab_table!
+      def scenario(comments, tags, keyword, name, description, line)
         scenario = Ast::Scenario.new(
           @background, 
-          Ast::Comment.new(grab_comments!('')), 
-          Ast::Tags.new(nil, grab_tags!('')), 
+          Ast::Comment.new(comments.join("\n")), 
+          Ast::Tags.new(nil, tags), 
           line, 
           keyword, 
-          name, 
+          legacy_name_for(name, description), 
           steps=[]
         )
         @feature.add_feature_element(scenario)
@@ -61,15 +52,14 @@ module Cucumber
         @step_container = scenario
       end
 
-      def scenario_outline(keyword, name, line)
-        grab_table!
+      def scenario_outline(comments, tags, keyword, name, description, line)
         scenario_outline = Ast::ScenarioOutline.new(
           @background, 
-          Ast::Comment.new(grab_comments!('')), 
-          Ast::Tags.new(nil, grab_tags!('')), 
+          Ast::Comment.new(comments.join("\n")), 
+          Ast::Tags.new(nil, tags), 
           line, 
           keyword, 
-          name, 
+          legacy_name_for(name, description), 
           steps=[],
           example_sections=[]
         )
@@ -81,64 +71,47 @@ module Cucumber
         @step_container = scenario_outline
       end
 
-      def examples(keyword, name, line)
-        grab_table!
-        @examples_fields = [Ast::Comment.new(grab_comments!('')), line, keyword, name]
+      def examples(comments, tags, keyword, name, description, line, examples_table)
+        examples_fields = [Ast::Comment.new(comments.join("\n")), line, keyword, legacy_name_for(name, description), matrix(examples_table)]
+        @step_container.add_examples(examples_fields)
       end
 
-      def step(keyword, name, line)
-        grab_table!
+      def step(comments, keyword, name, line, multiline_arg, status, exception, arguments, stepdef_location)
         @table_owner = Ast::Step.new(line, keyword, name)
-        @step_container.add_step(@table_owner)
-      end
-
-      def row(row, line)
-        @rows ||= []
-        @rows << row
-        class << row
-          attr_accessor :line
+        multiline_arg = rubify(multiline_arg)
+        case(multiline_arg)
+        when String
+          @table_owner.multiline_arg = Ast::PyString.new(multiline_arg)
+        when Array
+          @table_owner.multiline_arg = Ast::Table.new(matrix(multiline_arg))
         end
-        row.line = line
-      end
-
-      def py_string(string, line)
-        @multiline_arg = Ast::PyString.new(string)
-        @table_owner.multiline_arg = @multiline_arg if @table_owner
+        @step_container.add_step(@table_owner)
       end
 
       def eof
-        grab_table!
       end
 
       def syntax_error(state, event, legal_events, line)
         # raise "SYNTAX ERROR"
       end
-
+      
     private
-
-      def grab_table!
-        return if @rows.nil? 
-        if @examples_fields
-          @examples_fields << @rows
-          @step_container.add_examples(@examples_fields)
-          @examples_fields = nil
-        else
-          @multiline_arg = Ast::Table.new(@rows)
-          @table_owner.multiline_arg = @multiline_arg if @table_owner
+    
+      def legacy_name_for(name, description)
+        s = name
+        s += "\n#{description}" if description != ""
+        s
+      end
+
+      def matrix(gherkin_table)
+        gherkin_table.map do |gherkin_row|
+          row = gherkin_row.cells
+          class << row
+            attr_accessor :line
+          end
+          row.line = gherkin_row.line
+          row
         end
-        @rows = nil
-      end
-
-      def grab_tags!(indent)
-        tags = @tags ? @tags : []
-        @tags = nil
-        tags
-      end
-
-      def grab_comments!(indent)
-        comments = @comments ? indent + @comments.join("\n#{indent}") : ''
-        @comments = nil
-        comments
       end
     end
   end

data/lib/cucumber/rb_support/rb_language.rb

@@ -87,15 +87,17 @@ module Cucumber
         end.compact
       end
 
-      def snippet_text(step_keyword, step_name, multiline_arg_class)
-        escaped = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
-        escaped = escaped.gsub(PARAM_PATTERN, ESCAPED_PARAM_PATTERN)
+      ARGUMENT_PATTERNS = ['"([^"]*)"', '(\d+)']
 
-        n = 0
-        block_args = escaped.scan(ESCAPED_PARAM_PATTERN).map do |a|
-          n += 1
-          "arg#{n}"
+      def snippet_text(step_keyword, step_name, multiline_arg_class)
+        snippet_pattern = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
+        arg_count = 0
+        ARGUMENT_PATTERNS.each do |pattern|
+          snippet_pattern = snippet_pattern.gsub(Regexp.new(pattern), pattern)
+          arg_count += snippet_pattern.scan(pattern).length
         end
+
+        block_args = (0...arg_count).map {|n| "arg#{n+1}"}
         block_args << multiline_arg_class.default_arg_name unless multiline_arg_class.nil?
         block_arg_string = block_args.empty? ? "" : " |#{block_args.join(", ")}|"
         multiline_class_comment = ""
@@ -103,7 +105,7 @@ module Cucumber
           multiline_class_comment = "# #{multiline_arg_class.default_arg_name} is a #{multiline_arg_class.to_s}\n  "
         end
 
-        "#{Gherkin::I18n.code_keyword_for(step_keyword)} /^#{escaped}$/ do#{block_arg_string}\n  #{multiline_class_comment}pending # express the regexp above with the code you wish you had\nend"
+        "#{Gherkin::I18n.code_keyword_for(step_keyword)} /^#{snippet_pattern}$/ do#{block_arg_string}\n  #{multiline_class_comment}pending # express the regexp above with the code you wish you had\nend"
       end
 
       def begin_rb_scenario(scenario)
@@ -151,9 +153,6 @@ module Cucumber
 
       private
 
-      PARAM_PATTERN = /"([^"]*)"/
-      ESCAPED_PARAM_PATTERN = '"([^"]*)"'
-
       def create_world
         if(@world_proc)
           @current_world = @world_proc.call

data/lib/cucumber/rb_support/rb_world.rb

@@ -24,7 +24,7 @@ module Cucumber
 
       # See StepMother#invoke_steps
       def steps(steps_text)
-        @__cucumber_step_mother.invoke_steps(steps_text, @__natural_language)
+        @__cucumber_step_mother.invoke_steps(steps_text, @__natural_language, caller[0])
       end
 
       # See StepMother#table

data/lib/cucumber/step_mother.rb

@@ -189,9 +189,10 @@ module Cucumber
     #     Given I have 8 cukes in my belly
     #     Then I should not be thirsty
     #   })
-    def invoke_steps(steps_text, i18n)
+    def invoke_steps(steps_text, i18n, file_colon_line)
+      file, line = file_colon_line.split(':')
       lexer = i18n.lexer(Gherkin::Parser::Parser.new(StepInvoker.new(self), true, 'steps'))
-      lexer.scan(steps_text)
+      lexer.scan(steps_text, file, line)
     end
 
     class StepInvoker
@@ -199,6 +200,9 @@ module Cucumber
         @step_mother = step_mother
       end
 
+      def location(uri, offset)
+      end
+
       def step(keyword, name, line)
         invoke
         @name = name
@@ -251,7 +255,7 @@ module Cucumber
       if Array === text_or_table
         Ast::Table.new(text_or_table)
       else
-        Ast::Table.parse(text_or_table)
+        Ast::Table.parse(text_or_table, file, line_offset)
       end
     end
 

data/spec/cucumber/ast/table_spec.rb

@@ -229,7 +229,7 @@ module Cucumber
             | 55555     | 666666      | 7777777     | 88888888     |
             | 999999999 | 0000000000  | 01010101010 | 121212121212 |
             | 4000      | ABC         | DEF         | 50000        |
-          })
+          }, __FILE__, __LINE__)
           
           t2 = table(%{
             | a     | 4444     | 1         | 
@@ -237,7 +237,7 @@ module Cucumber
             | ccc   | xxxxxxxx | 999999999 | 
             | dddd  | 4000     | 300       |
             | e     | 50000    | 4000      |
-          })
+          }, __FILE__, __LINE__)
           lambda{t1.diff!(t2)}.should raise_error
           t1.to_s(:indent => 12, :color => false).should == %{
             |     1         | (-) 22         | (-) 333         |     4444         | (+) a    |
@@ -254,7 +254,7 @@ module Cucumber
             |a|b|c|
             |d|e|f|
             |g|h|i|
-          })
+          }, __FILE__, __LINE__)
           t.diff!(t.dup)
           t.to_s(:indent => 12, :color => false).should == %{
             |     a |     b |     c |
@@ -350,14 +350,14 @@ module Cucumber
             @t = table(%{
               | a | b |
               | c | d |
-            })
+            }, __FILE__, __LINE__)
             @t.should_not == nil
           end
           
           it "should raise on missing rows" do
             t = table(%{
               | a | b |
-            })
+            }, __FILE__, __LINE__)
             lambda { @t.dup.diff!(t) }.should raise_error
             lambda { @t.dup.diff!(t, :missing_row => false) }.should_not raise_error
           end
@@ -367,7 +367,7 @@ module Cucumber
               | a | b |
               | c | d |
               | e | f |
-            })
+            }, __FILE__, __LINE__)
             lambda { @t.dup.diff!(t) }.should raise_error
             lambda { @t.dup.diff!(t, :surplus_row => false) }.should_not raise_error
           end
@@ -376,7 +376,7 @@ module Cucumber
             t1 = table(%{
               | row_1 | row_2 |
               | four  | 4     |
-            })
+            }, __FILE__, __LINE__)
             t2 = table(%{
               | row_1 | row_2 |
               | one   | 1     |
@@ -384,7 +384,7 @@ module Cucumber
               | three | 3     |
               | four  | 4     |
               | five  | 5     |
-            })
+            }, __FILE__, __LINE__)
             lambda { t1.dup.diff!(t2) }.should raise_error
 
             begin
@@ -400,7 +400,7 @@ module Cucumber
             t = table(%{
               | a |
               | c |
-            })
+            }, __FILE__, __LINE__)
             lambda { @t.dup.diff!(t) }.should raise_error
             lambda { @t.dup.diff!(t, :missing_col => false) }.should_not raise_error
           end
@@ -409,14 +409,14 @@ module Cucumber
             t = table(%{
               | a | b | x |
               | c | d | y |
-            })
+            }, __FILE__, __LINE__)
             lambda { @t.dup.diff!(t) }.should_not raise_error
             lambda { @t.dup.diff!(t, :surplus_col => true) }.should raise_error
           end
         end
 
-        def table(text, file=nil, line_offset=0)
-          Table.parse(text)
+        def table(text, file, offset)
+          Table.parse(text, file, offset)
         end
       end