bryanl-gherkin 2.11.1.1

data/lib/gherkin/formatter/argument.rb

@@ -0,0 +1,16 @@
+require 'gherkin/native'
+require 'gherkin/formatter/hashable'
+
+module Gherkin
+  module Formatter
+    class Argument < Hashable
+      native_impl('gherkin')
+      attr_reader :offset, :val
+
+      # Creates a new Argument that starts at character offset +offset+ with value +val+
+      def initialize(offset, val)
+        @offset, @val = offset, val
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/escaping.rb

@@ -0,0 +1,15 @@
+module Gherkin
+  module Formatter
+    module Escaping
+      # Escapes a pipes and backslashes:
+      #
+      # * | becomes \|
+      # * \ becomes \\
+      #
+      # This is used in the pretty formatter.
+      def escape_cell(s)
+        s.gsub(/\\(?!\|)/, "\\\\\\\\").gsub(/\n/, "\\n").gsub(/\|/, "\\|")
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/filter_formatter.rb

@@ -0,0 +1,146 @@
+require 'gherkin/tag_expression'
+require 'gherkin/formatter/regexp_filter'
+require 'gherkin/formatter/line_filter'
+require 'gherkin/formatter/tag_filter'
+require 'gherkin/formatter/model'
+require 'gherkin/native'
+
+module Gherkin
+  module Formatter
+    class FilterFormatter
+      native_impl('gherkin')
+      
+      def initialize(formatter, filters)
+        @formatter = formatter
+        @filter    = detect_filter(filters)
+
+        @feature_tags           = []
+        @feature_element_tags   = []
+        @examples_tags          = []
+
+        @feature_events         = []
+        @background_events      = []
+        @feature_element_events = []
+        @examples_events        = []
+      end
+
+      def uri(uri)
+        @formatter.uri(uri)
+      end
+
+      def feature(feature)
+        @feature_tags   = feature.tags
+        @feature_name   = feature.name
+        @feature_events = [feature]
+      end
+
+      def background(background)
+        @feature_element_name   = background.name
+        @feature_element_range  = background.line_range
+        @background_events      = [background]
+      end
+
+      def scenario(scenario)
+        replay!
+        @feature_element_tags   = scenario.tags
+        @feature_element_name   = scenario.name
+        @feature_element_range  = scenario.line_range
+        @feature_element_events = [scenario]
+      end
+
+      def scenario_outline(scenario_outline)
+        replay!
+        @feature_element_tags   = scenario_outline.tags
+        @feature_element_name   = scenario_outline.name
+        @feature_element_range  = scenario_outline.line_range
+        @feature_element_events = [scenario_outline]
+      end
+
+      def examples(examples)
+        replay!
+        @examples_tags = examples.tags
+        @examples_name = examples.name
+
+        table_body_range = case(examples.rows.length)
+          when 0 then examples.line_range.last..examples.line_range.last
+          when 1 then examples.rows[0].line..examples.rows[0].line
+          else examples.rows[1].line..examples.rows[-1].line
+        end
+
+        @examples_range = examples.line_range.first..table_body_range.last
+        if(@filter.eval([], [], [table_body_range]))
+          examples.rows = @filter.filter_table_body_rows(examples.rows)
+        end
+        @examples_events = [examples]
+      end
+
+      def step(step)
+        if @feature_element_events.any?
+          @feature_element_events << step
+        else
+          @background_events << step
+        end
+
+        @feature_element_range = @feature_element_range.first..step.line_range.last
+      end
+
+      def eof
+        replay!
+        @formatter.eof
+      end
+
+      def done
+        @formatter.done
+      end
+
+    private
+
+      def detect_filter(filters)
+        raise "Inconsistent filters: #{filters.inspect}. Only one type [line,name,tag] can be used at once." if filters.map{|filter| filter.class}.uniq.length > 1
+        case(filters[0])
+        when Fixnum 
+          LineFilter.new(filters)
+        when Regexp 
+          RegexpFilter.new(filters)
+        when String 
+          TagFilter.new(filters)
+        end
+      end
+
+      def replay!
+        feature_element_ok = @filter.eval(
+          (@feature_tags + @feature_element_tags), 
+          [@feature_name, @feature_element_name].compact, 
+          [@feature_element_range].compact
+        )
+        examples_ok = @filter.eval(
+          (@feature_tags + @feature_element_tags + @examples_tags), 
+          [@feature_name, @feature_element_name, @examples_name].compact, 
+          [@feature_element_range, @examples_range].compact
+        )
+
+        if feature_element_ok || examples_ok
+          replay_events!(@feature_events)
+          replay_events!(@background_events)
+          replay_events!(@feature_element_events)
+
+          if examples_ok
+            replay_events!(@examples_events)
+          end
+        end
+
+        @examples_events.clear
+        @examples_tags.clear
+        @examples_name = nil
+        @examples_range = nil
+      end
+
+      def replay_events!(events)
+        events.each do |event|
+          event.replay(@formatter)
+        end
+        events.clear
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/hashable.rb

@@ -0,0 +1,19 @@
+module Gherkin
+  module Formatter
+    class Hashable
+      def to_hash
+        instance_variables.inject({}) do |hash, ivar|
+          value = instance_variable_get(ivar)
+          value = value.to_hash if value.respond_to?(:to_hash)
+          if Array === value
+            value = value.map do |e|
+              e.respond_to?(:to_hash) ? e.to_hash : e
+            end
+          end
+          hash[ivar[1..-1]] = value unless [[], nil].index(value)
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/json_formatter.rb

@@ -0,0 +1,122 @@
+require 'json'
+require 'gherkin/formatter/model'
+require 'gherkin/native'
+require 'base64'
+
+module Gherkin
+  module Formatter
+    # This class doesn't really generate JSON - instead it populates an Array that can easily
+    # be turned into JSON.
+    class JSONFormatter
+      native_impl('gherkin')
+      
+      include Base64
+      
+      def initialize(io)
+        raise "Must be writeable" unless io.respond_to?(:write)
+        @io = io
+        @feature_hashes = []
+        @current_step_or_hook = nil
+      end
+
+      def done
+        @io.write(@feature_hashes.to_json)
+      end
+
+      def uri(uri)
+        @uri = uri
+      end
+
+      def feature(feature)
+        @feature_hash = feature.to_hash
+        @feature_hash['uri'] = @uri
+        @feature_hashes << @feature_hash
+      end
+
+      def background(background)
+        feature_elements << background.to_hash
+      end
+
+      def scenario(scenario)
+        feature_elements << scenario.to_hash
+      end
+
+      def scenario_outline(scenario_outline)
+        feature_elements << scenario_outline.to_hash
+      end
+
+      def examples(examples)
+        all_examples << examples.to_hash
+      end
+
+      def step(step)
+        @current_step_or_hook = step.to_hash
+        steps << @current_step_or_hook
+      end
+
+      def match(match)
+        @current_step_or_hook['match'] = match.to_hash
+      end
+
+      def result(result)
+        @current_step_or_hook['result'] = result.to_hash
+      end
+
+      def before(match, result)
+        add_hook(match, result, "before")
+      end
+
+      def after(match, result)
+        add_hook(match, result, "after")
+      end
+
+      def embedding(mime_type, data)
+        embeddings << {'mime_type' => mime_type, 'data' => encode64s(data)}
+      end
+
+      def write(text)
+        output << text
+      end
+
+      def eof
+      end
+
+    private
+
+      def add_hook(match, result, hook)
+        hooks = feature_element[hook] ||= []
+        hooks << {'match' => match.to_hash, 'result' => result.to_hash}
+      end
+
+      def feature_elements
+        @feature_hash['elements'] ||= []
+      end
+
+      def feature_element
+        feature_elements[-1]
+      end
+
+      def all_examples
+        feature_element['examples'] ||= []
+      end
+
+      def steps
+        feature_element['steps'] ||= []
+      end
+
+      def embeddings
+        @current_step_or_hook['embeddings'] ||= []
+      end
+
+      def output
+        @current_step_or_hook['output'] ||= []
+      end
+
+      def encode64s(data)
+        # Strip newlines
+        Base64.encode64(data).gsub(/\n/, '')
+      end
+    end
+  end
+end
+

data/lib/gherkin/formatter/line_filter.rb

@@ -0,0 +1,26 @@
+module Gherkin
+  module Formatter
+    class LineFilter
+      def initialize(lines)
+        @lines = lines
+      end
+
+      def eval(tags, names, ranges)
+        ranges.detect do |range|
+          @lines.detect do |line|
+            range.include?(line)
+          end
+        end
+      end
+
+      def filter_table_body_rows(rows)
+        body = rows.to_a[1..-1].select do |row|
+          @lines.detect do |line|
+            row.line == line
+          end
+        end
+        [rows[0]] + body
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/model.rb

@@ -0,0 +1,281 @@
+require 'gherkin/native'
+require 'gherkin/formatter/hashable'
+
+module Gherkin
+  module Formatter
+    module Model
+      class BasicStatement < Hashable
+        attr_reader :comments, :keyword, :name, :line
+        
+        def initialize(comments, keyword, name, line)
+          @comments, @keyword, @name, @line = comments, keyword, name, line
+        end
+
+        def line_range
+          first = @comments.any? ? @comments[0].line : first_non_comment_line
+          first..line
+        end
+
+        def first_non_comment_line
+          @line
+        end
+      end
+
+      class DescribedStatement < BasicStatement
+        attr_reader :description
+
+        def initialize(comments, keyword, name, description, line)
+          super(comments, keyword, name, line)
+          @description = description
+        end
+      end
+
+      class TagStatement < DescribedStatement
+        attr_reader :tags, :id
+
+        def initialize(comments, tags, keyword, name, description, line, id)
+          super(comments, keyword, name, description, line)
+          @tags = tags
+          @id = id
+        end
+
+        def first_non_comment_line
+          @tags.any? ? @tags[0].line : @line
+        end
+      end
+
+      class Feature < TagStatement
+        native_impl('gherkin')
+
+        def replay(formatter)
+          formatter.feature(self)
+        end
+      end
+
+      class Background < DescribedStatement
+        native_impl('gherkin')
+
+        def initialize(comments, keyword, name, description, line)
+          super(comments, keyword, name, description, line)
+          @type = "background"
+        end
+
+        def replay(formatter)
+          formatter.background(self)
+        end
+      end
+
+      class Scenario < TagStatement
+        native_impl('gherkin')
+
+        def initialize(comments, tags, keyword, name, description, line, id)
+          super(comments, tags, keyword, name, description, line, id)
+          @type = "scenario"
+        end
+
+        def replay(formatter)
+          formatter.scenario(self)
+        end
+      end
+
+      class ScenarioOutline < TagStatement
+        native_impl('gherkin')
+
+        def initialize(comments, tags, keyword, name, description, line, id)
+          super(comments, tags, keyword, name, description, line, id)
+          @type = "scenario_outline"
+        end
+
+        def replay(formatter)
+          formatter.scenario_outline(self)
+        end
+      end
+
+      class Examples < TagStatement
+        native_impl('gherkin')
+
+        attr_accessor :rows # needs to remain mutable for filters
+
+        def initialize(comments, tags, keyword, name, description, line, id, rows)
+          super(comments, tags, keyword, name, description, line, id)
+          @rows = rows
+        end
+
+        def replay(formatter)
+          formatter.examples(self)
+        end
+        
+        class Builder
+          def initialize(*args)
+            @args = *args
+            @rows = nil
+          end
+        
+          def row(comments, cells, line, id)
+            @rows ||= []
+            @rows << ExamplesTableRow.new(comments, cells, line, id)
+          end
+        
+          def replay(formatter)
+            build.replay(formatter)
+          end
+          
+          def build
+            Examples.new(*(@args << @rows))
+          end
+        end
+      end
+
+      class Step < BasicStatement
+        native_impl('gherkin')
+
+        attr_reader :rows, :doc_string
+        
+        def initialize(comments, keyword, name, line, rows, doc_string)
+          super(comments, keyword, name, line)
+          @rows, @doc_string = rows, doc_string
+        end
+
+        def line_range
+          range = super
+          if(rows)
+            range = range.first..rows[-1].line
+          elsif(doc_string)
+            range = range.first..doc_string.line_range.last
+          end
+          range
+        end
+
+        def replay(formatter)
+          formatter.step(self)
+        end
+
+        def outline_args
+          offset = 0
+          name.scan(/<[^<]*>/).map do |val|
+            offset = name.index(val, offset)
+            Argument.new(offset, val)
+          end
+        end
+        
+        class Builder
+          def initialize(*args)
+            @args = *args
+            @rows = nil
+            @doc_string = nil
+          end
+        
+          def row(comments, cells, line, id)
+            @rows ||= []
+            @rows << DataTableRow.new(comments, cells, line)
+          end
+          
+          def doc_string(string, content_type, line)
+            @doc_string = Formatter::Model::DocString.new(string, content_type, line)
+          end
+        
+          def replay(formatter)
+            build.replay(formatter)
+          end
+          
+          def build
+            Step.new(*(@args << @rows << @doc_string))
+          end
+        end
+      end
+
+      class Comment < Hashable
+        native_impl('gherkin')
+
+        attr_reader :value, :line
+        
+        def initialize(value, line)
+          @value, @line = value, line
+        end
+      end
+
+      class Tag < Hashable
+        native_impl('gherkin')
+
+        attr_reader :name, :line
+        
+        def initialize(name, line)
+          @name, @line = name, line
+        end
+        
+        def eql?(tag)
+          @name.eql?(tag.name)
+        end
+
+        def hash
+          @name.hash
+        end
+      end
+
+      class DocString < Hashable
+        native_impl('gherkin')
+
+        attr_reader :value, :content_type, :line
+        
+        def initialize(value, content_type, line)
+          @value, @content_type, @line = value, content_type, line
+        end
+
+        def line_range
+          line_count = value.split(/\r?\n/).length
+          line..(line+line_count+1)
+        end
+      end
+
+      class Row < Hashable
+        attr_reader :comments, :cells, :line
+
+        def initialize(comments, cells, line)
+          @comments, @cells, @line = comments, cells, line
+        end
+      end
+
+      class DataTableRow < Row
+        native_impl('gherkin')
+      end
+
+      class ExamplesTableRow < Row
+        native_impl('gherkin')
+        attr_reader :id
+
+        def initialize(comments, cells, line, id)
+          super(comments, cells, line)
+          @id = id
+        end
+      end
+
+      class Match < Hashable
+        native_impl('gherkin')
+
+        attr_reader :arguments, :location
+        
+        def initialize(arguments, location)
+          @arguments, @location = arguments, location
+        end
+
+        def replay(formatter)
+          formatter.match(self)
+        end
+      end
+
+      class Result < Hashable
+        native_impl('gherkin')
+
+        attr_reader :status, :duration, :error_message
+        
+        def initialize(status, duration, error_message)
+          @status, @duration, @error_message = status, duration, error_message
+        end
+
+        def replay(formatter)
+          formatter.result(self)
+        end
+      end
+    end
+  end
+end