tripper 0.0.3d

data/lib/tripper/model_parsers/validates/ValidatesParserParser.rb

@@ -0,0 +1,869 @@
+#!/usr/bin/env ruby
+#
+# /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/validates/ValidatesParser.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: /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/validates/ValidatesParser.g
+# Generated at: 2013-05-05 11:33:11
+# 
+
+# ~~~> 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 - - - - - -
+# /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/validates/ValidatesParser.g
+
+
+	def strip_quotes str
+		return str[1,(str.length)-2]
+	end
+
+# - - - - - - end action @parser::header - - - - - - -
+
+
+module ValidatesParser
+  # 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( :T__24 => 24, :T__23 => 23, :T__22 => 22, :T__21 => 21, 
+                   :T__20 => 20, :ATTRIBUTE => 5, :WHITESPACE => 9, :EOF => -1, 
+                   :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, :LC => 7, :DIGIT => 8, 
+                   :COMMENT => 4 )
+
+    # 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( "COMMENT", "ATTRIBUTE", "HC", "LC", "DIGIT", "WHITESPACE", 
+                    "ACTUALSTRING", "'validates'", "','", "':'", "'uniqueness'", 
+                    "'presence'", "'=>'", "'true'", "'{'", "'}'", "'scope'", 
+                    "'['", "']'", "'\\''", "'\"'" )
+    
+  end
+
+
+  class Parser < ANTLR3::Parser
+    @grammar_home = ValidatesParser
+
+    RULE_METHODS = [ :comment, :validates, :validation_helper, :validation_helper_old_syntax, 
+                     :validation_helper_new_syntax, :ruby_scope, :scope_old_syntax, 
+                     :scope_new_syntax, :list, :attribute, :list_attribute ].freeze
+
+
+    include TokenData
+
+    begin
+      generated_using( "/Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/validates/ValidatesParser.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 :attribute, :list, :type
+
+    # - - - - - - - - - - - - Rules - - - - - - - - - - - - -
+
+    # 
+    # parser rule comment
+    # 
+    # (in /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/validates/ValidatesParser.g)
+    # 17:1: comment : COMMENT ;
+    # 
+    def comment
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 1 )
+
+      begin
+        # at line 17:10: COMMENT
+        match( COMMENT, TOKENS_FOLLOWING_COMMENT_IN_comment_35 )
+
+      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 
+    end
+
+
+    # 
+    # parser rule validates
+    # 
+    # (in /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/validates/ValidatesParser.g)
+    # 19:1: validates returns [expr] : ( (c= COMMENT )* | 'validates' attribute validation_helper ( comment )? ) ;
+    # 
+    def validates
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 2 )
+      expr = nil
+      c = nil
+
+      begin
+        # at line 19:27: ( (c= COMMENT )* | 'validates' attribute validation_helper ( comment )? )
+        # at line 19:27: ( (c= COMMENT )* | 'validates' attribute validation_helper ( comment )? )
+        alt_3 = 2
+        look_3_0 = @input.peek( 1 )
+
+        if ( look_3_0 == EOF || look_3_0 == COMMENT )
+          alt_3 = 1
+        elsif ( look_3_0 == T__11 )
+          alt_3 = 2
+        else
+          raise NoViableAlternative( "", 3, 0 )
+        end
+        case alt_3
+        when 1
+          # at line 19:28: (c= COMMENT )*
+          # at line 19:28: (c= COMMENT )*
+          while true # decision 1
+            alt_1 = 2
+            look_1_0 = @input.peek( 1 )
+
+            if ( look_1_0 == COMMENT )
+              alt_1 = 1
+
+            end
+            case alt_1
+            when 1
+              # at line 19:29: c= COMMENT
+              c = match( COMMENT, TOKENS_FOLLOWING_COMMENT_IN_validates_50 )
+
+            else
+              break # out of loop for decision 1
+            end
+          end # loop for decision 1
+
+        when 2
+          # at line 19:43: 'validates' attribute validation_helper ( comment )?
+          match( T__11, TOKENS_FOLLOWING_T__11_IN_validates_56 )
+          @state.following.push( TOKENS_FOLLOWING_attribute_IN_validates_58 )
+          attribute
+          @state.following.pop
+          @state.following.push( TOKENS_FOLLOWING_validation_helper_IN_validates_60 )
+          validation_helper
+          @state.following.pop
+          # at line 19:83: ( comment )?
+          alt_2 = 2
+          look_2_0 = @input.peek( 1 )
+
+          if ( look_2_0 == COMMENT )
+            alt_2 = 1
+          end
+          case alt_2
+          when 1
+            # at line 19:83: comment
+            @state.following.push( TOKENS_FOLLOWING_comment_IN_validates_62 )
+            comment
+            @state.following.pop
+
+          end
+
+        end
+        # --> action
+
+        		@list = [] unless @list
+        		expr = {type: @type, attribute: @attribute, on: @list} unless c
+        	
+        # <-- action
+
+      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 expr
+    end
+
+
+    # 
+    # parser rule validation_helper
+    # 
+    # (in /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/validates/ValidatesParser.g)
+    # 26:1: validation_helper : ',' ( validation_helper_old_syntax | validation_helper_new_syntax ) ;
+    # 
+    def validation_helper
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 3 )
+
+      begin
+        # at line 26:20: ',' ( validation_helper_old_syntax | validation_helper_new_syntax )
+        match( T__12, TOKENS_FOLLOWING_T__12_IN_validation_helper_75 )
+        # at line 26:24: ( validation_helper_old_syntax | validation_helper_new_syntax )
+        alt_4 = 2
+        look_4_0 = @input.peek( 1 )
+
+        if ( look_4_0 == T__13 )
+          alt_4 = 1
+        elsif ( look_4_0.between?( T__14, T__15 ) )
+          alt_4 = 2
+        else
+          raise NoViableAlternative( "", 4, 0 )
+        end
+        case alt_4
+        when 1
+          # at line 26:25: validation_helper_old_syntax
+          @state.following.push( TOKENS_FOLLOWING_validation_helper_old_syntax_IN_validation_helper_78 )
+          validation_helper_old_syntax
+          @state.following.pop
+
+        when 2
+          # at line 26:56: validation_helper_new_syntax
+          @state.following.push( TOKENS_FOLLOWING_validation_helper_new_syntax_IN_validation_helper_82 )
+          validation_helper_new_syntax
+          @state.following.pop
+
+        end
+
+      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
+
+
+    # 
+    # parser rule validation_helper_old_syntax
+    # 
+    # (in /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/validates/ValidatesParser.g)
+    # 28:1: validation_helper_old_syntax : ':' (a= 'uniqueness' | a= 'presence' ) '=>' ( 'true' | ruby_scope ) ;
+    # 
+    def validation_helper_old_syntax
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 4 )
+      a = nil
+
+      begin
+        # at line 28:31: ':' (a= 'uniqueness' | a= 'presence' ) '=>' ( 'true' | ruby_scope )
+        match( T__13, TOKENS_FOLLOWING_T__13_IN_validation_helper_old_syntax_90 )
+        # at line 28:35: (a= 'uniqueness' | a= 'presence' )
+        alt_5 = 2
+        look_5_0 = @input.peek( 1 )
+
+        if ( look_5_0 == T__14 )
+          alt_5 = 1
+        elsif ( look_5_0 == T__15 )
+          alt_5 = 2
+        else
+          raise NoViableAlternative( "", 5, 0 )
+        end
+        case alt_5
+        when 1
+          # at line 28:36: a= 'uniqueness'
+          a = match( T__14, TOKENS_FOLLOWING_T__14_IN_validation_helper_old_syntax_95 )
+
+        when 2
+          # at line 28:53: a= 'presence'
+          a = match( T__15, TOKENS_FOLLOWING_T__15_IN_validation_helper_old_syntax_101 )
+
+        end
+        match( T__16, TOKENS_FOLLOWING_T__16_IN_validation_helper_old_syntax_104 )
+        # at line 28:72: ( 'true' | ruby_scope )
+        alt_6 = 2
+        look_6_0 = @input.peek( 1 )
+
+        if ( look_6_0 == T__17 )
+          alt_6 = 1
+        elsif ( look_6_0 == T__18 )
+          alt_6 = 2
+        else
+          raise NoViableAlternative( "", 6, 0 )
+        end
+        case alt_6
+        when 1
+          # at line 28:73: 'true'
+          match( T__17, TOKENS_FOLLOWING_T__17_IN_validation_helper_old_syntax_107 )
+
+        when 2
+          # at line 28:82: ruby_scope
+          @state.following.push( TOKENS_FOLLOWING_ruby_scope_IN_validation_helper_old_syntax_111 )
+          ruby_scope
+          @state.following.pop
+
+        end
+        # --> action
+        @type = 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__, 4 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule validation_helper_new_syntax
+    # 
+    # (in /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/validates/ValidatesParser.g)
+    # 30:1: validation_helper_new_syntax : (a= 'uniqueness' | a= 'presence' ) ':' ( 'true' | ruby_scope ) ;
+    # 
+    def validation_helper_new_syntax
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 5 )
+      a = nil
+
+      begin
+        # at line 30:31: (a= 'uniqueness' | a= 'presence' ) ':' ( 'true' | ruby_scope )
+        # at line 30:31: (a= 'uniqueness' | a= 'presence' )
+        alt_7 = 2
+        look_7_0 = @input.peek( 1 )
+
+        if ( look_7_0 == T__14 )
+          alt_7 = 1
+        elsif ( look_7_0 == T__15 )
+          alt_7 = 2
+        else
+          raise NoViableAlternative( "", 7, 0 )
+        end
+        case alt_7
+        when 1
+          # at line 30:32: a= 'uniqueness'
+          a = match( T__14, TOKENS_FOLLOWING_T__14_IN_validation_helper_new_syntax_124 )
+
+        when 2
+          # at line 30:49: a= 'presence'
+          a = match( T__15, TOKENS_FOLLOWING_T__15_IN_validation_helper_new_syntax_130 )
+
+        end
+        match( T__13, TOKENS_FOLLOWING_T__13_IN_validation_helper_new_syntax_133 )
+        # at line 30:67: ( 'true' | ruby_scope )
+        alt_8 = 2
+        look_8_0 = @input.peek( 1 )
+
+        if ( look_8_0 == T__17 )
+          alt_8 = 1
+        elsif ( look_8_0 == T__18 )
+          alt_8 = 2
+        else
+          raise NoViableAlternative( "", 8, 0 )
+        end
+        case alt_8
+        when 1
+          # at line 30:68: 'true'
+          match( T__17, TOKENS_FOLLOWING_T__17_IN_validation_helper_new_syntax_136 )
+
+        when 2
+          # at line 30:77: ruby_scope
+          @state.following.push( TOKENS_FOLLOWING_ruby_scope_IN_validation_helper_new_syntax_140 )
+          ruby_scope
+          @state.following.pop
+
+        end
+        # --> action
+        @type = 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__, 5 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule ruby_scope
+    # 
+    # (in /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/validates/ValidatesParser.g)
+    # 32:1: ruby_scope : '{' ( scope_old_syntax | scope_new_syntax ) '}' ;
+    # 
+    def ruby_scope
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 6 )
+
+      begin
+        # at line 32:13: '{' ( scope_old_syntax | scope_new_syntax ) '}'
+        match( T__18, TOKENS_FOLLOWING_T__18_IN_ruby_scope_150 )
+        # at line 32:17: ( scope_old_syntax | scope_new_syntax )
+        alt_9 = 2
+        look_9_0 = @input.peek( 1 )
+
+        if ( look_9_0 == T__13 )
+          alt_9 = 1
+        elsif ( look_9_0 == T__20 )
+          alt_9 = 2
+        else
+          raise NoViableAlternative( "", 9, 0 )
+        end
+        case alt_9
+        when 1
+          # at line 32:18: scope_old_syntax
+          @state.following.push( TOKENS_FOLLOWING_scope_old_syntax_IN_ruby_scope_153 )
+          scope_old_syntax
+          @state.following.pop
+
+        when 2
+          # at line 32:37: scope_new_syntax
+          @state.following.push( TOKENS_FOLLOWING_scope_new_syntax_IN_ruby_scope_157 )
+          scope_new_syntax
+          @state.following.pop
+
+        end
+        match( T__19, TOKENS_FOLLOWING_T__19_IN_ruby_scope_160 )
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 6 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule scope_old_syntax
+    # 
+    # (in /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/validates/ValidatesParser.g)
+    # 34:1: scope_old_syntax : ':' 'scope' '=>' ( list | list_attribute ) ;
+    # 
+    def scope_old_syntax
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 7 )
+
+      begin
+        # at line 34:19: ':' 'scope' '=>' ( list | list_attribute )
+        match( T__13, TOKENS_FOLLOWING_T__13_IN_scope_old_syntax_167 )
+        match( T__20, TOKENS_FOLLOWING_T__20_IN_scope_old_syntax_169 )
+        match( T__16, TOKENS_FOLLOWING_T__16_IN_scope_old_syntax_171 )
+        # at line 34:36: ( list | list_attribute )
+        alt_10 = 2
+        look_10_0 = @input.peek( 1 )
+
+        if ( look_10_0 == T__21 )
+          alt_10 = 1
+        elsif ( look_10_0 == T__13 || look_10_0.between?( T__23, T__24 ) )
+          alt_10 = 2
+        else
+          raise NoViableAlternative( "", 10, 0 )
+        end
+        case alt_10
+        when 1
+          # at line 34:37: list
+          @state.following.push( TOKENS_FOLLOWING_list_IN_scope_old_syntax_174 )
+          list
+          @state.following.pop
+
+        when 2
+          # at line 34:44: list_attribute
+          @state.following.push( TOKENS_FOLLOWING_list_attribute_IN_scope_old_syntax_178 )
+          list_attribute
+          @state.following.pop
+
+        end
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 7 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule scope_new_syntax
+    # 
+    # (in /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/validates/ValidatesParser.g)
+    # 36:1: scope_new_syntax : 'scope' ':' ( list | list_attribute ) ;
+    # 
+    def scope_new_syntax
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 8 )
+
+      begin
+        # at line 36:19: 'scope' ':' ( list | list_attribute )
+        match( T__20, TOKENS_FOLLOWING_T__20_IN_scope_new_syntax_186 )
+        match( T__13, TOKENS_FOLLOWING_T__13_IN_scope_new_syntax_188 )
+        # at line 36:31: ( list | list_attribute )
+        alt_11 = 2
+        look_11_0 = @input.peek( 1 )
+
+        if ( look_11_0 == T__21 )
+          alt_11 = 1
+        elsif ( look_11_0 == T__13 || look_11_0.between?( T__23, T__24 ) )
+          alt_11 = 2
+        else
+          raise NoViableAlternative( "", 11, 0 )
+        end
+        case alt_11
+        when 1
+          # at line 36:32: list
+          @state.following.push( TOKENS_FOLLOWING_list_IN_scope_new_syntax_191 )
+          list
+          @state.following.pop
+
+        when 2
+          # at line 36:39: list_attribute
+          @state.following.push( TOKENS_FOLLOWING_list_attribute_IN_scope_new_syntax_195 )
+          list_attribute
+          @state.following.pop
+
+        end
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 8 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule list
+    # 
+    # (in /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/validates/ValidatesParser.g)
+    # 38:1: list : '[' list_attribute ',' ( list_attribute )* ']' ;
+    # 
+    def list
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 9 )
+
+      begin
+        # at line 38:7: '[' list_attribute ',' ( list_attribute )* ']'
+        match( T__21, TOKENS_FOLLOWING_T__21_IN_list_203 )
+        @state.following.push( TOKENS_FOLLOWING_list_attribute_IN_list_205 )
+        list_attribute
+        @state.following.pop
+        match( T__12, TOKENS_FOLLOWING_T__12_IN_list_207 )
+        # at line 38:30: ( list_attribute )*
+        while true # decision 12
+          alt_12 = 2
+          look_12_0 = @input.peek( 1 )
+
+          if ( look_12_0 == T__13 || look_12_0.between?( T__23, T__24 ) )
+            alt_12 = 1
+
+          end
+          case alt_12
+          when 1
+            # at line 38:30: list_attribute
+            @state.following.push( TOKENS_FOLLOWING_list_attribute_IN_list_209 )
+            list_attribute
+            @state.following.pop
+
+          else
+            break # out of loop for decision 12
+          end
+        end # loop for decision 12
+        match( T__22, TOKENS_FOLLOWING_T__22_IN_list_212 )
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 9 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule attribute
+    # 
+    # (in /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/validates/ValidatesParser.g)
+    # 40:1: attribute : ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) );
+    # 
+    def attribute
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 10 )
+      a = nil
+
+      begin
+        # at line 40:10: ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) )
+        alt_13 = 3
+        case look_13 = @input.peek( 1 )
+        when T__23 then alt_13 = 1
+        when T__24 then alt_13 = 2
+        when T__13 then alt_13 = 3
+        else
+          raise NoViableAlternative( "", 13, 0 )
+        end
+        case alt_13
+        when 1
+          # at line 40:12: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 40:12: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 40:13: '\\'' a= ATTRIBUTE '\\''
+          match( T__23, TOKENS_FOLLOWING_T__23_IN_attribute_220 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_224 )
+          match( T__23, TOKENS_FOLLOWING_T__23_IN_attribute_226 )
+
+
+        when 2
+          # at line 40:38: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 40:38: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 40:39: '\"' a= ATTRIBUTE '\"'
+          match( T__24, TOKENS_FOLLOWING_T__24_IN_attribute_232 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_236 )
+          match( T__24, TOKENS_FOLLOWING_T__24_IN_attribute_238 )
+
+
+        when 3
+          # at line 40:62: ( ':' a= ATTRIBUTE )
+          # at line 40:62: ( ':' a= ATTRIBUTE )
+          # at line 40:63: ':' a= ATTRIBUTE
+          match( T__13, TOKENS_FOLLOWING_T__13_IN_attribute_244 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_248 )
+
+          # --> action
+
+          		@attribute = a.text
+          	
+          # <-- action
+
+        end
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 10 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule list_attribute
+    # 
+    # (in /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/validates/ValidatesParser.g)
+    # 46:1: list_attribute : ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) ) ;
+    # 
+    def list_attribute
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 11 )
+      a = nil
+
+      begin
+        # at line 46:17: ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) )
+        # at line 46:17: ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) )
+        alt_14 = 3
+        case look_14 = @input.peek( 1 )
+        when T__23 then alt_14 = 1
+        when T__24 then alt_14 = 2
+        when T__13 then alt_14 = 3
+        else
+          raise NoViableAlternative( "", 14, 0 )
+        end
+        case alt_14
+        when 1
+          # at line 46:18: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 46:18: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 46:19: '\\'' a= ATTRIBUTE '\\''
+          match( T__23, TOKENS_FOLLOWING_T__23_IN_list_attribute_262 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_list_attribute_266 )
+          match( T__23, TOKENS_FOLLOWING_T__23_IN_list_attribute_268 )
+
+
+        when 2
+          # at line 46:44: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 46:44: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 46:45: '\"' a= ATTRIBUTE '\"'
+          match( T__24, TOKENS_FOLLOWING_T__24_IN_list_attribute_274 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_list_attribute_278 )
+          match( T__24, TOKENS_FOLLOWING_T__24_IN_list_attribute_280 )
+
+
+        when 3
+          # at line 46:68: ( ':' a= ATTRIBUTE )
+          # at line 46:68: ( ':' a= ATTRIBUTE )
+          # at line 46:69: ':' a= ATTRIBUTE
+          match( T__13, TOKENS_FOLLOWING_T__13_IN_list_attribute_286 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_list_attribute_290 )
+
+
+        end
+        # --> action
+
+        		@list = [] unless @list
+        		@list << 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__, 11 )
+
+      end
+      
+      return 
+    end
+
+
+
+    TOKENS_FOLLOWING_COMMENT_IN_comment_35 = Set[ 1 ]
+    TOKENS_FOLLOWING_COMMENT_IN_validates_50 = Set[ 1, 4 ]
+    TOKENS_FOLLOWING_T__11_IN_validates_56 = Set[ 13, 23, 24 ]
+    TOKENS_FOLLOWING_attribute_IN_validates_58 = Set[ 12 ]
+    TOKENS_FOLLOWING_validation_helper_IN_validates_60 = Set[ 1, 4 ]
+    TOKENS_FOLLOWING_comment_IN_validates_62 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__12_IN_validation_helper_75 = Set[ 13, 14, 15 ]
+    TOKENS_FOLLOWING_validation_helper_old_syntax_IN_validation_helper_78 = Set[ 1 ]
+    TOKENS_FOLLOWING_validation_helper_new_syntax_IN_validation_helper_82 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__13_IN_validation_helper_old_syntax_90 = Set[ 14, 15 ]
+    TOKENS_FOLLOWING_T__14_IN_validation_helper_old_syntax_95 = Set[ 16 ]
+    TOKENS_FOLLOWING_T__15_IN_validation_helper_old_syntax_101 = Set[ 16 ]
+    TOKENS_FOLLOWING_T__16_IN_validation_helper_old_syntax_104 = Set[ 17, 18 ]
+    TOKENS_FOLLOWING_T__17_IN_validation_helper_old_syntax_107 = Set[ 1 ]
+    TOKENS_FOLLOWING_ruby_scope_IN_validation_helper_old_syntax_111 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__14_IN_validation_helper_new_syntax_124 = Set[ 13 ]
+    TOKENS_FOLLOWING_T__15_IN_validation_helper_new_syntax_130 = Set[ 13 ]
+    TOKENS_FOLLOWING_T__13_IN_validation_helper_new_syntax_133 = Set[ 17, 18 ]
+    TOKENS_FOLLOWING_T__17_IN_validation_helper_new_syntax_136 = Set[ 1 ]
+    TOKENS_FOLLOWING_ruby_scope_IN_validation_helper_new_syntax_140 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__18_IN_ruby_scope_150 = Set[ 13, 20 ]
+    TOKENS_FOLLOWING_scope_old_syntax_IN_ruby_scope_153 = Set[ 19 ]
+    TOKENS_FOLLOWING_scope_new_syntax_IN_ruby_scope_157 = Set[ 19 ]
+    TOKENS_FOLLOWING_T__19_IN_ruby_scope_160 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__13_IN_scope_old_syntax_167 = Set[ 20 ]
+    TOKENS_FOLLOWING_T__20_IN_scope_old_syntax_169 = Set[ 16 ]
+    TOKENS_FOLLOWING_T__16_IN_scope_old_syntax_171 = Set[ 13, 21, 23, 24 ]
+    TOKENS_FOLLOWING_list_IN_scope_old_syntax_174 = Set[ 1 ]
+    TOKENS_FOLLOWING_list_attribute_IN_scope_old_syntax_178 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__20_IN_scope_new_syntax_186 = Set[ 13 ]
+    TOKENS_FOLLOWING_T__13_IN_scope_new_syntax_188 = Set[ 13, 21, 23, 24 ]
+    TOKENS_FOLLOWING_list_IN_scope_new_syntax_191 = Set[ 1 ]
+    TOKENS_FOLLOWING_list_attribute_IN_scope_new_syntax_195 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__21_IN_list_203 = Set[ 13, 21, 23, 24 ]
+    TOKENS_FOLLOWING_list_attribute_IN_list_205 = Set[ 12 ]
+    TOKENS_FOLLOWING_T__12_IN_list_207 = Set[ 13, 21, 22, 23, 24 ]
+    TOKENS_FOLLOWING_list_attribute_IN_list_209 = Set[ 13, 21, 22, 23, 24 ]
+    TOKENS_FOLLOWING_T__22_IN_list_212 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__23_IN_attribute_220 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_224 = Set[ 23 ]
+    TOKENS_FOLLOWING_T__23_IN_attribute_226 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__24_IN_attribute_232 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_236 = Set[ 24 ]
+    TOKENS_FOLLOWING_T__24_IN_attribute_238 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__13_IN_attribute_244 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_248 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__23_IN_list_attribute_262 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_list_attribute_266 = Set[ 23 ]
+    TOKENS_FOLLOWING_T__23_IN_list_attribute_268 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__24_IN_list_attribute_274 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_list_attribute_278 = Set[ 24 ]
+    TOKENS_FOLLOWING_T__24_IN_list_attribute_280 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__13_IN_list_attribute_286 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_list_attribute_290 = Set[ 1 ]
+
+  end # class Parser < ANTLR3::Parser
+
+  at_exit { Parser.main( ARGV ) } if __FILE__ == $0
+end
+