tripper 0.0.3d

data/lib/tripper/model_parsers/attribute_parser/AttributeParserParser.rb

@@ -0,0 +1,412 @@
+#!/usr/bin/env ruby
+#
+# /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/attribute_parser/AttributeParser.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/attribute_parser/AttributeParser.g
+# Generated at: 2013-05-05 11:42:33
+# 
+
+# ~~~> 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/attribute_parser/AttributeParser.g
+
+
+	def strip_quotes str
+		return str[1,(str.length)-2]
+	end
+
+# - - - - - - end action @parser::header - - - - - - -
+
+
+module AttributeParser
+  # 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, :HC => 6, :T__12 => 12, :T__11 => 11, 
+                   :T__13 => 13, :ATTRIBUTE => 5, :WHITESPACE => 9, :LC => 7, 
+                   :DIGIT => 8, :COMMENT => 4, :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( "COMMENT", "ATTRIBUTE", "HC", "LC", "DIGIT", "WHITESPACE", 
+                    "ACTUALSTRING", "'attr_accessible'", "','", "':'" )
+    
+  end
+
+
+  class Parser < ANTLR3::Parser
+    @grammar_home = AttributeParser
+
+    RULE_METHODS = [ :comment, :attr_accessible, :attributes, :attribute ].freeze
+
+
+    include TokenData
+
+    begin
+      generated_using( "/Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/attribute_parser/AttributeParser.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 comment
+    # 
+    # (in /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/attribute_parser/AttributeParser.g)
+    # 15:1: comment : COMMENT ;
+    # 
+    def comment
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 1 )
+
+      begin
+        # at line 15:10: COMMENT
+        match( COMMENT, TOKENS_FOLLOWING_COMMENT_IN_comment_34 )
+
+      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 attr_accessible
+    # 
+    # (in /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/attribute_parser/AttributeParser.g)
+    # 17:1: attr_accessible returns [expr] : ( (c= COMMENT )* | 'attr_accessible' ( attributes )* ( attribute )? ( comment )? ) ;
+    # 
+    def attr_accessible
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 2 )
+      expr = nil
+      c = nil
+
+      begin
+        # at line 17:33: ( (c= COMMENT )* | 'attr_accessible' ( attributes )* ( attribute )? ( comment )? )
+        # at line 17:33: ( (c= COMMENT )* | 'attr_accessible' ( attributes )* ( attribute )? ( comment )? )
+        alt_5 = 2
+        look_5_0 = @input.peek( 1 )
+
+        if ( look_5_0 == EOF || look_5_0 == COMMENT )
+          alt_5 = 1
+        elsif ( look_5_0 == T__11 )
+          alt_5 = 2
+        else
+          raise NoViableAlternative( "", 5, 0 )
+        end
+        case alt_5
+        when 1
+          # at line 17:34: (c= COMMENT )*
+          # at line 17:34: (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 17:35: c= COMMENT
+              c = match( COMMENT, TOKENS_FOLLOWING_COMMENT_IN_attr_accessible_49 )
+
+            else
+              break # out of loop for decision 1
+            end
+          end # loop for decision 1
+
+        when 2
+          # at line 17:49: 'attr_accessible' ( attributes )* ( attribute )? ( comment )?
+          match( T__11, TOKENS_FOLLOWING_T__11_IN_attr_accessible_55 )
+          # at line 17:67: ( attributes )*
+          while true # decision 2
+            alt_2 = 2
+            alt_2 = @dfa2.predict( @input )
+            case alt_2
+            when 1
+              # at line 17:67: attributes
+              @state.following.push( TOKENS_FOLLOWING_attributes_IN_attr_accessible_57 )
+              attributes
+              @state.following.pop
+
+            else
+              break # out of loop for decision 2
+            end
+          end # loop for decision 2
+          # at line 17:79: ( attribute )?
+          alt_3 = 2
+          look_3_0 = @input.peek( 1 )
+
+          if ( look_3_0 == T__13 )
+            alt_3 = 1
+          end
+          case alt_3
+          when 1
+            # at line 17:79: attribute
+            @state.following.push( TOKENS_FOLLOWING_attribute_IN_attr_accessible_60 )
+            attribute
+            @state.following.pop
+
+          end
+          # at line 17:90: ( comment )?
+          alt_4 = 2
+          look_4_0 = @input.peek( 1 )
+
+          if ( look_4_0 == COMMENT )
+            alt_4 = 1
+          end
+          case alt_4
+          when 1
+            # at line 17:90: comment
+            @state.following.push( TOKENS_FOLLOWING_comment_IN_attr_accessible_63 )
+            comment
+            @state.following.pop
+
+          end
+
+        end
+        # --> action
+
+        	@attributes = [] unless @attributes
+        expr = @attributes
+
+        # <-- 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 attributes
+    # 
+    # (in /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/attribute_parser/AttributeParser.g)
+    # 24:1: attributes : attribute ',' ;
+    # 
+    def attributes
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 3 )
+
+      begin
+        # at line 24:13: attribute ','
+        @state.following.push( TOKENS_FOLLOWING_attribute_IN_attributes_75 )
+        attribute
+        @state.following.pop
+        match( T__12, TOKENS_FOLLOWING_T__12_IN_attributes_77 )
+
+      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 attribute
+    # 
+    # (in /Users/rivmeche/Google Drive/vub/_Thesis/code/tripper/lib/tripper/model_parsers/attribute_parser/AttributeParser.g)
+    # 27:1: attribute : ( ':' )+ a= ATTRIBUTE ;
+    # 
+    def attribute
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 4 )
+      a = nil
+
+      begin
+        # at line 28:4: ( ':' )+ a= ATTRIBUTE
+        # at file 28:4: ( ':' )+
+        match_count_6 = 0
+        while true
+          alt_6 = 2
+          look_6_0 = @input.peek( 1 )
+
+          if ( look_6_0 == T__13 )
+            alt_6 = 1
+
+          end
+          case alt_6
+          when 1
+            # at line 28:5: ':'
+            match( T__13, TOKENS_FOLLOWING_T__13_IN_attribute_88 )
+
+          else
+            match_count_6 > 0 and break
+            eee = EarlyExit(6)
+
+
+            raise eee
+          end
+          match_count_6 += 1
+        end
+
+        a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_94 )
+        # --> 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__, 4 )
+
+      end
+      
+      return 
+    end
+
+
+
+    # - - - - - - - - - - DFA definitions - - - - - - - - - - -
+    class DFA2 < ANTLR3::DFA
+      EOT = unpack( 5, -1 )
+      EOF = unpack( 1, 2, 2, -1, 1, 2, 1, -1 )
+      MIN = unpack( 1, 4, 1, 5, 1, -1, 1, 4, 1, -1 )
+      MAX = unpack( 2, 13, 1, -1, 1, 12, 1, -1 )
+      ACCEPT = unpack( 2, -1, 1, 2, 1, -1, 1, 1 )
+      SPECIAL = unpack( 5, -1 )
+      TRANSITION = [
+        unpack( 1, 2, 8, -1, 1, 1 ),
+        unpack( 1, 3, 7, -1, 1, 1 ),
+        unpack(  ),
+        unpack( 1, 2, 7, -1, 1, 4 ),
+        unpack(  )
+      ].freeze
+      
+      ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
+        if a > 0 and z < 0
+          MAX[ i ] %= 0x10000
+        end
+      end
+      
+      @decision = 2
+      
+
+      def description
+        <<-'__dfa_description__'.strip!
+          ()* loopback of 17:67: ( attributes )*
+        __dfa_description__
+      end
+    end
+
+
+    private
+
+    def initialize_dfas
+      super rescue nil
+      @dfa2 = DFA2.new( self, 2 )
+
+    end
+    TOKENS_FOLLOWING_COMMENT_IN_comment_34 = Set[ 1 ]
+    TOKENS_FOLLOWING_COMMENT_IN_attr_accessible_49 = Set[ 1, 4 ]
+    TOKENS_FOLLOWING_T__11_IN_attr_accessible_55 = Set[ 1, 4, 13 ]
+    TOKENS_FOLLOWING_attributes_IN_attr_accessible_57 = Set[ 1, 4, 13 ]
+    TOKENS_FOLLOWING_attribute_IN_attr_accessible_60 = Set[ 1, 4 ]
+    TOKENS_FOLLOWING_comment_IN_attr_accessible_63 = Set[ 1 ]
+    TOKENS_FOLLOWING_attribute_IN_attributes_75 = Set[ 12 ]
+    TOKENS_FOLLOWING_T__12_IN_attributes_77 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__13_IN_attribute_88 = Set[ 5, 13 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_94 = Set[ 1 ]
+
+  end # class Parser < ANTLR3::Parser
+
+  at_exit { Parser.main( ARGV ) } if __FILE__ == $0
+end
+

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

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

data/lib/tripper/model_parsers/belongs_to/BelongsToParser.g

@@ -0,0 +1,63 @@
+grammar BelongsToParser;
+
+options {
+	language = Ruby;
+	}
+
+@header {
+	def strip_quotes str
+		return str[1,(str.length)-2]
+	end
+
+	@@attribute = nil
+	@@class_name = nil
+}
+
+@members {
+attr_accessor :attribute, :class_name
+}
+
+comment: COMMENT;
+
+belongs_to returns [expr]:	((c=COMMENT)* | 'belongs_to' attribute class_name? comment?)
+	{
+		$expr = {attribute: @attribute, class_name: @class_name} 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;
+
+
+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';