tripper 0.0.3d

data/lib/tripper/model_parsers/database_fields_parser/DatabaseFieldsParserParser.rb

@@ -0,0 +1,279 @@
+#!/usr/bin/env ruby
+#
+# DatabaseFieldsParser.g
+# --
+# Generated using ANTLR version: 3.2.1-SNAPSHOT Jul 31, 2010 19:34:52
+# Ruby runtime library version: 1.8.11
+# Input grammar file: DatabaseFieldsParser.g
+# Generated at: 2013-05-15 13:56:44
+# 
+
+# ~~~> start load path setup
+this_directory = File.expand_path( File.dirname( __FILE__ ) )
+$LOAD_PATH.unshift( this_directory ) unless $LOAD_PATH.include?( this_directory )
+
+antlr_load_failed = proc do
+  load_path = $LOAD_PATH.map { |dir| '  - ' << dir }.join( $/ )
+  raise LoadError, <<-END.strip!
+  
+Failed to load the ANTLR3 runtime library (version 1.8.11):
+
+Ensure the library has been installed on your system and is available
+on the load path. If rubygems is available on your system, this can
+be done with the command:
+  
+  gem install antlr3
+
+Current load path:
+#{ load_path }
+
+  END
+end
+
+defined?( ANTLR3 ) or begin
+  
+  # 1: try to load the ruby antlr3 runtime library from the system path
+  require 'antlr3'
+  
+rescue LoadError
+  
+  # 2: try to load rubygems if it isn't already loaded
+  defined?( Gem ) or begin
+    require 'rubygems'
+  rescue LoadError
+    antlr_load_failed.call
+  end
+  
+  # 3: try to activate the antlr3 gem
+  begin
+    Gem.activate( 'antlr3', '~> 1.8.11' )
+  rescue Gem::LoadError
+    antlr_load_failed.call
+  end
+  
+  require 'antlr3'
+  
+end
+# <~~~ end load path setup
+
+# - - - - - - begin action @parser::header - - - - - -
+# DatabaseFieldsParser.g
+
+
+	def strip_quotes str
+		return str[1,(str.length)-2]
+	end
+
+# - - - - - - end action @parser::header - - - - - - -
+
+
+module DatabaseFieldsParser
+  # TokenData defines all of the token type integer values
+  # as constants, which will be included in all 
+  # ANTLR-generated recognizers.
+  const_defined?( :TokenData ) or TokenData = ANTLR3::TokenScheme.new
+
+  module TokenData
+
+    # define the token constants
+    define_tokens( :ACTUALSTRING => 9, :HC => 5, :T__12 => 12, :T__11 => 11, 
+                   :T__13 => 13, :T__10 => 10, :ATTRIBUTE => 4, :WHITESPACE => 8, 
+                   :LC => 6, :DIGIT => 7, :EOF => -1 )
+
+    # register the proper human-readable name or literal value
+    # for each token type
+    #
+    # this is necessary because anonymous tokens, which are
+    # created from literal values in the grammar, do not
+    # have descriptive names
+    register_names( "ATTRIBUTE", "HC", "LC", "DIGIT", "WHITESPACE", "ACTUALSTRING", 
+                    "'#'", "'database_fields'", "':'", "','" )
+    
+  end
+
+
+  class Parser < ANTLR3::Parser
+    @grammar_home = DatabaseFieldsParser
+
+    RULE_METHODS = [ :database_fields, :attributes, :attribute ].freeze
+
+
+    include TokenData
+
+    begin
+      generated_using( "DatabaseFieldsParser.g", "3.2.1-SNAPSHOT Jul 31, 2010 19:34:52", "1.8.11" )
+    rescue NoMethodError => error
+      # ignore
+    end
+
+    def initialize( input, options = {} )
+      super( input, options )
+
+
+    end
+
+    attr_accessor :attributes
+
+    # - - - - - - - - - - - - Rules - - - - - - - - - - - - -
+
+    # 
+    # parser rule database_fields
+    # 
+    # (in DatabaseFieldsParser.g)
+    # 15:1: database_fields returns [expr] : ( '#' 'database_fields' ':' ( attributes )* ( attribute )? ) ;
+    # 
+    def database_fields
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 1 )
+      expr = nil
+
+      begin
+        # at line 15:33: ( '#' 'database_fields' ':' ( attributes )* ( attribute )? )
+        # at line 15:33: ( '#' 'database_fields' ':' ( attributes )* ( attribute )? )
+        # at line 15:34: '#' 'database_fields' ':' ( attributes )* ( attribute )?
+        match( T__10, TOKENS_FOLLOWING_T__10_IN_database_fields_39 )
+        match( T__11, TOKENS_FOLLOWING_T__11_IN_database_fields_41 )
+        match( T__12, TOKENS_FOLLOWING_T__12_IN_database_fields_43 )
+        # at line 15:60: ( attributes )*
+        while true # decision 1
+          alt_1 = 2
+          look_1_0 = @input.peek( 1 )
+
+          if ( look_1_0 == ATTRIBUTE )
+            look_1_1 = @input.peek( 2 )
+
+            if ( look_1_1 == T__13 )
+              alt_1 = 1
+
+            end
+
+          end
+          case alt_1
+          when 1
+            # at line 15:60: attributes
+            @state.following.push( TOKENS_FOLLOWING_attributes_IN_database_fields_45 )
+            attributes
+            @state.following.pop
+
+          else
+            break # out of loop for decision 1
+          end
+        end # loop for decision 1
+        # at line 15:72: ( attribute )?
+        alt_2 = 2
+        look_2_0 = @input.peek( 1 )
+
+        if ( look_2_0 == ATTRIBUTE )
+          alt_2 = 1
+        end
+        case alt_2
+        when 1
+          # at line 15:72: attribute
+          @state.following.push( TOKENS_FOLLOWING_attribute_IN_database_fields_48 )
+          attribute
+          @state.following.pop
+
+        end
+
+        # --> action
+
+        	@attributes = [] unless @attributes
+        expr = @attributes - ["id", "created_at", "updated_at"]
+
+        # <-- action
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 1 )
+
+      end
+      
+      return expr
+    end
+
+
+    # 
+    # parser rule attributes
+    # 
+    # (in DatabaseFieldsParser.g)
+    # 22:1: attributes : attribute ',' ;
+    # 
+    def attributes
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 2 )
+
+      begin
+        # at line 22:13: attribute ','
+        @state.following.push( TOKENS_FOLLOWING_attribute_IN_attributes_60 )
+        attribute
+        @state.following.pop
+        match( T__13, TOKENS_FOLLOWING_T__13_IN_attributes_62 )
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 2 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule attribute
+    # 
+    # (in DatabaseFieldsParser.g)
+    # 25:1: attribute : a= ATTRIBUTE ;
+    # 
+    def attribute
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 3 )
+      a = nil
+
+      begin
+        # at line 26:4: a= ATTRIBUTE
+        a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_74 )
+        # --> action
+
+        		@attributes = [] unless @attributes
+        		@attributes << a.text
+        	
+        # <-- action
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 3 )
+
+      end
+      
+      return 
+    end
+
+
+
+    TOKENS_FOLLOWING_T__10_IN_database_fields_39 = Set[ 11 ]
+    TOKENS_FOLLOWING_T__11_IN_database_fields_41 = Set[ 12 ]
+    TOKENS_FOLLOWING_T__12_IN_database_fields_43 = Set[ 1, 4 ]
+    TOKENS_FOLLOWING_attributes_IN_database_fields_45 = Set[ 1, 4 ]
+    TOKENS_FOLLOWING_attribute_IN_database_fields_48 = Set[ 1 ]
+    TOKENS_FOLLOWING_attribute_IN_attributes_60 = Set[ 13 ]
+    TOKENS_FOLLOWING_T__13_IN_attributes_62 = Set[ 1 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_74 = Set[ 1 ]
+
+  end # class Parser < ANTLR3::Parser
+
+  at_exit { Parser.main( ARGV ) } if __FILE__ == $0
+end
+

data/lib/tripper/model_parsers/database_fields_parser/playing_around.rb

@@ -0,0 +1,14 @@
+require './DatabaseFieldsParserParser'
+require './DatabaseFieldsParserLexer'
+# input = ANTLR3::StringStream.new( "attr_accessible :hour, :minute, :second" )
+# lexer = DatabaseFieldsParser::Lexer.new(input)
+# tokens = ANTLR3::CommonTokenStream.new(lexer)
+parser = DatabaseFieldsParser::Parser.new("# database_fields: hour, minute, second")
+a= parser.database_fields
+puts a
+# input = ANTLR3::StringStream.new( "attr_accessible :tes, :bla, :blo" )
+# lexer = DatabaseFieldsParser::Lexer.new(input)
+# tokens = ANTLR3::CommonTokenStream.new(lexer)
+parser = DatabaseFieldsParser::Parser.new("# database_fields: tes, bla, blo")
+a= parser.database_fields
+puts a

data/lib/tripper/model_parsers/has_and_belongs_to_many/HasAndBelongsToManyParser.g

@@ -0,0 +1,92 @@
+grammar HasAndBelongsToManyParser;
+
+options {
+	language = Ruby;
+	}
+
+@header {
+	def strip_quotes str
+		return str[1,(str.length)-2]
+	end
+
+	@@attribute = nil
+	@@class_name = nil
+	@@foreign_key = nil
+	@@association_foreign_key = nil
+}
+
+@members {
+attr_accessor :attribute, :class_name, :foreign_key, :association_foreign_key
+}
+
+comment: COMMENT;
+
+has_and_belongs_to_many returns [expr]:	((c=COMMENT)* | 'has_and_belongs_to_many' attribute class_name? foreign_key? association_foreign_key? comment?)
+	{
+		$expr = {attribute: @attribute, class_name: @class_name, foreign_key: @foreign_key, association_foreign_key: @association_foreign_key} unless $c
+	}
+;
+
+class_name:	',' (class_name_old_syntax | class_name_new_syntax);
+
+class_name_old_syntax: ':' 'class_name' '=>' class_name_word
+;
+
+class_name_word:	(('\'' a=ATTRIBUTE '\'') | ('"' a=ATTRIBUTE '"') | (':' a=ATTRIBUTE))
+	{
+		@class_name = $a.text
+	}
+;
+
+class_name_new_syntax: 'class_name' ':' class_name_word;
+
+foreign_key: ',' (foreign_key_old_syntax | foreign_key_new_syntax);
+
+foreign_key_old_syntax: ':' 'foreign_key' '=>' foreign_key_word
+;
+
+foreign_key_word:	(('\'' a=ATTRIBUTE '\'') | ('"' a=ATTRIBUTE '"') | (':' a=ATTRIBUTE))
+	{
+		@foreign_key = $a.text
+	}
+;
+
+foreign_key_new_syntax: 'foreign_key' ':' foreign_key_word;
+
+
+association_foreign_key: ',' (association_foreign_key_old_syntax | association_foreign_key_new_syntax);
+
+association_foreign_key_old_syntax: ':' 'association_foreign_key' '=>' association_foreign_key_word
+;
+
+association_foreign_key_word:	(('\'' a=ATTRIBUTE '\'') | ('"' a=ATTRIBUTE '"') | (':' a=ATTRIBUTE))
+	{
+		@association_foreign_key = $a.text
+	}
+;
+
+association_foreign_key_new_syntax: 'association_foreign_key' ':' foreign_key_word;
+
+
+attribute: ('\'' a=ATTRIBUTE '\'') | ('"' a=ATTRIBUTE '"') | (':' a=ATTRIBUTE)
+	{
+		@attribute = $a.text
+	}
+;
+
+//string: STRING;
+
+/*------------------------------------------------------------------
+ * LEXER RULES
+ *------------------------------------------------------------------*/
+//LITERAL: (HC|LC)(HC|LC|'_')*;
+ATTRIBUTE: (HC|LC)(HC|LC|DIGIT|'_')*;
+//LITERAL: (HC|LC)(HC|LC|DIGIT|'_'|'-')*;
+//NUMERICCONSTANT: ('-')? DIGIT+ ('.' DIGIT+)?;
+//STRING: '\'' ACTUALSTRING '\'';
+WHITESPACE: ( '\t' | ' ' | '\r' | '\n'| '\u000C' )+ { $channel = HIDDEN; };
+COMMENT: '#' ~('\n'|'\r')*;
+fragment ACTUALSTRING: ~('\\'|'\'')*;
+fragment DIGIT: '0'..'9';
+fragment HC: 'A'..'Z';
+fragment LC: 'a'..'z';

data/lib/tripper/model_parsers/has_and_belongs_to_many/HasAndBelongsToManyParser.tokens

@@ -0,0 +1,25 @@
+ACTUALSTRING=10
+T__19=19
+T__16=16
+HC=6
+T__15=15
+T__18=18
+T__17=17
+T__12=12
+T__11=11
+T__14=14
+T__13=13
+ATTRIBUTE=5
+WHITESPACE=9
+LC=7
+DIGIT=8
+COMMENT=4
+'association_foreign_key'=19
+'"'=17
+':'=13
+'has_and_belongs_to_many'=11
+','=12
+'=>'=15
+'foreign_key'=18
+'class_name'=14
+'\''=16

data/lib/tripper/model_parsers/has_and_belongs_to_many/HasAndBelongsToManyParserLexer.rb

@@ -0,0 +1,787 @@
+#!/usr/bin/env ruby
+#
+# HasAndBelongsToManyParser.g
+# --
+# Generated using ANTLR version: 3.2.1-SNAPSHOT Jul 31, 2010 19:34:52
+# Ruby runtime library version: 1.8.11
+# Input grammar file: HasAndBelongsToManyParser.g
+# Generated at: 2013-07-28 14:32:01
+# 
+
+# ~~~> start load path setup
+this_directory = File.expand_path( File.dirname( __FILE__ ) )
+$LOAD_PATH.unshift( this_directory ) unless $LOAD_PATH.include?( this_directory )
+
+antlr_load_failed = proc do
+  load_path = $LOAD_PATH.map { |dir| '  - ' << dir }.join( $/ )
+  raise LoadError, <<-END.strip!
+  
+Failed to load the ANTLR3 runtime library (version 1.8.11):
+
+Ensure the library has been installed on your system and is available
+on the load path. If rubygems is available on your system, this can
+be done with the command:
+  
+  gem install antlr3
+
+Current load path:
+#{ load_path }
+
+  END
+end
+
+defined?( ANTLR3 ) or begin
+  
+  # 1: try to load the ruby antlr3 runtime library from the system path
+  require 'antlr3'
+  
+rescue LoadError
+  
+  # 2: try to load rubygems if it isn't already loaded
+  defined?( Gem ) or begin
+    require 'rubygems'
+  rescue LoadError
+    antlr_load_failed.call
+  end
+  
+  # 3: try to activate the antlr3 gem
+  begin
+    Gem.activate( 'antlr3', '~> 1.8.11' )
+  rescue Gem::LoadError
+    antlr_load_failed.call
+  end
+  
+  require 'antlr3'
+  
+end
+# <~~~ end load path setup
+
+
+module HasAndBelongsToManyParser
+  # TokenData defines all of the token type integer values
+  # as constants, which will be included in all 
+  # ANTLR-generated recognizers.
+  const_defined?( :TokenData ) or TokenData = ANTLR3::TokenScheme.new
+
+  module TokenData
+
+    # define the token constants
+    define_tokens( :ACTUALSTRING => 10, :T__19 => 19, :T__16 => 16, :T__15 => 15, 
+                   :HC => 6, :T__18 => 18, :T__17 => 17, :T__12 => 12, :T__11 => 11, 
+                   :T__14 => 14, :T__13 => 13, :ATTRIBUTE => 5, :LC => 7, 
+                   :WHITESPACE => 9, :DIGIT => 8, :COMMENT => 4, :EOF => -1 )
+    
+  end
+
+
+  class Lexer < ANTLR3::Lexer
+    @grammar_home = HasAndBelongsToManyParser
+    include TokenData
+
+    
+    begin
+      generated_using( "HasAndBelongsToManyParser.g", "3.2.1-SNAPSHOT Jul 31, 2010 19:34:52", "1.8.11" )
+    rescue NoMethodError => error
+      # ignore
+    end
+    
+    RULE_NAMES   = [ "T__11", "T__12", "T__13", "T__14", "T__15", "T__16", 
+                     "T__17", "T__18", "T__19", "ATTRIBUTE", "WHITESPACE", 
+                     "COMMENT", "ACTUALSTRING", "DIGIT", "HC", "LC" ].freeze
+    RULE_METHODS = [ :t__11!, :t__12!, :t__13!, :t__14!, :t__15!, :t__16!, 
+                     :t__17!, :t__18!, :t__19!, :attribute!, :whitespace!, 
+                     :comment!, :actualstring!, :digit!, :hc!, :lc! ].freeze
+
+    
+    def initialize( input=nil, options = {} )
+      super( input, options )
+
+    end
+    
+    
+    # - - - - - - - - - - - lexer rules - - - - - - - - - - - -
+    # lexer rule t__11! (T__11)
+    # (in HasAndBelongsToManyParser.g)
+    def t__11!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 1 )
+
+      type = T__11
+      channel = ANTLR3::DEFAULT_CHANNEL
+
+      
+      # - - - - main rule block - - - -
+      # at line 7:9: 'has_and_belongs_to_many'
+      match( "has_and_belongs_to_many" )
+
+      
+      @state.type = type
+      @state.channel = channel
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 1 )
+
+    end
+
+    # lexer rule t__12! (T__12)
+    # (in HasAndBelongsToManyParser.g)
+    def t__12!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 2 )
+
+      type = T__12
+      channel = ANTLR3::DEFAULT_CHANNEL
+
+      
+      # - - - - main rule block - - - -
+      # at line 8:9: ','
+      match( 0x2c )
+
+      
+      @state.type = type
+      @state.channel = channel
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 2 )
+
+    end
+
+    # lexer rule t__13! (T__13)
+    # (in HasAndBelongsToManyParser.g)
+    def t__13!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 3 )
+
+      type = T__13
+      channel = ANTLR3::DEFAULT_CHANNEL
+
+      
+      # - - - - main rule block - - - -
+      # at line 9:9: ':'
+      match( 0x3a )
+
+      
+      @state.type = type
+      @state.channel = channel
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 3 )
+
+    end
+
+    # lexer rule t__14! (T__14)
+    # (in HasAndBelongsToManyParser.g)
+    def t__14!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 4 )
+
+      type = T__14
+      channel = ANTLR3::DEFAULT_CHANNEL
+
+      
+      # - - - - main rule block - - - -
+      # at line 10:9: 'class_name'
+      match( "class_name" )
+
+      
+      @state.type = type
+      @state.channel = channel
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 4 )
+
+    end
+
+    # lexer rule t__15! (T__15)
+    # (in HasAndBelongsToManyParser.g)
+    def t__15!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 5 )
+
+      type = T__15
+      channel = ANTLR3::DEFAULT_CHANNEL
+
+      
+      # - - - - main rule block - - - -
+      # at line 11:9: '=>'
+      match( "=>" )
+
+      
+      @state.type = type
+      @state.channel = channel
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 5 )
+
+    end
+
+    # lexer rule t__16! (T__16)
+    # (in HasAndBelongsToManyParser.g)
+    def t__16!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 6 )
+
+      type = T__16
+      channel = ANTLR3::DEFAULT_CHANNEL
+
+      
+      # - - - - main rule block - - - -
+      # at line 12:9: '\\''
+      match( 0x27 )
+
+      
+      @state.type = type
+      @state.channel = channel
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 6 )
+
+    end
+
+    # lexer rule t__17! (T__17)
+    # (in HasAndBelongsToManyParser.g)
+    def t__17!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 7 )
+
+      type = T__17
+      channel = ANTLR3::DEFAULT_CHANNEL
+
+      
+      # - - - - main rule block - - - -
+      # at line 13:9: '\"'
+      match( 0x22 )
+
+      
+      @state.type = type
+      @state.channel = channel
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 7 )
+
+    end
+
+    # lexer rule t__18! (T__18)
+    # (in HasAndBelongsToManyParser.g)
+    def t__18!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 8 )
+
+      type = T__18
+      channel = ANTLR3::DEFAULT_CHANNEL
+
+      
+      # - - - - main rule block - - - -
+      # at line 14:9: 'foreign_key'
+      match( "foreign_key" )
+
+      
+      @state.type = type
+      @state.channel = channel
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 8 )
+
+    end
+
+    # lexer rule t__19! (T__19)
+    # (in HasAndBelongsToManyParser.g)
+    def t__19!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 9 )
+
+      type = T__19
+      channel = ANTLR3::DEFAULT_CHANNEL
+
+      
+      # - - - - main rule block - - - -
+      # at line 15:9: 'association_foreign_key'
+      match( "association_foreign_key" )
+
+      
+      @state.type = type
+      @state.channel = channel
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 9 )
+
+    end
+
+    # lexer rule attribute! (ATTRIBUTE)
+    # (in HasAndBelongsToManyParser.g)
+    def attribute!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 10 )
+
+      type = ATTRIBUTE
+      channel = ANTLR3::DEFAULT_CHANNEL
+
+      
+      # - - - - main rule block - - - -
+      # at line 83:12: ( HC | LC ) ( HC | LC | DIGIT | '_' )*
+      if @input.peek( 1 ).between?( 0x41, 0x5a ) || @input.peek( 1 ).between?( 0x61, 0x7a )
+        @input.consume
+      else
+        mse = MismatchedSet( nil )
+        recover mse
+        raise mse
+      end
+
+
+      # at line 83:19: ( HC | LC | DIGIT | '_' )*
+      while true # decision 1
+        alt_1 = 2
+        look_1_0 = @input.peek( 1 )
+
+        if ( look_1_0.between?( 0x30, 0x39 ) || look_1_0.between?( 0x41, 0x5a ) || look_1_0 == 0x5f || look_1_0.between?( 0x61, 0x7a ) )
+          alt_1 = 1
+
+        end
+        case alt_1
+        when 1
+          # at line 
+          if @input.peek( 1 ).between?( 0x30, 0x39 ) || @input.peek( 1 ).between?( 0x41, 0x5a ) || @input.peek(1) == 0x5f || @input.peek( 1 ).between?( 0x61, 0x7a )
+            @input.consume
+          else
+            mse = MismatchedSet( nil )
+            recover mse
+            raise mse
+          end
+
+
+
+        else
+          break # out of loop for decision 1
+        end
+      end # loop for decision 1
+
+      
+      @state.type = type
+      @state.channel = channel
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 10 )
+
+    end
+
+    # lexer rule whitespace! (WHITESPACE)
+    # (in HasAndBelongsToManyParser.g)
+    def whitespace!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 11 )
+
+      type = WHITESPACE
+      channel = ANTLR3::DEFAULT_CHANNEL
+
+      
+      # - - - - main rule block - - - -
+      # at line 87:13: ( '\\t' | ' ' | '\\r' | '\\n' | '\\u000C' )+
+      # at file 87:13: ( '\\t' | ' ' | '\\r' | '\\n' | '\\u000C' )+
+      match_count_2 = 0
+      while true
+        alt_2 = 2
+        look_2_0 = @input.peek( 1 )
+
+        if ( look_2_0.between?( 0x9, 0xa ) || look_2_0.between?( 0xc, 0xd ) || look_2_0 == 0x20 )
+          alt_2 = 1
+
+        end
+        case alt_2
+        when 1
+          # at line 
+          if @input.peek( 1 ).between?( 0x9, 0xa ) || @input.peek( 1 ).between?( 0xc, 0xd ) || @input.peek(1) == 0x20
+            @input.consume
+          else
+            mse = MismatchedSet( nil )
+            recover mse
+            raise mse
+          end
+
+
+
+        else
+          match_count_2 > 0 and break
+          eee = EarlyExit(2)
+
+
+          raise eee
+        end
+        match_count_2 += 1
+      end
+
+      # --> action
+       channel = HIDDEN; 
+      # <-- action
+
+      
+      @state.type = type
+      @state.channel = channel
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 11 )
+
+    end
+
+    # lexer rule comment! (COMMENT)
+    # (in HasAndBelongsToManyParser.g)
+    def comment!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 12 )
+
+      type = COMMENT
+      channel = ANTLR3::DEFAULT_CHANNEL
+
+      
+      # - - - - main rule block - - - -
+      # at line 88:10: '#' (~ ( '\\n' | '\\r' ) )*
+      match( 0x23 )
+      # at line 88:14: (~ ( '\\n' | '\\r' ) )*
+      while true # decision 3
+        alt_3 = 2
+        look_3_0 = @input.peek( 1 )
+
+        if ( look_3_0.between?( 0x0, 0x9 ) || look_3_0.between?( 0xb, 0xc ) || look_3_0.between?( 0xe, 0xffff ) )
+          alt_3 = 1
+
+        end
+        case alt_3
+        when 1
+          # at line 88:14: ~ ( '\\n' | '\\r' )
+          if @input.peek( 1 ).between?( 0x0, 0x9 ) || @input.peek( 1 ).between?( 0xb, 0xc ) || @input.peek( 1 ).between?( 0xe, 0xff )
+            @input.consume
+          else
+            mse = MismatchedSet( nil )
+            recover mse
+            raise mse
+          end
+
+
+
+        else
+          break # out of loop for decision 3
+        end
+      end # loop for decision 3
+
+      
+      @state.type = type
+      @state.channel = channel
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 12 )
+
+    end
+
+    # lexer rule actualstring! (ACTUALSTRING)
+    # (in HasAndBelongsToManyParser.g)
+    def actualstring!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 13 )
+
+      
+      # - - - - main rule block - - - -
+      # at line 89:24: (~ ( '\\\\' | '\\'' ) )*
+      # at line 89:24: (~ ( '\\\\' | '\\'' ) )*
+      while true # decision 4
+        alt_4 = 2
+        look_4_0 = @input.peek( 1 )
+
+        if ( look_4_0.between?( 0x0, 0x26 ) || look_4_0.between?( 0x28, 0x5b ) || look_4_0.between?( 0x5d, 0xffff ) )
+          alt_4 = 1
+
+        end
+        case alt_4
+        when 1
+          # at line 89:24: ~ ( '\\\\' | '\\'' )
+          if @input.peek( 1 ).between?( 0x0, 0x26 ) || @input.peek( 1 ).between?( 0x28, 0x5b ) || @input.peek( 1 ).between?( 0x5d, 0xff )
+            @input.consume
+          else
+            mse = MismatchedSet( nil )
+            recover mse
+            raise mse
+          end
+
+
+
+        else
+          break # out of loop for decision 4
+        end
+      end # loop for decision 4
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 13 )
+
+    end
+
+    # lexer rule digit! (DIGIT)
+    # (in HasAndBelongsToManyParser.g)
+    def digit!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 14 )
+
+      
+      # - - - - main rule block - - - -
+      # at line 90:17: '0' .. '9'
+      match_range( 0x30, 0x39 )
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 14 )
+
+    end
+
+    # lexer rule hc! (HC)
+    # (in HasAndBelongsToManyParser.g)
+    def hc!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 15 )
+
+      
+      # - - - - main rule block - - - -
+      # at line 91:14: 'A' .. 'Z'
+      match_range( 0x41, 0x5a )
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 15 )
+
+    end
+
+    # lexer rule lc! (LC)
+    # (in HasAndBelongsToManyParser.g)
+    def lc!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 16 )
+
+      
+      # - - - - main rule block - - - -
+      # at line 92:14: 'a' .. 'z'
+      match_range( 0x61, 0x7a )
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 16 )
+
+    end
+
+    # main rule used to study the input at the current position,
+    # and choose the proper lexer rule to call in order to
+    # fetch the next token
+    # 
+    # usually, you don't make direct calls to this method,
+    # but instead use the next_token method, which will
+    # build and emit the actual next token
+    def token!
+      # at line 1:8: ( T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | ATTRIBUTE | WHITESPACE | COMMENT )
+      alt_5 = 12
+      alt_5 = @dfa5.predict( @input )
+      case alt_5
+      when 1
+        # at line 1:10: T__11
+        t__11!
+
+      when 2
+        # at line 1:16: T__12
+        t__12!
+
+      when 3
+        # at line 1:22: T__13
+        t__13!
+
+      when 4
+        # at line 1:28: T__14
+        t__14!
+
+      when 5
+        # at line 1:34: T__15
+        t__15!
+
+      when 6
+        # at line 1:40: T__16
+        t__16!
+
+      when 7
+        # at line 1:46: T__17
+        t__17!
+
+      when 8
+        # at line 1:52: T__18
+        t__18!
+
+      when 9
+        # at line 1:58: T__19
+        t__19!
+
+      when 10
+        # at line 1:64: ATTRIBUTE
+        attribute!
+
+      when 11
+        # at line 1:74: WHITESPACE
+        whitespace!
+
+      when 12
+        # at line 1:85: COMMENT
+        comment!
+
+      end
+    end
+
+    
+    # - - - - - - - - - - DFA definitions - - - - - - - - - - -
+    class DFA5 < ANTLR3::DFA
+      EOT = unpack( 1, -1, 1, 10, 2, -1, 1, 10, 3, -1, 2, 10, 3, -1, 33, 
+                    10, 1, 50, 3, 10, 1, -1, 1, 54, 2, 10, 1, -1, 21, 10, 
+                    1, 78, 1, 79, 2, -1 )
+      EOF = unpack( 80, -1 )
+      MIN = unpack( 1, 9, 1, 97, 2, -1, 1, 108, 3, -1, 1, 111, 1, 115, 3, 
+                    -1, 1, 115, 1, 97, 1, 114, 1, 115, 1, 95, 1, 115, 1, 
+                    101, 1, 111, 1, 97, 1, 115, 1, 105, 1, 99, 1, 110, 1, 
+                    95, 1, 103, 1, 105, 1, 100, 2, 110, 1, 97, 1, 95, 1, 
+                    97, 1, 95, 1, 116, 1, 98, 1, 109, 1, 107, 1, 105, 3, 
+                    101, 1, 111, 1, 108, 1, 48, 1, 121, 1, 110, 1, 111, 
+                    1, -1, 1, 48, 1, 95, 1, 110, 1, -1, 1, 102, 1, 103, 
+                    1, 111, 1, 115, 1, 114, 1, 95, 1, 101, 1, 116, 1, 105, 
+                    1, 111, 1, 103, 1, 95, 1, 110, 1, 109, 1, 95, 1, 97, 
+                    1, 107, 1, 110, 1, 101, 2, 121, 2, 48, 2, -1 )
+      MAX = unpack( 1, 122, 1, 97, 2, -1, 1, 108, 3, -1, 1, 111, 1, 115, 
+                    3, -1, 1, 115, 1, 97, 1, 114, 1, 115, 1, 95, 1, 115, 
+                    1, 101, 1, 111, 1, 97, 1, 115, 1, 105, 1, 99, 1, 110, 
+                    1, 95, 1, 103, 1, 105, 1, 100, 2, 110, 1, 97, 1, 95, 
+                    1, 97, 1, 95, 1, 116, 1, 98, 1, 109, 1, 107, 1, 105, 
+                    3, 101, 1, 111, 1, 108, 1, 122, 1, 121, 1, 110, 1, 111, 
+                    1, -1, 1, 122, 1, 95, 1, 110, 1, -1, 1, 102, 1, 103, 
+                    1, 111, 1, 115, 1, 114, 1, 95, 1, 101, 1, 116, 1, 105, 
+                    1, 111, 1, 103, 1, 95, 1, 110, 1, 109, 1, 95, 1, 97, 
+                    1, 107, 1, 110, 1, 101, 2, 121, 2, 122, 2, -1 )
+      ACCEPT = unpack( 2, -1, 1, 2, 1, 3, 1, -1, 1, 5, 1, 6, 1, 7, 2, -1, 
+                       1, 10, 1, 11, 1, 12, 37, -1, 1, 4, 3, -1, 1, 8, 23, 
+                       -1, 1, 1, 1, 9 )
+      SPECIAL = unpack( 80, -1 )
+      TRANSITION = [
+        unpack( 2, 11, 1, -1, 2, 11, 18, -1, 1, 11, 1, -1, 1, 7, 1, 12, 
+                3, -1, 1, 6, 4, -1, 1, 2, 13, -1, 1, 3, 2, -1, 1, 5, 3, 
+                -1, 26, 10, 6, -1, 1, 9, 1, 10, 1, 4, 2, 10, 1, 8, 1, 10, 
+                1, 1, 18, 10 ),
+        unpack( 1, 13 ),
+        unpack(  ),
+        unpack(  ),
+        unpack( 1, 14 ),
+        unpack(  ),
+        unpack(  ),
+        unpack(  ),
+        unpack( 1, 15 ),
+        unpack( 1, 16 ),
+        unpack(  ),
+        unpack(  ),
+        unpack(  ),
+        unpack( 1, 17 ),
+        unpack( 1, 18 ),
+        unpack( 1, 19 ),
+        unpack( 1, 20 ),
+        unpack( 1, 21 ),
+        unpack( 1, 22 ),
+        unpack( 1, 23 ),
+        unpack( 1, 24 ),
+        unpack( 1, 25 ),
+        unpack( 1, 26 ),
+        unpack( 1, 27 ),
+        unpack( 1, 28 ),
+        unpack( 1, 29 ),
+        unpack( 1, 30 ),
+        unpack( 1, 31 ),
+        unpack( 1, 32 ),
+        unpack( 1, 33 ),
+        unpack( 1, 34 ),
+        unpack( 1, 35 ),
+        unpack( 1, 36 ),
+        unpack( 1, 37 ),
+        unpack( 1, 38 ),
+        unpack( 1, 39 ),
+        unpack( 1, 40 ),
+        unpack( 1, 41 ),
+        unpack( 1, 42 ),
+        unpack( 1, 43 ),
+        unpack( 1, 44 ),
+        unpack( 1, 45 ),
+        unpack( 1, 46 ),
+        unpack( 1, 47 ),
+        unpack( 1, 48 ),
+        unpack( 1, 49 ),
+        unpack( 10, 10, 7, -1, 26, 10, 4, -1, 1, 10, 1, -1, 26, 10 ),
+        unpack( 1, 51 ),
+        unpack( 1, 52 ),
+        unpack( 1, 53 ),
+        unpack(  ),
+        unpack( 10, 10, 7, -1, 26, 10, 4, -1, 1, 10, 1, -1, 26, 10 ),
+        unpack( 1, 55 ),
+        unpack( 1, 56 ),
+        unpack(  ),
+        unpack( 1, 57 ),
+        unpack( 1, 58 ),
+        unpack( 1, 59 ),
+        unpack( 1, 60 ),
+        unpack( 1, 61 ),
+        unpack( 1, 62 ),
+        unpack( 1, 63 ),
+        unpack( 1, 64 ),
+        unpack( 1, 65 ),
+        unpack( 1, 66 ),
+        unpack( 1, 67 ),
+        unpack( 1, 68 ),
+        unpack( 1, 69 ),
+        unpack( 1, 70 ),
+        unpack( 1, 71 ),
+        unpack( 1, 72 ),
+        unpack( 1, 73 ),
+        unpack( 1, 74 ),
+        unpack( 1, 75 ),
+        unpack( 1, 76 ),
+        unpack( 1, 77 ),
+        unpack( 10, 10, 7, -1, 26, 10, 4, -1, 1, 10, 1, -1, 26, 10 ),
+        unpack( 10, 10, 7, -1, 26, 10, 4, -1, 1, 10, 1, -1, 26, 10 ),
+        unpack(  ),
+        unpack(  )
+      ].freeze
+      
+      ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
+        if a > 0 and z < 0
+          MAX[ i ] %= 0x10000
+        end
+      end
+      
+      @decision = 5
+      
+
+      def description
+        <<-'__dfa_description__'.strip!
+          1:1: Tokens : ( T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | ATTRIBUTE | WHITESPACE | COMMENT );
+        __dfa_description__
+      end
+    end
+
+    
+    private
+    
+    def initialize_dfas
+      super rescue nil
+      @dfa5 = DFA5.new( self, 5 )
+
+    end
+  end # class Lexer < ANTLR3::Lexer
+
+  at_exit { Lexer.main( ARGV ) } if __FILE__ == $0
+end
+