benhamill-gherkin 2.3.5

data/lib/.gitignore

@@ -0,0 +1,4 @@
+*.bundle
+*.dll
+*.so
+*.jar

data/lib/gherkin.rb

@@ -0,0 +1,2 @@
+require 'gherkin/lexer/i18n_lexer'
+require 'gherkin/parser/parser'

data/lib/gherkin/c_lexer.rb

@@ -0,0 +1,17 @@
+require 'rbconfig'
+
+module Gherkin
+  module CLexer
+    def self.[](i18n_underscored_iso_code)
+      begin
+        prefix = Config::CONFIG['arch'] =~ /mswin|mingw/ ? "#{Config::CONFIG['MAJOR']}.#{Config::CONFIG['MINOR']}/" : ''
+        lib = "#{prefix}gherkin_lexer_#{i18n_underscored_iso_code}"
+        require lib
+        const_get(i18n_underscored_iso_code.capitalize)
+      rescue LoadError => e
+        e.message << %{\nCouldn't load #{lib}\nThe $LOAD_PATH was:\n#{$LOAD_PATH.join("\n")}}
+        raise e
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/ansi_escapes.rb

@@ -0,0 +1,95 @@
+module Gherkin
+  module Formatter
+    # Defines aliases for ANSI coloured output. Default colours can be overridden by defining
+    # a <tt>GHERKIN_COLORS</tt> variable in your shell, very much like how you can
+    # tweak the familiar POSIX command <tt>ls</tt> with
+    # <a href="http://mipsisrisc.com/rambling/2008/06/27/lscolorsls_colors-now-with-linux-support/">$LSCOLORS/$LS_COLORS</a>
+    #
+    # The colours that you can change are:
+    #
+    # <tt>undefined</tt>::     defaults to <tt>yellow</tt>
+    # <tt>pending</tt>::       defaults to <tt>yellow</tt>
+    # <tt>pending_arg</tt>::   defaults to <tt>yellow,bold</tt>
+    # <tt>executing</tt>::     defaults to <tt>grey</tt>
+    # <tt>executing_arg</tt>:: defaults to <tt>grey,bold</tt>
+    # <tt>failed</tt>::        defaults to <tt>red</tt>
+    # <tt>failed_arg</tt>::    defaults to <tt>red,bold</tt>
+    # <tt>passed</tt>::        defaults to <tt>green</tt>
+    # <tt>passed_arg</tt>::    defaults to <tt>green,bold</tt>
+    # <tt>outline</tt>::       defaults to <tt>cyan</tt>
+    # <tt>outline_arg</tt>::   defaults to <tt>cyan,bold</tt>
+    # <tt>skipped</tt>::       defaults to <tt>cyan</tt>
+    # <tt>skipped_arg</tt>::   defaults to <tt>cyan,bold</tt>
+    # <tt>comment</tt>::       defaults to <tt>grey</tt>
+    # <tt>tag</tt>::           defaults to <tt>cyan</tt>
+    #
+    # For instance, if your shell has a black background and a green font (like the
+    # "Homebrew" settings for OS X' Terminal.app), you may want to override passed
+    # steps to be white instead of green. Examples:
+    #
+    #   export GHERKIN_COLORS="passed=white"
+    #   export GHERKIN_COLORS="passed=white,bold:passed_arg=white,bold,underline"
+    #
+    # (If you're on Windows, use SET instead of export).
+    # To see what colours and effects are available, just run this in your shell:
+    #
+    #   ruby -e "require 'rubygems'; require 'term/ansicolor'; puts Term::ANSIColor.attributes"
+    #
+    # Although not listed, you can also use <tt>grey</tt>
+    module AnsiEscapes
+      COLORS = {
+        'black'   => "\e[30m",
+        'red'     => "\e[31m",
+        'green'   => "\e[32m",
+        'yellow'  => "\e[33m",
+        'blue'    => "\e[34m",
+        'magenta' => "\e[35m",
+        'cyan'    => "\e[36m",
+        'white'   => "\e[37m",
+        'grey'    => "\e[90m",
+        'bold'    => "\e[1m"
+      }
+
+      ALIASES = Hash.new do |h,k|
+        if k.to_s =~ /(.*)_arg/
+          h[$1] + ',bold'
+        end
+      end.merge({
+        'undefined' => 'yellow',
+        'pending'   => 'yellow',
+        'executing' => 'grey',
+        'failed'    => 'red',
+        'passed'    => 'green',
+        'outline'   => 'cyan',
+        'skipped'   => 'cyan',
+        'comments'  => 'grey',
+        'tag'       => 'cyan'
+      })
+
+      if ENV['GHERKIN_COLORS'] # Example: export GHERKIN_COLORS="passed=red:failed=yellow"
+        ENV['GHERKIN_COLORS'].split(':').each do |pair|
+          a = pair.split('=')
+          ALIASES[a[0]] = a[1]
+        end
+      end
+
+      ALIASES.keys.each do |key|
+        define_method(key) do
+          ALIASES[key].split(',').map{|color| COLORS[color]}.join('')
+        end
+
+        define_method("#{key}_arg") do
+          ALIASES["#{key}_arg"].split(',').map{|color| COLORS[color]}.join('')
+        end
+      end
+      
+      def reset
+        "\e[0m"
+      end
+
+      def up(n)
+        "\e[#{n}A"
+      end
+    end
+  end
+end

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,136 @@
+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 = examples.rows[1].line..examples.rows[-1].line
+        @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
+
+    private
+
+      def detect_filter(filters)
+        raise "Inconsistent filters: #{filters.inspect}" 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
+      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,102 @@
+require 'json'
+require 'gherkin/formatter/model'
+require 'gherkin/native'
+require 'base64'
+
+module Gherkin
+  module Formatter
+    class JSONFormatter
+      native_impl('gherkin')
+      
+      include Base64
+      attr_reader :gherkin_object
+      
+      # Creates a new instance that writes the resulting JSON to +io+.
+      # If +io+ is nil, the JSON will not be written, but instead a Ruby
+      # object can be retrieved with #gherkin_object
+      def initialize(io)
+        @io = io
+      end
+
+      def uri(uri)
+        # We're ignoring the uri - we don't want it as part of the JSON
+        # (The pretty formatter uses it just for visual niceness - comments)
+      end
+
+      def feature(feature)
+        @gherkin_object = feature.to_hash
+      end
+
+      def steps(steps)
+      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_steps << step.to_hash
+      end
+
+      def match(match)
+        last_step['match'] = match.to_hash
+      end
+
+      def result(result)
+        last_step['result'] = result.to_hash
+      end
+
+      def embedding(mime_type, data)
+        embeddings << {'mime_type' => mime_type, 'data' => encode64s(data)}
+      end
+
+      def eof
+        @io.write(@gherkin_object.to_json) if @io
+      end
+
+    private
+
+      def feature_elements
+        @gherkin_object['elements'] ||= []
+      end
+
+      def feature_element
+        feature_elements[-1]
+      end
+
+      def all_examples
+        feature_element['examples'] ||= []
+      end
+
+      def current_steps
+        feature_element['steps'] ||= []
+      end
+
+      def last_step
+        current_steps[-1]
+      end
+
+      def embeddings
+        last_step['embeddings'] ||= []
+      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