gherkin 2.12.2 → 3.2.0

data/lib/gherkin/formatter/filter_formatter.rb

@@ -1,150 +0,0 @@
-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          = []
-        @examples_range         = []
-        @feature_events         = []
-        @background_events      = []
-        @feature_element_events = []
-        @examples_events        = []
-
-        @examples_name          = nil
-        @feature_element_name   = nil
-        @feature_element_range  = nil
-      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.evaluate([], [], [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.evaluate(
-          (@feature_tags + @feature_element_tags), 
-          [@feature_name, @feature_element_name].compact, 
-          [@feature_element_range].compact
-        )
-        examples_ok = @filter.evaluate(
-          (@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 = []
-        @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

@@ -1,25 +0,0 @@
-module Gherkin
-  module Formatter
-    class Hashable
-      def to_hash
-        ivars = instance_variables
-        # When tests are runn with therubyracer (JavaScript), an extra field might
-        # exist - added by Ref::WeakReference
-        # https://github.com/bdurand/ref/blob/master/lib/ref/weak_reference/pure_ruby.rb
-        # Remove it - we don't want it in the JSON.
-        ivars.delete(:@__weak_backreferences__)
-        ivars.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

@@ -1,133 +0,0 @@
-require 'multi_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(MultiJson.dump(@feature_hashes, :pretty => true))
-      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 append_duration(timestamp)
-      	#check to make sure result exists (scenario outlines do not have results yet)
-      	if !@current_step_or_hook['result'].nil?
-        	#convert to nanoseconds
-        	timestamp = timestamp * 1000000000
-        	rshash = @current_step_or_hook['result'].to_hash
-        	rshash['duration'] = timestamp.to_i
-        	@current_step_or_hook['result'] = rshash
-       	end
-      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

@@ -1,26 +0,0 @@
-module Gherkin
-  module Formatter
-    class LineFilter
-      def initialize(lines)
-        @lines = lines
-      end
-
-      def evaluate(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

@@ -1,281 +0,0 @@
-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