gherkin 1.0.3-java → 1.0.4-java

data/java/src/gherkin/parser/StateMachineReader.java

@@ -1,67 +0,0 @@
-package gherkin.parser;
-
-import gherkin.FixJava;
-import gherkin.Lexer;
-import gherkin.Listener;
-import gherkin.lexer.En;
-
-import java.io.IOException;
-import java.util.List;
-import java.util.ArrayList;
-
-public class StateMachineReader implements Listener {
-    private final String machinePath;
-    private List<List<String>> transitionTable;
-
-    public StateMachineReader(String name) {
-        machinePath = "/gherkin/parser/" + name + ".txt";
-    }
-
-    public List<List<String>> transitionTable() {
-		transitionTable = new ArrayList<List<String>>();
-        Lexer lexer = new En(this);
-        try {
-            lexer.scan(FixJava.readResource(machinePath));
-        } catch (IOException e) {
-            throw new RuntimeException("Fatal error. Couldn't read " + machinePath);
-        }
-        return transitionTable;
-    }
-
-    public void tag(String name, int line) {
-    }
-
-    public void comment(String content, int line) {
-    }
-
-    public void feature(String keyword, String name, int line) {
-    }
-
-    public void background(String keyword, String name, int line) {
-    }
-
-    public void scenario(String keyword, String name, int line) {
-    }
-
-    public void scenario_outline(String keyword, String name, int line) {
-    }
-
-    public void examples(String keyword, String name, int line) {
-    }
-
-    public void step(String keyword, String name, int line) {
-    }
-
-    public void py_string(String string, int line) {
-    }
-
-    public void eof() {
-    }
-
-    public void syntax_error(String name, String event, List<String> strings, int line) {
-    }
-
-    public void row(List<String> row, int line) {
-        transitionTable.add(row);
-    }
-}

data/java/test/gherkin/formatter/ArgumentTest.java

@@ -1,17 +0,0 @@
-package gherkin.formatter;
-
-import org.junit.Test;
-
-import java.io.UnsupportedEncodingException;
-
-import static org.junit.Assert.assertEquals;
-
-public class ArgumentTest {
-    @Test
-    public void shouldFormatAscii() throws UnsupportedEncodingException {
-        assertEquals("I have [[[[åtte] cukes i [[[[bøtta]", Argument.format("I have åtte cukes i bøtta", new ArgumentFormat("[[[[", "]"),
-                new Argument(7, "åtte"),
-                new Argument(21, "bøtta")
-                ));
-    }
-}

data/lib/gherkin/lexer.rb

@@ -1,35 +0,0 @@
-module Gherkin
-  module Lexer
-
-    class << self
-      def [](i18n_lang)
-        begin
-          begin
-            c[i18n_lang]
-          rescue NameError, LoadError => e
-            raise("WARNING: #{e.message}. Reverting to Ruby lexer.") unless defined?(@warned)
-            @warned = true
-            rb[i18n_lang]
-          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 csharp
-        require 'gherkin/csharp_lexer'
-        CSharpLexer
-      end
-
-      def rb
-        require 'gherkin/rb_lexer'
-        RbLexer
-      end
-    end
-  end
-end

data/lib/gherkin/parser.rb

@@ -1,19 +0,0 @@
-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_name='root')
-      if defined?(JRUBY_VERSION)
-        require 'gherkin.jar'
-        Java::Gherkin::Parser.new(listener, raise_on_error, machine_name)
-      else
-        require 'gherkin/rb_parser'
-        Gherkin::RbParser.new(listener, raise_on_error, machine_name)
-      end
-    end
-  end
-end

data/lib/gherkin/rb_parser.rb

@@ -1,125 +0,0 @@
-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 - ['eof']
-      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::I18nLexer.lexer_class('en', false).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 initialize
-          @rows = []
-        end
-
-        def row(row, line_number)
-          @rows << row
-        end
-
-        def eof
-        end
-      end
-
-    end
-  end
-end

data/spec/gherkin/parser_spec.rb

@@ -1,33 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'gherkin/parser'
-
-module Gherkin
-  describe Parser do
-    before do
-      @listener = mock('listener')
-      @parser = Parser.new(@listener, true)
-    end
-
-    it "should delegate events to the listener" do
-      @listener.should_receive(:comment).with("# Content", 1)
-      @parser.comment("# Content", 1)
-    end
-
-    it "should raise helpful error messages by default" do
-      lambda { 
-        @parser.scenario("Scenario", "My pet scenario", 12) 
-      }.should raise_error(/Parse error on line 12\. Found scenario when expecting one of: comment, feature, tag\. \(Current state: root\)\.$/)
-    end
-
-    it "should allow empty files" do
-      @listener.should_receive(:eof)
-      @parser.eof
-    end
-
-    it "should delegate an error message when raise on error is false" do
-      @listener.should_receive(:syntax_error).with(sym(:root), sym(:background), a([:comment, :feature, :tag]), 1)
-      @parser = Parser.new(@listener, false)
-      @parser.background("Background", "Content", 1)
-    end
-  end
-end