benhamill-gherkin 2.3.5

data/lib/gherkin/native/null.rb

@@ -0,0 +1,9 @@
+class Class
+  def implements(java_class_name)
+    # no-op
+  end
+
+  def native_impl(lib)
+    # no-op
+  end
+end

data/lib/gherkin/parser/meta.txt

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

data/lib/gherkin/parser/parser.rb

@@ -0,0 +1,164 @@
+require 'gherkin/i18n'
+require 'gherkin/lexer/i18n_lexer'
+require 'gherkin/native'
+require 'gherkin/listener/formatter_listener'
+
+module Gherkin
+  module Parser
+    class ParseError < StandardError
+      def initialize(state, new_state, expected_states, uri, line)
+        super("Parse error at #{uri}:#{line}. Found #{new_state} when expecting one of: #{expected_states.join(', ')}. (Current state: #{state}).")
+      end
+    end
+
+    class Parser
+      native_impl('gherkin')
+
+      # Initialize the parser. +machine_name+ refers to a state machine table.
+      def initialize(formatter, raise_on_error=true, machine_name='root', force_ruby=false)
+        @formatter = formatter
+        @listener = Listener::FormatterListener.new(@formatter)
+        @raise_on_error = raise_on_error
+        @machine_name = machine_name
+        @machines = []
+        push_machine(@machine_name)
+        @lexer = Gherkin::Lexer::I18nLexer.new(self, force_ruby)
+      end
+
+      def parse(gherkin, feature_uri, line_offset)
+        @formatter.uri(feature_uri)
+        @line_offset = line_offset
+        @lexer.scan(gherkin)
+      end
+
+      def i18n_language
+        @lexer.i18n_language
+      end
+
+      def errors
+        @lexer.errors
+      end
+
+      # Doesn't yet fall back to super
+      def method_missing(method, *args)
+        # TODO: Catch exception and call super
+        event(method.to_s, args[-1])
+        @listener.__send__(method, *args)
+        if method == :eof
+          pop_machine
+          push_machine(@machine_name)
+        end
+      end
+
+      def event(ev, line)
+        l = line ? @line_offset+line : nil
+        machine.event(ev, l) do |state, legal_events|
+          if @raise_on_error
+            raise ParseError.new(state, ev, legal_events, @feature_uri, l)
+          else
+            # Only used for testing
+            @listener.syntax_error(state, ev, legal_events, @feature_uri, l)
+          end
+        end
+      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::I18n.new('en').lexer(state_machine_reader)
+          machine = File.dirname(__FILE__) + "/#{name}.txt"
+          lexer.scan(File.read(machine))
+          state_machine_reader.rows
+        end
+
+        class StateMachineReader
+          attr_reader :rows
+
+          def initialize
+            @rows = []
+          end
+
+          def uri(uri)
+          end
+
+          def row(row, line_number)
+            @rows << row
+          end
+
+          def eof
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/gherkin/parser/root.txt

@@ -0,0 +1,11 @@
+ |                  | feature | background | scenario | scenario_outline | examples | step         | row            | py_string    | eof | comment    | tag        |
+ | root             | feature | E          | E        | E                | E        | E            | E              | E            | eof | push(meta) | push(meta) |
+ | feature          | E       | background | scenario | scenario_outline | E        | E            | E              | E            | eof | push(meta) | push(meta) |
+ | step             | E       | E          | scenario | scenario_outline | E        | step         | step           | step         | eof | push(meta) | push(meta) |
+ | outline_step     | E       | E          | scenario | scenario_outline | examples | outline_step | outline_step   | outline_step | eof | push(meta) | push(meta) |
+ | background       | E       | E          | scenario | scenario_outline | E        | step         | E              | E            | eof | push(meta) | push(meta) |
+ | scenario         | E       | E          | scenario | scenario_outline | E        | step         | E              | E            | eof | push(meta) | push(meta) |
+ | scenario_outline | E       | E          | E        | E                | E        | outline_step | E              | E            | eof | push(meta) | push(meta) |
+ | examples         | E       | E          | E        | E                | E        | E            | examples_table | E            | eof | push(meta) | push(meta) |
+ | examples_table   | E       | E          | scenario | scenario_outline | examples | E            | examples_table | E            | eof | push(meta) | push(meta) |
+ | eof              | E       | E          | E        | E                | E        | E            | E              | E            | E   | E          | E          |

data/lib/gherkin/parser/steps.txt

@@ -0,0 +1,4 @@
+ |       | feature | background | scenario | scenario_outline | examples | step | row  | py_string | eof | comment | tag |
+ | steps | E       | E          | E        | E                | E        | step | E    | E         | eof | E       | E   |
+ | step  | E       | E          | E        | E                | E        | step | step | steps     | eof | E       | E   |
+ | eof   | E       | E          | E        | E                | E        | E    | E    | E         | E   | E       | E   |

data/lib/gherkin/rb_lexer.rb

@@ -0,0 +1,8 @@
+module Gherkin
+  module RbLexer
+    def self.[](i18n_underscored_iso_code)
+      require "gherkin/rb_lexer/#{i18n_underscored_iso_code}"
+      const_get(i18n_underscored_iso_code.capitalize)
+    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/rubify.rb

@@ -0,0 +1,24 @@
+module Gherkin
+  module Rubify
+    if defined?(JRUBY_VERSION)
+      # Translate Java objects to Ruby.
+      # This is especially important to convert java.util.List coming
+      # from Java and back to a Ruby Array.
+      def rubify(o)
+        case(o)
+        when Java.java.util.Collection, Array
+          o.map{|e| rubify(e)}
+        when Java.gherkin.formatter.model.PyString
+          require 'gherkin/formatter/model'
+          Formatter::Model::PyString.new(o.value, o.line)
+        else
+          o
+        end
+      end
+    else
+      def rubify(o)
+        o
+      end
+    end
+  end
+end

data/lib/gherkin/tag_expression.rb

@@ -0,0 +1,62 @@
+require 'gherkin/native'
+
+module Gherkin
+  class TagExpression
+    native_impl('gherkin')
+
+    attr_reader :limits
+
+    def initialize(tag_expressions)
+      @ands = []
+      @limits = {}
+      tag_expressions.each do |expr|
+        add(expr.strip.split(/\s*,\s*/))
+      end
+    end
+
+    def empty?
+      @ands.empty?
+    end
+
+    def eval(tags)
+      return true if @ands.flatten.empty?
+      vars = Hash[*tags.map{|tag| [tag, true]}.flatten]
+      !!Kernel.eval(ruby_expression)
+    end
+
+  private
+
+    def add(tags_with_negation_and_limits)
+      negatives, positives = tags_with_negation_and_limits.partition{|tag| tag =~ /^~/}
+      @ands << (store_and_extract_limits(negatives, true) + store_and_extract_limits(positives, false))
+    end
+
+    def store_and_extract_limits(tags_with_negation_and_limits, negated)
+      tags_with_negation = []
+      tags_with_negation_and_limits.each do |tag_with_negation_and_limit|
+        tag_with_negation, limit = tag_with_negation_and_limit.split(':')
+        tags_with_negation << tag_with_negation
+        if limit
+          tag_without_negation = negated ? tag_with_negation[1..-1] : tag_with_negation
+          if @limits[tag_without_negation] && @limits[tag_without_negation] != limit.to_i
+            raise "Inconsistent tag limits for #{tag_without_negation}: #{@limits[tag_without_negation]} and #{limit.to_i}" 
+          end
+          @limits[tag_without_negation] = limit.to_i
+        end
+      end
+      tags_with_negation
+    end
+
+    def ruby_expression
+      "(" + @ands.map do |ors|
+        ors.map do |tag|
+          if tag =~ /^~(.*)/
+            "!vars['#{$1}']"
+          else
+            "vars['#{tag}']"
+          end
+        end.join("||")
+      end.join(")&&(") + ")"
+    end
+  end
+end

data/lib/gherkin/version.rb

@@ -0,0 +1,3 @@
+module Gherkin
+  VERSION = IO.read(File.dirname(__FILE__) + '/../../VERSION').strip
+end

data/ragel/i18n/.gitignore

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

data/ragel/lexer.c.rl.erb

@@ -0,0 +1,439 @@
+#include <assert.h>
+#include <ruby.h>
+
+#if defined(_WIN32)
+#include <stddef.h>
+#endif
+
+#ifdef HAVE_RUBY_RE_H
+#include <ruby/re.h>
+#else
+#include <re.h>
+#endif
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/encoding.h>
+#define ENCODED_STR_NEW(ptr, len) \
+    rb_enc_str_new(ptr, len, rb_utf8_encoding())
+#else
+#define ENCODED_STR_NEW(ptr, len) \
+    rb_str_new(ptr, len)
+#endif
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+#define DATA_GET(FROM, TYPE, NAME) \
+  Data_Get_Struct(FROM, TYPE, NAME); \
+  if (NAME == NULL) { \
+    rb_raise(rb_eArgError, "NULL found for " # NAME " when it shouldn't be."); \
+  }
+ 
+typedef struct lexer_state {
+  int content_len;
+  int line_number;
+  int current_line;
+  int start_col;
+  size_t mark;
+  size_t keyword_start;
+  size_t keyword_end;
+  size_t next_keyword_start;
+  size_t content_start;
+  size_t content_end;
+  size_t query_start;
+  size_t last_newline;
+  size_t final_newline;
+} lexer_state;
+
+static VALUE mGherkin;
+static VALUE mGherkinLexer;
+static VALUE mCLexer;
+static VALUE cI18nLexer;
+static VALUE rb_eGherkinLexingError;
+
+#define LEN(AT, P) (P - data - lexer->AT)
+#define MARK(M, P) (lexer->M = (P) - data)
+#define PTR_TO(P) (data + lexer->P)
+
+#define STORE_KW_END_CON(EVENT) \
+  store_multiline_kw_con(listener, # EVENT, \
+    PTR_TO(keyword_start), LEN(keyword_start, PTR_TO(keyword_end - 1)), \
+    PTR_TO(content_start), LEN(content_start, PTR_TO(content_end)), \
+    lexer->current_line, lexer->start_col); \
+    if (lexer->content_end != 0) { \
+      p = PTR_TO(content_end - 1); \
+    } \
+    lexer->content_end = 0
+
+#define STORE_ATTR(ATTR) \
+    store_attr(listener, # ATTR, \
+      PTR_TO(content_start), LEN(content_start, p), \
+      lexer->line_number)
+
+%%{
+  machine lexer;
+ 
+  action begin_content {
+		MARK(content_start, p);
+    lexer->current_line = lexer->line_number;
+    lexer->start_col = lexer->content_start - lexer->last_newline - (lexer->keyword_end - lexer->keyword_start) + 2;
+  }
+  
+  action begin_pystring_content {
+    MARK(content_start, p);
+  }
+
+  action start_pystring {
+    lexer->current_line = lexer->line_number;
+    lexer->start_col = p - data - lexer->last_newline;
+  }
+ 
+  action store_pystring_content {
+    int len = LEN(content_start, PTR_TO(final_newline));
+
+    if (len < 0) len = 0;
+
+    store_pystring_content(listener, lexer->start_col, PTR_TO(content_start), len, lexer->current_line);
+  } 
+ 
+  action store_feature_content {
+    STORE_KW_END_CON(feature);
+  }
+  
+  action store_background_content {
+    STORE_KW_END_CON(background);
+  }
+  
+  action store_scenario_content {
+    STORE_KW_END_CON(scenario);
+  }
+  
+  action store_scenario_outline_content {
+    STORE_KW_END_CON(scenario_outline);
+  }
+  
+  action store_examples_content {
+    STORE_KW_END_CON(examples);
+  }
+  
+  action store_step_content {
+    store_kw_con(listener, "step",
+      PTR_TO(keyword_start), LEN(keyword_start, PTR_TO(keyword_end)),
+      PTR_TO(content_start), LEN(content_start, p), 
+      lexer->current_line);
+  }
+  
+  action store_comment_content {
+    STORE_ATTR(comment);
+    lexer->mark = 0;
+  }
+  
+  action store_tag_content {
+    STORE_ATTR(tag);
+    lexer->mark = 0;
+  }
+  
+  action inc_line_number {
+    lexer->line_number += 1;
+    MARK(final_newline, p);
+  }
+    
+  action last_newline {
+    MARK(last_newline, p + 1);
+  }
+ 
+  action start_keyword {
+    if (lexer->mark == 0) {
+      MARK(mark, p);
+    }
+  }
+  
+  action end_keyword {
+    MARK(keyword_end, p);
+    MARK(keyword_start, PTR_TO(mark));
+    MARK(content_start, p + 1);
+    lexer->mark = 0;
+  }
+  
+  action next_keyword_start {
+    MARK(content_end, p);
+  }
+
+  action start_row {
+    p = p - 1;
+    lexer->current_line = lexer->line_number;
+    current_row = rb_ary_new();
+  }
+  
+  action begin_cell_content {
+		MARK(content_start, p);
+  }
+
+  action store_cell_content {
+    VALUE re_pipe, re_newline, re_backslash;
+    VALUE con = ENCODED_STR_NEW(PTR_TO(content_start), LEN(content_start, p));
+    rb_funcall(con, rb_intern("strip!"), 0);
+    re_pipe      = rb_reg_regcomp(rb_str_new2("\\\\\\|"));
+    re_newline   = rb_reg_regcomp(rb_str_new2("\\\\n"));
+    re_backslash = rb_reg_regcomp(rb_str_new2("\\\\\\\\"));
+    rb_funcall(con, rb_intern("gsub!"), 2, re_pipe,      rb_str_new2("|"));
+    rb_funcall(con, rb_intern("gsub!"), 2, re_newline,   rb_str_new2("\n"));
+    rb_funcall(con, rb_intern("gsub!"), 2, re_backslash, rb_str_new2("\\"));
+
+    rb_ary_push(current_row, con);
+  }
+
+  action store_row {
+    rb_funcall(listener, rb_intern("row"), 2, current_row, INT2FIX(lexer->current_line));
+  }
+
+  action end_feature {
+    int line;
+    if (cs < lexer_first_final) {
+      size_t count = 0;
+      VALUE newstr_val;
+      char *newstr;
+      int newstr_count = 0;        
+      size_t len;
+      const char *buff;
+      if (lexer->last_newline != 0) {
+        len = LEN(last_newline, eof);
+        buff = PTR_TO(last_newline);
+      } else {
+        len = strlen(data);
+        buff = data;
+      }
+
+      // Allocate as a ruby string so that it gets cleaned up by GC
+      newstr_val = rb_str_new(buff, len);
+      newstr = RSTRING_PTR(newstr_val);
+
+
+      for (count = 0; count < len; count++) {
+        if(buff[count] == 10) {
+          newstr[newstr_count] = '\0'; // terminate new string at first newline found
+          break;
+        } else {
+          if (buff[count] == '%') {
+            newstr[newstr_count++] = buff[count];
+            newstr[newstr_count] = buff[count];
+          } else {
+            newstr[newstr_count] = buff[count];
+          }
+        }
+        newstr_count++;
+      }
+
+      line = lexer->line_number;
+      lexer_init(lexer); // Re-initialize so we can scan again with the same lexer
+      raise_lexer_error(newstr, line);
+    } else {
+      rb_funcall(listener, rb_intern("eof"), 0);
+    }
+  }
+
+  include lexer_common "lexer_common.<%= @i18n.underscored_iso_code %>.rl";   
+
+}%%
+
+/** Data **/
+%% write data;
+
+static VALUE 
+unindent(VALUE con, int start_col)
+{
+  VALUE re;
+  // Gherkin will crash gracefully if the string representation of start_col pushes the pattern past 32 characters
+  char pat[32]; 
+  snprintf(pat, 32, "^[\t ]{0,%d}", start_col); 
+  re = rb_reg_regcomp(rb_str_new2(pat));
+  rb_funcall(con, rb_intern("gsub!"), 2, re, rb_str_new2(""));
+
+  return Qnil;
+
+}
+
+static void 
+store_kw_con(VALUE listener, const char * event_name, 
+             const char * keyword_at, size_t keyword_length, 
+             const char * at,         size_t length, 
+             int current_line)
+{
+  VALUE con = Qnil, kw = Qnil;
+  kw = ENCODED_STR_NEW(keyword_at, keyword_length);
+  con = ENCODED_STR_NEW(at, length);
+  rb_funcall(con, rb_intern("strip!"), 0);
+  rb_funcall(listener, rb_intern(event_name), 3, kw, con, INT2FIX(current_line)); 
+}
+
+static void
+store_multiline_kw_con(VALUE listener, const char * event_name,
+                      const char * keyword_at, size_t keyword_length,
+                      const char * at,         size_t length,
+                      int current_line, int start_col)
+{
+  VALUE split;
+  VALUE con = Qnil, kw = Qnil, name = Qnil, desc = Qnil;
+
+  kw = ENCODED_STR_NEW(keyword_at, keyword_length);
+  con = ENCODED_STR_NEW(at, length);
+
+  unindent(con, start_col);
+  
+  split = rb_str_split(con, "\n");
+
+  name = rb_funcall(split, rb_intern("shift"), 0);
+  desc = rb_ary_join(split, rb_str_new2( "\n" ));
+
+  if( name == Qnil ) 
+  {
+    name = rb_str_new2("");
+  }
+  if( rb_funcall(desc, rb_intern("size"), 0) == 0) 
+  {
+    desc = rb_str_new2("");
+  }
+  rb_funcall(name, rb_intern("strip!"), 0);
+  rb_funcall(desc, rb_intern("rstrip!"), 0);
+  rb_funcall(listener, rb_intern(event_name), 4, kw, name, desc, INT2FIX(current_line)); 
+}
+
+static void 
+store_attr(VALUE listener, const char * attr_type,
+           const char * at, size_t length, 
+           int line)
+{
+  VALUE val = ENCODED_STR_NEW(at, length);
+  rb_funcall(listener, rb_intern(attr_type), 2, val, INT2FIX(line));
+}
+
+static void 
+store_pystring_content(VALUE listener, 
+          int start_col, 
+          const char *at, size_t length, 
+          int current_line)
+{
+  VALUE re2;
+  VALUE unescape_escaped_quotes;
+  VALUE con = ENCODED_STR_NEW(at, length);
+
+  unindent(con, start_col);
+
+  re2 = rb_reg_regcomp(rb_str_new2("\r\\Z"));
+  unescape_escaped_quotes = rb_reg_regcomp(rb_str_new2("\\\\\"\\\\\"\\\\\""));
+  rb_funcall(con, rb_intern("sub!"), 2, re2, rb_str_new2(""));
+  rb_funcall(con, rb_intern("gsub!"), 2, unescape_escaped_quotes, rb_str_new2("\"\"\""));
+  rb_funcall(listener, rb_intern("py_string"), 2, con, INT2FIX(current_line));
+}
+
+static void 
+raise_lexer_error(const char * at, int line)
+{ 
+  rb_raise(rb_eGherkinLexingError, "Lexing error on line %d: '%s'. See http://wiki.github.com/aslakhellesoy/gherkin/lexingerror for more information.", line, at);
+}
+
+static void lexer_init(lexer_state *lexer) {
+  lexer->content_start = 0;
+  lexer->content_end = 0;
+  lexer->content_len = 0;
+  lexer->mark = 0;
+  lexer->keyword_start = 0;
+  lexer->keyword_end = 0;
+  lexer->next_keyword_start = 0;
+  lexer->line_number = 1;
+  lexer->last_newline = 0;
+  lexer->final_newline = 0;
+  lexer->start_col = 0;
+}
+
+static VALUE CLexer_alloc(VALUE klass)
+{
+  VALUE obj;
+  lexer_state *lxr = ALLOC(lexer_state);
+  lexer_init(lxr);
+
+  obj = Data_Wrap_Struct(klass, NULL, -1, lxr);
+
+  return obj;
+}
+
+static VALUE CLexer_init(VALUE self, VALUE listener)
+{
+  lexer_state *lxr; 
+  rb_iv_set(self, "@listener", listener);
+  
+  lxr = NULL;
+  DATA_GET(self, lexer_state, lxr);
+  lexer_init(lxr);
+  
+  return self;
+}
+
+static VALUE CLexer_scan(VALUE self, VALUE input)
+{
+  VALUE input_copy;
+  char *data;
+  size_t len;
+  VALUE listener = rb_iv_get(self, "@listener");
+
+  lexer_state *lexer;
+  lexer = NULL;
+  DATA_GET(self, lexer_state, lexer);
+
+  input_copy = rb_str_dup(input);
+
+  rb_str_append(input_copy, rb_str_new2("\n%_FEATURE_END_%"));
+  data = RSTRING_PTR(input_copy);
+  len = RSTRING_LEN(input_copy);
+  
+  if (len == 0) { 
+    rb_raise(rb_eGherkinLexingError, "No content to lex.");
+  } else {
+
+    const char *p, *pe, *eof;
+    int cs = 0;
+    
+    VALUE current_row = Qnil;
+
+    p = data;
+    pe = data + len;
+    eof = pe;
+    
+    assert(*pe == '\0' && "pointer does not end on NULL");
+    
+    %% write init;
+    %% write exec;
+
+    assert(p <= pe && "data overflow after parsing execute");
+    assert(lexer->content_start <= len && "content starts after data end");
+    assert(lexer->mark < len && "mark is after data end");
+    
+    // Reset lexer by re-initializing the whole thing
+    lexer_init(lexer);
+
+    if (cs == lexer_error) {
+      rb_raise(rb_eGherkinLexingError, "Invalid format, lexing fails.");
+    } else {
+      return Qtrue;
+    }
+  }
+}
+
+void Init_gherkin_lexer_<%= @i18n.underscored_iso_code %>()
+{
+  mGherkin = rb_define_module("Gherkin");
+  mGherkinLexer = rb_define_module_under(mGherkin, "Lexer");
+  rb_eGherkinLexingError = rb_const_get(mGherkinLexer, rb_intern("LexingError"));
+
+  mCLexer = rb_define_module_under(mGherkin, "CLexer");
+  cI18nLexer = rb_define_class_under(mCLexer, "<%= @i18n.underscored_iso_code.capitalize %>", rb_cObject);
+  rb_define_alloc_func(cI18nLexer, CLexer_alloc);
+  rb_define_method(cI18nLexer, "initialize", CLexer_init, 1);
+  rb_define_method(cI18nLexer, "scan", CLexer_scan, 1);
+}
+