gherkin 1.0.2-java

data/lib/gherkin/i18n_lexer.rb

@@ -0,0 +1,29 @@
+require 'gherkin/lexer'
+require 'gherkin/i18n'
+
+module Gherkin
+  # The main entry point to lexing Gherkin source.
+  class I18nLexer
+    LANGUAGE_PATTERN = /language\s*:\s*(.*)/ #:nodoc:
+
+    attr_reader :language
+
+    def initialize(parser)
+      @parser = parser
+    end
+
+    def scan(source)
+      @language = lang(source) 
+      delegate = Lexer[@language.key].new(@parser)
+      delegate.scan(source)
+    end
+
+    private
+
+    def lang(source)
+      line_one = source.split(/\n/)[0]
+      match = LANGUAGE_PATTERN.match(line_one)
+      I18n.get(match ? match[1] : 'en')
+    end
+  end
+end

data/lib/gherkin/java_lexer.rb

@@ -0,0 +1,10 @@
+require 'gherkin.jar'
+
+module Gherkin
+  module JavaLexer
+    def self.[](i18n_language)
+      i18n_lexer_class_name = i18n_language.gsub(/[\s-]/, '').capitalize
+      Java::GherkinLexer.__send__(i18n_lexer_class_name)
+    end
+  end
+end

data/lib/gherkin/lexer.rb

@@ -0,0 +1,44 @@
+module Gherkin
+  module Lexer
+    I18nLexerNotFound = Class.new(LoadError)
+    LexingError = Class.new(StandardError)
+
+    class << self
+      def [](i18n_lang)
+        begin
+          # Uncomment the line below (during development) to force use of Ruby lexer
+          # return rb[i18n_lang]
+
+          if defined?(JRUBY_VERSION)
+            java[i18n_lang]
+          else
+            begin
+              c[i18n_lang]
+            rescue NameError, LoadError => e
+              warn("WARNING: #{e.message}. Reverting to Ruby lexer.") unless defined?(@warned)
+              @warned = true
+              rb[i18n_lang]
+            end
+          end
+        rescue LoadError => e
+          raise I18nLexerNotFound, "No lexer was found for #{i18n_lang} (#{e.message}). Supported languages are listed in gherkin/i18n.yml."
+        end
+      end
+
+      def c
+        require 'gherkin/c_lexer'
+        CLexer
+      end
+
+      def java
+        require 'gherkin/java_lexer'
+        JavaLexer
+      end
+
+      def rb
+        require 'gherkin/rb_lexer'
+        RbLexer
+      end
+    end
+  end
+end

data/lib/gherkin/parser.rb

@@ -0,0 +1,19 @@
+module Gherkin
+  class ParseError < StandardError
+    def initialize(state, new_state, expected_states, line)
+      super("Parse error on line #{line}. Found #{new_state} when expecting one of: #{expected_states.join(', ')}. (Current state: #{state}).")
+    end
+  end
+
+  class Parser
+    def self.new(listener, raise_on_error=false, machine_names='root')
+      if defined?(JRUBY_VERSION)
+        require 'gherkin.jar'
+        Java::Gherkin::Parser.new(listener, raise_on_error, machine_names)
+      else
+        require 'gherkin/rb_parser'
+        Gherkin::RbParser.new(listener, raise_on_error, machine_names)
+      end
+    end
+  end
+end

data/lib/gherkin/parser/meta.txt

@@ -0,0 +1,4 @@
+ |         | feature | background | scenario | scenario_outline | examples | step  | table | py_string | comment | tag |
+ | meta    | E       | E          | E        | E                | E        | E     | E     | E         | comment | tag |
+ | comment | pop()   | pop()      | pop()    | pop()            | pop()    | pop() | pop() | pop()     | pop()   | tag |
+ | tag     | pop()   | E          | pop()    | pop()            | pop()    | E     | E     | E         | E       | tag |

data/lib/gherkin/parser/root.txt

@@ -0,0 +1,9 @@
+ |                  | feature | background | scenario | scenario_outline | examples | step | table          | py_string | comment    | tag        |
+ | root             | feature | E          | E        | E                | E        | E    | E              | E         | push(meta) | push(meta) |
+ | feature          | E       | background | scenario | scenario_outline | E        | E    | E              | E         | push(meta) | push(meta) |
+ | step             | E       | E          | scenario | scenario_outline | examples | step | step           | step      | push(meta) | push(meta) |
+ | background       | E       | E          | scenario | scenario_outline | E        | step | E              | E         | push(meta) | push(meta) |
+ | scenario         | E       | E          | scenario | scenario_outline | E        | step | E              | E         | push(meta) | push(meta) |
+ | scenario_outline | E       | E          | E        | E                | E        | step | E              | E         | push(meta) | push(meta) |
+ | examples         | E       | E          | E        | E                | E        | E    | examples_table | E         | push(meta) | push(meta) |
+ | examples_table   | E       | E          | scenario | scenario_outline | examples | E    | E              | E         | push(meta) | push(meta) |

data/lib/gherkin/parser/steps.txt

@@ -0,0 +1,3 @@
+ |       | feature | background | scenario | scenario_outline | examples | step | table | py_string | comment | tag |
+ | steps | E       | E          | E        | E                | E        | step | E     | E         | E       | E   |
+ | step  | E       | E          | E        | E                | E        | step | steps | steps     | E       | E   |

data/lib/gherkin/rb_lexer.rb

@@ -0,0 +1,10 @@
+module Gherkin
+  module RbLexer
+    def self.[](i18n_language)
+      name = i18n_language.gsub(/[\s-]/, '')
+      require "gherkin/rb_lexer/#{name}"
+      i18n_lexer_class_name = name.capitalize
+      const_get(i18n_lexer_class_name)
+    end
+  end
+end

data/lib/gherkin/rb_lexer/.gitignore

@@ -0,0 +1 @@
+*.rb

data/lib/gherkin/rb_lexer/README.rdoc

@@ -0,0 +1,8 @@
+= Lexers
+
+Gherkin support lexing of lots of natural languages, defined by gherkin/i18n.yml
+The lexers are generated with the following command:
+
+    rake ragel:i18n
+
+You have to run this command if you modify gherkin/i18n.yml

data/lib/gherkin/rb_parser.rb

@@ -0,0 +1,117 @@
+module Gherkin
+  class RbParser
+    # Initialize the parser. +machine_name+ refers to a state machine table.
+    def initialize(listener, raise_on_error, machine_name)
+      @listener = listener
+      @raise_on_error = raise_on_error
+      @machines = []
+      push_machine(machine_name)
+    end
+
+    # Doesn't yet fall back to super
+    def method_missing(method, *args)
+      # TODO: Catch exception and call super
+      if(event(method.to_s, args[-1]))
+        @listener.send(method, *args)
+      end
+    end
+
+    def event(ev, line)
+      machine.event(ev, line) do |state, expected|
+        if @raise_on_error
+          raise ParseError.new(state, ev, expected, line)
+        else
+          @listener.syntax_error(state, ev, expected, line)
+          return false
+        end
+      end
+      true
+    end
+
+    def push_machine(name)
+      @machines.push(Machine.new(self, name))
+    end
+
+    def pop_machine
+      @machines.pop
+    end
+
+    def machine
+      @machines[-1]
+    end
+
+    def expected
+      machine.expected
+    end
+
+    def force_state(state)
+      machine.instance_variable_set('@state', state)
+    end
+
+    class Machine
+      def initialize(parser, name)
+        @parser = parser
+        @name = name
+        @transition_map = transition_map(name)
+        @state = name
+      end
+
+      def event(ev, line)
+        states = @transition_map[@state]
+        raise "Unknown state: #{@state.inspect} for machine #{@name}" if states.nil?
+        new_state = states[ev]
+        case new_state
+        when "E"
+          yield @state, expected
+        when /push\((.+)\)/
+          @parser.push_machine($1)
+          @parser.event(ev, line)
+        when "pop()"
+          @parser.pop_machine()
+          @parser.event(ev, line)
+        else
+          raise "Unknown transition: #{ev.inspect} among #{states.inspect} for machine #{@name}" if new_state.nil?
+          @state = new_state
+        end
+      end
+
+      def expected
+        allowed = @transition_map[@state].find_all { |_, action| action != "E" }
+        allowed.collect { |state| state[0] }.sort
+      end
+
+      private
+
+      @@transition_maps = {}
+
+      def transition_map(name)
+        @@transition_maps[name] ||= build_transition_map(name)
+      end
+
+      def build_transition_map(name)
+        table = transition_table(name)
+        events = table.shift[1..-1]
+        table.inject({}) do |machine, actions|
+          state = actions.shift
+          machine[state] = Hash[*events.zip(actions).flatten]
+          machine
+        end
+      end
+
+      def transition_table(name)
+        state_machine_reader = StateMachineReader.new
+        lexer = Gherkin::Lexer['en'].new(state_machine_reader)
+        lexer.scan(File.read(File.dirname(__FILE__) + "/parser/#{name}.txt"))
+        state_machine_reader.rows
+      end
+
+      class StateMachineReader
+        attr_reader :rows
+        def table(rows, line_number)
+          @rows = rows
+        end
+      end
+
+    end
+  end
+end

data/lib/gherkin/tools.rb

@@ -0,0 +1,8 @@
+module Gherkin
+  module Tools
+    SUB_COMMANDS = %w(stats reformat)
+    SUB_COMMANDS.each do |cmd|
+      autoload cmd.capitalize.to_sym, "gherkin/tools/#{cmd}"
+    end
+  end
+end

data/lib/gherkin/tools/files.rb

@@ -0,0 +1,30 @@
+require 'gherkin'
+
+module Gherkin
+  module Tools
+    # Base class for file based operations
+    class Files
+      include Enumerable
+
+      def initialize(paths)
+        raise "Please specify one or more paths" if paths.empty?
+        @paths = paths
+      end
+
+      def each(&proc)
+        globs = @paths.map do |path|
+          raise "#{path} does not exist" unless File.exist?(path)
+          File.directory?(path) ? File.join(path, '**', '*.feature') : path
+        end
+
+        Dir[*globs].uniq.sort.each(&proc)
+      end
+
+      def scan(file, listener)
+        parser = Parser.new(listener, true)
+        lexer = I18nLexer.new(parser)
+        lexer.scan(IO.read(file))
+      end
+    end
+  end
+end

data/lib/gherkin/tools/pretty_listener.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+module Gherkin
+  module Tools
+    class PrettyListener
+      def initialize(io)
+        @io = io
+        @tags = nil
+      end
+
+      def tag(name, line)
+        @tags ||= []
+        @tags << "@#{name}"
+      end
+
+      def comment(content, line)
+        @io.puts content
+      end
+
+      def feature(keyword, name, line)
+        tags = @tags ? @tags.join(' ') + "\n" : ''
+        @tags = nil
+        @io.puts "#{tags}#{keyword}: #{indent(name, '  ')}"
+      end
+
+      def background(keyword, name, line)
+        @io.puts "\n  #{keyword}: #{indent(name, '    ')}"
+      end
+
+      def scenario(keyword, name, line)
+        tags = @tags ? '  ' + @tags.join(' ') + "\n" : ''
+        @tags = nil
+        @io.puts "\n#{tags}  #{keyword}: #{indent(name, '    ')}"
+      end
+
+      def scenario_outline(keyword, name, line)
+        tags = @tags ? '  ' + @tags.join(' ') + "\n" : ''
+        @tags = nil
+        @io.puts "\n#{tags}  #{keyword}: #{indent(name, '    ')}"
+      end
+
+      def examples(keyword, name, line)
+        @io.puts "\n    #{keyword}: #{indent(name, '    ')}"
+      end
+
+      def step(keyword, name, line)
+        @io.puts "    #{keyword} #{indent(name, '    ')}"
+      end
+
+      def table(rows, line)
+        rows = rows.to_a.map {|row| row.to_a} if defined?(JRUBY_VERSION) # Convert ArrayList
+        max_lengths =  rows.transpose.map { |col| col.map { |cell| cell.unpack("U*").length }.max }.flatten
+        rows.each do |table_line|
+          @io.puts '      | ' + table_line.zip(max_lengths).map { |cell, max_length| cell + ' ' * (max_length-cell.unpack("U*").length) }.join(' | ') + ' |'
+        end
+      end
+
+      def py_string(string, line)
+        @io.puts "      \"\"\"\n" + string.gsub(START, '      ') + "\n      \"\"\""
+      end
+
+      def syntax_error(state, event, legal_events, line)
+        raise "SYNTAX ERROR"
+      end
+
+    private
+      if(RUBY_VERSION =~ /^1\.9/)
+        START = /#{"^".encode('UTF-8')}/
+        NL    = Regexp.new("\n".encode('UTF-8'))
+      else
+        START = /^/
+        NL    = /\n/n
+      end
+
+      def indent(string, indentation)
+        indent = ""
+        string.split(NL).map do |l|
+          s = "#{indent}#{l}"
+          indent = indentation
+          s
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/gherkin/tools/reformat.rb

@@ -0,0 +1,19 @@
+require 'stringio'
+require 'gherkin/tools/files'
+require 'gherkin/tools/pretty_listener'
+
+module Gherkin
+  module Tools
+    class Reformat < Files
+      def run
+        each do |file|
+          purdy = StringIO.new
+          listener = PrettyListener.new(purdy)
+          scan(file, listener)
+          purdy.rewind
+          File.open(file, 'w') {|io| io.write(purdy.read)}
+        end
+      end
+    end
+  end
+end

data/lib/gherkin/tools/stats.rb

@@ -0,0 +1,21 @@
+require 'gherkin'
+require 'gherkin/tools/files'
+require 'gherkin/tools/stats_listener'
+
+module Gherkin
+  module Tools
+    class Stats < Files
+      def run
+        listener = StatsListener.new
+        each do |f|
+          parser = Gherkin::Parser.new(listener, true)
+          lexer = Gherkin::I18nLexer.new(parser)
+          lexer.scan(IO.read(f))
+        end
+        puts "Features:  #{listener.features}"
+        puts "Scenarios: #{listener.scenarios}"
+        puts "Steps:     #{listener.steps}"
+      end
+    end
+  end
+end

data/lib/gherkin/tools/stats_listener.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+module Gherkin
+  module Tools
+    class StatsListener
+      attr_reader :features, :scenarios, :steps
+
+      def initialize
+        @features  = 0
+        @scenarios = 0
+        @steps     = 0
+      end
+
+      def tag(name, line)
+      end
+
+      def comment(content, line)
+      end
+
+      def feature(keyword, name, line)
+        @features += 1
+      end
+
+      def background(keyword, name, line)
+      end
+
+      def scenario(keyword, name, line)
+        @scenarios += 1
+      end
+
+      def scenario_outline(keyword, name, line)
+      end
+
+      def examples(keyword, name, line)
+      end
+
+      def step(keyword, name, line)
+        @steps += 1
+      end
+
+      def table(rows, line)
+      end
+
+      def py_string(string, line)
+      end
+
+      def syntax_error(state, event, legal_events, line)
+      end
+    end
+  end
+end