gherkin 1.0.2-i386-mingw32 → 1.0.3-i386-mingw32

data/lib/gherkin/rb_parser.rb

@@ -77,7 +77,7 @@ module Gherkin
 
       def expected
         allowed = @transition_map[@state].find_all { |_, action| action != "E" }
-        allowed.collect { |state| state[0] }.sort
+        allowed.collect { |state| state[0] }.sort - ['eof']
       end
 
       private
@@ -100,18 +100,26 @@ module Gherkin
 
       def transition_table(name)
         state_machine_reader = StateMachineReader.new
-        lexer = Gherkin::Lexer['en'].new(state_machine_reader)
+        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 table(rows, line_number)
-          @rows = rows
+
+        def initialize
+          @rows = []
+        end
+
+        def row(row, line_number)
+          @rows << row
+        end
+
+        def eof
         end
       end
 
     end
   end
-end
+end

data/lib/gherkin/tools/colors.rb

@@ -0,0 +1,119 @@
+require 'term/ansicolor'
+
+module Gherkin
+  module Tools
+    # Defines aliases for coloured output. You don't invoke any methods from this
+    # module directly, but you can change the output colours 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_param</tt> - defaults to <tt>yellow,bold</tt>
+    # * <tt>failed</tt>        - defaults to <tt>red</tt>
+    # * <tt>failed_param</tt>  - defaults to <tt>red,bold</tt>
+    # * <tt>passed</tt>        - defaults to <tt>green</tt>
+    # * <tt>passed_param</tt>  - defaults to <tt>green,bold</tt>
+    # * <tt>outline</tt>       - defaults to <tt>cyan</tt>
+    # * <tt>outline_param</tt> - defaults to <tt>cyan,bold</tt>
+    # * <tt>skipped</tt>       - defaults to <tt>cyan</tt>
+    # * <tt>skipped_param</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_param=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 Colors
+      include Term::ANSIColor
+
+      ALIASES = Hash.new do |h,k|
+        if k.to_s =~ /(.*)_param/
+          h[$1] + ',bold'
+        end
+      end.merge({
+        'undefined' => 'yellow',
+        'pending'   => 'yellow',
+        '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.each do |method, color|
+        unless method =~ /.*_param/
+          code = <<-EOF
+          def #{method}(string=nil, monochrome=false, &proc)
+            return string if monochrome
+            #{ALIASES[method].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method].split(",").length}
+          end
+          # This resets the colour to the non-param colour
+          def #{method}_param(string=nil, monochrome=false, &proc)
+            return string if monochrome
+            #{ALIASES[method+'_param'].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method+'_param'].split(",").length} + #{ALIASES[method].split(",").join(' + ')}
+          end
+          EOF
+          eval(code)
+        end
+      end
+    
+      def self.define_grey #:nodoc:
+        begin
+          gem 'genki-ruby-terminfo'
+          require 'terminfo'
+          case TermInfo.default_object.tigetnum("colors")
+          when 0
+            raise "Your terminal doesn't support colours"
+          when 1
+            ::Term::ANSIColor.coloring = false
+            alias grey white
+          when 2..8
+            alias grey white
+          else
+            define_real_grey
+          end
+        rescue Exception => e
+          if e.class.name == 'TermInfo::TermInfoError'
+            STDERR.puts "*** WARNING ***"
+            STDERR.puts "You have the genki-ruby-terminfo gem installed, but you haven't set your TERM variable."
+            STDERR.puts "Try setting it to TERM=xterm-256color to get grey colour in output"
+            STDERR.puts "\n"
+            alias grey white
+          else
+            define_real_grey
+          end
+        end
+      end
+    
+      def self.define_real_grey #:nodoc:
+        def grey(m) #:nodoc:
+          "\e[90m#{m}\e[0m"
+        end
+      end
+    
+      define_grey
+    end
+  end
+end

data/lib/gherkin/tools/files.rb

@@ -23,7 +23,12 @@ module Gherkin
       def scan(file, listener)
         parser = Parser.new(listener, true)
         lexer = I18nLexer.new(parser)
-        lexer.scan(IO.read(file))
+        begin
+          lexer.scan(IO.read(file))
+        rescue => e
+          e.message << " (#{file})"
+          raise e
+        end
       end
     end
   end

data/lib/gherkin/tools/pretty_listener.rb

@@ -1,10 +1,32 @@
 # encoding: utf-8
+
+require 'gherkin/tools/colors'
+require 'gherkin/format/monochrome_format'
+
 module Gherkin
   module Tools
+    # TODO: Rename to Gherkin::Pretty::PrettyReporter - that's what this class *does*
+    # (The fact that it conforms to the Gherkin Listener interface is secondary)
     class PrettyListener
-      def initialize(io)
+      include Gherkin::Tools::Colors
+      
+      class << self
+        def new(io, monochrome=false)
+          if defined?(JRUBY_VERSION)
+            require 'gherkin.jar'
+            Java::GherkinFormatter::PrettyFormatter.new(io, monochrome)
+          else
+            super
+          end
+        end
+      end
+
+      def initialize(io, monochrome=false)
         @io = io
+        @monochrome = monochrome
+        @format = @monochrome ? Format::MonochromeFormat.new : Format::AnsiColorFormat.new
         @tags = nil
+        @comments = nil
       end
 
       def tag(name, line)
@@ -13,45 +35,48 @@ module Gherkin
       end
 
       def comment(content, line)
-        @io.puts content
+        @comments ||= []
+        @comments << content
       end
 
       def feature(keyword, name, line)
-        tags = @tags ? @tags.join(' ') + "\n" : ''
-        @tags = nil
-        @io.puts "#{tags}#{keyword}: #{indent(name, '  ')}"
+        @io.puts "#{grab_comments!('')}#{grab_tags!('')}#{keyword}: #{indent(name, '  ')}"
       end
 
       def background(keyword, name, line)
-        @io.puts "\n  #{keyword}: #{indent(name, '    ')}"
+        @io.puts "\n#{grab_comments!('  ')}  #{keyword}: #{indent(name, '    ')}"
       end
 
-      def scenario(keyword, name, line)
-        tags = @tags ? '  ' + @tags.join(' ') + "\n" : ''
-        @tags = nil
-        @io.puts "\n#{tags}  #{keyword}: #{indent(name, '    ')}"
+      def scenario(keyword, name, line, location=nil)
+        flush_table
+        @io.puts "\n#{grab_comments!('  ')}#{grab_tags!('  ')}  #{keyword}: #{indent(name, '    ')}#{indented_scenario_location!(keyword, name, location)}"
       end
 
       def scenario_outline(keyword, name, line)
-        tags = @tags ? '  ' + @tags.join(' ') + "\n" : ''
-        @tags = nil
-        @io.puts "\n#{tags}  #{keyword}: #{indent(name, '    ')}"
+        flush_table
+        @io.puts "\n#{grab_comments!('  ')}#{grab_tags!('  ')}  #{keyword}: #{indent(name, '    ')}"
       end
 
       def examples(keyword, name, line)
-        @io.puts "\n    #{keyword}: #{indent(name, '    ')}"
+        flush_table
+        @io.puts "\n#{grab_comments!('    ')}#{grab_tags!('    ')}    #{keyword}: #{indent(name, '    ')}"
       end
 
-      def step(keyword, name, line)
-        @io.puts "    #{keyword} #{indent(name, '    ')}"
+      def step(keyword, name, line, status=nil, arguments=nil, location=nil)
+        flush_table
+        status_param = "#{status}_param" if status
+        name = Gherkin::Format::Argument.format(name, @format, (arguments || [])) 
+        #{|arg| status_param ? self.__send__(status_param, arg, @monochrome) : arg} if arguments
+
+        step = "#{keyword}#{indent(name, '    ')}"
+        step = self.__send__(status, step, @monochrome) if status
+
+        @io.puts("#{grab_comments!('    ')}    #{step}#{indented_step_location!(location)}")
       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
+      def row(row, line)
+        @rows ||= []
+        @rows << row
       end
 
       def py_string(string, line)
@@ -62,7 +87,48 @@ module Gherkin
         raise "SYNTAX ERROR"
       end
 
-    private
+      def eof
+        flush_table
+      end
+
+      # This method can be invoked before a #scenario, to ensure location arguments are aligned
+      def steps(steps)
+        @step_lengths = steps.map {|keyword, name| (keyword+name).unpack("U*").length}
+        @max_step_length = @step_lengths.max
+        @step_index = -1
+      end
+
+      def exception(exception)
+        exception_text = "#{exception.message} (#{exception.class})\n#{(exception.backtrace || []).join("\n")}".gsub(/^/, '      ')
+        @io.puts(failed(exception_text, @monochrome))
+      end
+
+      def flush_table(exception=nil, statuses=nil)
+        return if @rows.nil?
+        cell_lengths = @rows.map { |col| col.map { |cell| cell.unpack("U*").length }}
+        max_lengths = cell_lengths.transpose.map { |col_lengths| col_lengths.max }.flatten
+
+        @rows.each_with_index do |row, i|
+          j = -1
+          @io.puts '      | ' + row.zip(max_lengths).map { |cell, max_length|
+            j += 1
+            color(cell, statuses, j) + ' ' * (max_length - cell_lengths[i][j])
+          }.join(' | ') + ' |'
+          exception(exception) if exception
+        end
+        @rows = nil
+      end
+
+      private
+
+      def color(cell, statuses, col)
+        if statuses
+          self.__send__(statuses[col], cell, @monochrome) + (@monochrome ? '' : reset)
+        else
+          cell
+        end
+      end
+
       if(RUBY_VERSION =~ /^1\.9/)
         START = /#{"^".encode('UTF-8')}/
         NL    = Regexp.new("\n".encode('UTF-8'))
@@ -79,6 +145,32 @@ module Gherkin
           s
         end.join("\n")
       end
+
+      def grab_tags!(indent)
+        tags = @tags ? indent + @tags.join(' ') + "\n" : ''
+        @tags = nil
+        tags
+      end
+
+      def grab_comments!(indent)
+        comments = @comments ? indent + @comments.join("\n#{indent}") + "\n" : ''
+        @comments = nil
+        comments
+      end
+
+      def indented_scenario_location!(keyword, name, location)
+        return "" if location.nil?
+        l = (keyword+name).unpack("U*").length
+        @max_step_length = [@max_step_length, l].max
+        indent = @max_step_length - l
+        ' ' * indent + ' ' + comments("# #{location}", @monochrome)
+      end
+
+      def indented_step_location!(location)
+        return "" if location.nil?
+        indent = @max_step_length - @step_lengths[@step_index+=1]
+        ' ' * indent + ' ' + comments("# #{location}", @monochrome)
+      end
     end
   end
 end

data/ragel/lexer.c.rl.erb

@@ -14,12 +14,17 @@
 #ifdef HAVE_RUBY_ENCODING_H
 #include <ruby/encoding.h>
 #define ENCODED_STR_NEW(ptr, len) \
-    rb_enc_str_new(ptr, len, rb_utf8_encoding());
+    rb_enc_str_new(ptr, len, rb_utf8_encoding())
 #else
 #define ENCODED_STR_NEW(ptr, len) \
-    rb_str_new(ptr, len); 
+    rb_str_new(ptr, len)
 #endif
 
+#define LF_FLAG      0
+#define CRLF_FLAG    1
+#define LF           "\n"
+#define CRLF         "\r\n"
+
 #ifndef RSTRING_PTR
 #define RSTRING_PTR(s) (RSTRING(s)->ptr)
 #endif
@@ -39,23 +44,22 @@ typedef struct lexer_state {
   int line_number;
   int current_line;
   int start_col;
+  int eol;
   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 field_len;
   size_t query_start;
   size_t last_newline;
   size_t final_newline;
 } lexer_state;
 
 static VALUE mGherkin;
-static VALUE mLexer;
 static VALUE mCLexer;
 static VALUE cI18nLexer;
-static VALUE rb_eGherkinLexerError;
+static VALUE rb_eGherkinLexingError;
 
 #define LEN(AT, P) (P - data - lexer->AT)
 #define MARK(M, P) (lexer->M = (P) - data)
@@ -65,16 +69,16 @@ static VALUE rb_eGherkinLexerError;
   store_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->current_line, lexer->eol); \
     if (lexer->content_end != 0) { \
       p = PTR_TO(content_end - 1); \
     } \
-    lexer->content_end = 0;
+    lexer->content_end = 0
 
 #define STORE_ATTR(ATTR) \
     store_attr(listener, # ATTR, \
       PTR_TO(content_start), LEN(content_start, p), \
-      lexer->line_number);
+      lexer->line_number)
 
 %%{
   machine lexer;
@@ -102,39 +106,39 @@ static VALUE rb_eGherkinLexerError;
   } 
  
   action store_feature_content {
-    STORE_KW_END_CON(feature)
+    STORE_KW_END_CON(feature);
   }
   
   action store_background_content {
-    STORE_KW_END_CON(background)
+    STORE_KW_END_CON(background);
   }
   
   action store_scenario_content {
-    STORE_KW_END_CON(scenario)
+    STORE_KW_END_CON(scenario);
   }
   
   action store_scenario_outline_content {
-    STORE_KW_END_CON(scenario_outline)
+    STORE_KW_END_CON(scenario_outline);
   }
   
   action store_examples_content {
-    STORE_KW_END_CON(examples)
+    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);
+      lexer->current_line, lexer->eol);
   }
   
   action store_comment_content {
-    STORE_ATTR(comment)
+    STORE_ATTR(comment);
     lexer->mark = 0;
   }
   
   action store_tag_content {
-    STORE_ATTR(tag)
+    STORE_ATTR(tag);
     lexer->mark = 0;
   }
   
@@ -164,11 +168,10 @@ static VALUE rb_eGherkinLexerError;
     MARK(content_end, p);
   }
 
-  action start_table {
+  action start_row {
     p = p - 1;
     lexer->current_line = lexer->line_number;
-    rb_ary_clear(rows);
-    rb_ary_clear(current_row);
+    current_row = rb_ary_new();
   }
   
   action begin_cell_content {
@@ -176,29 +179,20 @@ static VALUE rb_eGherkinLexerError;
   }
 
   action store_cell_content {
-    VALUE con = Qnil;
-    con = ENCODED_STR_NEW(PTR_TO(content_start), LEN(content_start, p));
+    VALUE con = ENCODED_STR_NEW(PTR_TO(content_start), LEN(content_start, p));
     rb_funcall(con, rb_intern("strip!"), 0);
 
     rb_ary_push(current_row, con);
   }
 
-  action start_row {
-    current_row = rb_ary_new();
-  }  
-
   action store_row {
-    rb_ary_push(rows, current_row);
-  }
-
-  action store_table {
-    rb_funcall(listener, rb_intern("table"), 2, rows, INT2FIX(lexer->current_line));
+    rb_funcall(listener, rb_intern("row"), 2, current_row, INT2FIX(lexer->current_line));
   }
 
   action end_feature {
     if (cs < lexer_first_final) {
       if (raise_lexer_error != NULL) {
-        int count = 0;
+        size_t count = 0;
         int newstr_count = 0;
         size_t len;
         const char *buff;
@@ -229,8 +223,10 @@ static VALUE rb_eGherkinLexerError;
 
         int line = lexer->line_number;
         lexer_init(lexer); // Re-initialize so we can scan again with the same lexer
-        raise_lexer_error(listener, newstr, line);
+        raise_lexer_error(newstr, line);
       }
+    } else {
+      rb_funcall(listener, rb_intern("eof"), 0);
     }
   }
 
@@ -251,28 +247,28 @@ strip_i(VALUE str, VALUE ary)
 }
 
 static VALUE 
-multiline_strip(VALUE text)
+multiline_strip(VALUE text, int eol)
 {
   VALUE map = rb_ary_new();
   VALUE split = rb_str_split(text, "\n");
   
   rb_iterate(rb_each, split, strip_i, map);
   
-  return rb_ary_join(split, rb_str_new2("\n"));
+  return rb_ary_join(split, rb_str_new2( \
+          eol == CRLF_FLAG ? CRLF : LF ));
 }
 
 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)
+             int current_line, int eol)
 {
   VALUE con = Qnil, kw = Qnil;
   kw = ENCODED_STR_NEW(keyword_at, keyword_length);
   con = ENCODED_STR_NEW(at, length);
-  con = multiline_strip(con);
+  con = multiline_strip(con, eol);
   rb_funcall(con, rb_intern("strip!"), 0);
-  rb_funcall(kw, rb_intern("strip!"), 0);
   rb_funcall(listener, rb_intern(event_name), 3, kw, con, INT2FIX(current_line)); 
 }
 
@@ -296,14 +292,30 @@ store_pystring_content(VALUE listener,
   char pat[32]; 
   snprintf(pat, 32, "^ {0,%d}", start_col); 
   VALUE re = rb_reg_regcomp(rb_str_new2(pat));
+  VALUE re2 = rb_reg_regcomp(rb_str_new2("\r\\Z"));
   rb_funcall(con, rb_intern("gsub!"), 2, re, rb_str_new2(""));
+  rb_funcall(con, rb_intern("sub!"), 2, re2, rb_str_new2(""));
   rb_funcall(listener, rb_intern("py_string"), 2, con, INT2FIX(current_line));
 }
 
 static void 
-raise_lexer_error(VALUE listener, const char * at, int line)
+raise_lexer_error(const char * at, int line)
 { 
-  rb_raise(rb_eGherkinLexerError, "Lexing error on line %d: '%s'.", line, at);
+  rb_raise(rb_eGherkinLexingError, "Lexing error on line %d: '%s'.", line, at);
+}
+
+static int 
+count_char(char char_to_count, char *str) {
+
+  int count = 0;
+  int i = 0;
+  while(str[i] != '\0') {
+    if(str[i] == char_to_count) {
+      count++;
+    }
+    i++;
+  }
+  return count;
 }
 
 static void lexer_init(lexer_state *lexer) {
@@ -311,7 +323,6 @@ static void lexer_init(lexer_state *lexer) {
   lexer->content_end = 0;
   lexer->content_len = 0;
   lexer->mark = 0;
-  lexer->field_len = 0;
   lexer->keyword_start = 0;
   lexer->keyword_end = 0;
   lexer->next_keyword_start = 0;
@@ -319,6 +330,7 @@ static void lexer_init(lexer_state *lexer) {
   lexer->last_newline = 0;
   lexer->final_newline = 0;
   lexer->start_col = 0;
+  lexer->eol = LF_FLAG;
 }
 
 static VALUE CLexer_alloc(VALUE klass)
@@ -348,41 +360,45 @@ static VALUE CLexer_scan(VALUE self, VALUE input)
   lexer_state *lexer = NULL;
   DATA_GET(self, lexer_state, lexer);
 
+
   VALUE input_copy = rb_str_dup(input);
+
   rb_str_append(input_copy, rb_str_new2("\n%_FEATURE_END_%"));
   char *data = RSTRING_PTR(input_copy);
-  long len = RSTRING_LEN(input_copy);
+  size_t len = RSTRING_LEN(input_copy);
+  
+  if (count_char('\r', data) > (count_char('\n', data) / 2)) {
+    lexer->eol = CRLF_FLAG;
+  }
   
   if (len == 0) { 
-    rb_raise(rb_eGherkinLexerError, "No content to lex.");
+    rb_raise(rb_eGherkinLexingError, "No content to lex.");
   } else {
+
     const char *p, *pe, *eof;
     int cs = 0;
     
     VALUE listener = rb_iv_get(self, "@listener");
-    VALUE rows = rb_ary_new();
-    VALUE current_row = rb_ary_new();
-    
+    VALUE current_row = Qnil;
+
     p = data;
     pe = data + len;
     eof = pe;
     
     assert(*pe == '\0' && "pointer does not end on NULL");
-    assert(pe - p == len && "pointers aren't same distance");
     
     %% 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");
-    assert(lexer->field_len <= len && "field has length longer than the whole data");
     
     // Reset lexer by re-initializing the whole thing
     lexer_init(lexer);
 
     if (cs == lexer_error) {
-      rb_raise(rb_eGherkinLexerError, "Invalid format, lexing fails.");
+      rb_raise(rb_eGherkinLexingError, "Invalid format, lexing fails.");
     } else {
       return Qtrue;
     }
@@ -392,8 +408,7 @@ static VALUE CLexer_scan(VALUE self, VALUE input)
 void Init_gherkin_lexer_<%= @i18n.sanitized_key %>()
 {
   mGherkin = rb_define_module("Gherkin");
-  mLexer = rb_const_get(mGherkin, rb_intern("Lexer"));
-  rb_eGherkinLexerError = rb_const_get(mLexer, rb_intern("LexingError"));
+  rb_eGherkinLexingError = rb_const_get(mGherkin, rb_intern("LexingError"));
 
   mCLexer = rb_define_module_under(mGherkin, "CLexer");
   cI18nLexer = rb_define_class_under(mCLexer, "<%= @i18n.sanitized_key.capitalize %>", rb_cObject);
@@ -401,3 +416,4 @@ void Init_gherkin_lexer_<%= @i18n.sanitized_key %>()
   rb_define_method(cI18nLexer, "initialize", CLexer_init, 1);
   rb_define_method(cI18nLexer, "scan", CLexer_scan, 1);
 }
+