simply_stored 0.1.4

data/test/vendor/dhaka-2.2.1/lib/dhaka/lexer/regex_tokenizer.rb

@@ -0,0 +1,14 @@
+module Dhaka
+  module LexerSupport
+    class RegexTokenizer < Tokenizer
+    
+      for_state TOKENIZER_IDLE_STATE do
+        for_characters(Dhaka::LexerSupport::ALL_CHARACTERS) do
+          create_token(curr_char, nil)
+          advance
+        end
+      end
+  
+    end
+  end
+end

data/test/vendor/dhaka-2.2.1/lib/dhaka/lexer/specification.rb

@@ -0,0 +1,96 @@
+module Dhaka
+  # Abstract base class for lexer specifications.
+  # 
+  # Use this to specify the transformations that will be performed when the lexer recognizes a given pattern. Actions are listed in
+  # descending order of priority. For example in the following lexer specification:
+  # 
+  #   class LexerSpec < Dhaka::LexerSpecification
+  #     for_pattern 'zz' do
+  #       "recognized two zs"
+  #     end
+  #   
+  #     for_pattern '\w(\w|\d)*' do
+  #       "recognized word token #{current_lexeme.value}"
+  #     end
+  #   
+  #     for_pattern '(\d)+(\.\d+)?' do
+  #       "recognized number #{current_lexeme.value}"
+  #     end
+  #   
+  #     for_pattern ' +' do
+  #       #ignores whitespace
+  #     end
+  #     
+  #     for_pattern "\n+" do
+  #       "recognized newline"
+  #     end
+  #   end
+  #  
+  # the pattern 'zz' takes precedence over the pattern immediately below it, so the lexer will announce that it has recognized two
+  # 'z's instead of a word token.
+  #  
+  # The patterns are <i>not</i> Ruby regular expressions - a lot of operators featured in Ruby's regular expression engine are not yet supported.
+  # See http://dhaka.rubyforge.org/regex_grammar.html for the current syntax. Patterns may be specified using Ruby regular expression literals 
+  # as well as string literals. 
+  # 
+  # There are a few things to keep in mind with regard to the regular expression implementation:
+  # * The greediest matching expression always wins. Precedences are only used when the same set of characters matches
+  #   multiple expressions.
+  # * All quantifiers are greedy. There is as yet no support for non-greedy modifiers.
+  # * The lookahead operator "/" can behave in counter-intuitive ways in situations where the pre-lookahead-operator expression and the 
+  #   post-lookahead-operator expression have characters in common. For example the expression "(ab)+/abcd", when applied to the input
+  #   "abababcd" will yield "ababab" as the match instead of "abab". A good thumb rule is that the pre-lookahead expression is greedy.
+  # * There is no support for characters beyond those specified in the grammar above. This means that there is no support for extended ASCII or unicode characters.
+
+  
+  class LexerSpecification
+    class << self
+      # Associates +blk+ as the action to be performed when a lexer recognizes +pattern+. When Lexer#lex is invoked, 
+      # it creates a LexerRun object that provides the context for +blk+ to be evaluated in. Methods available in this block
+      # are LexerRun#current_lexeme and LexerRun#create_token.
+      def for_pattern(pattern, &blk)
+        source = case pattern
+                   when String then pattern
+                   when Regexp then pattern.source
+                 end
+        items[source] = LexerSpecificationItem.new(source, priority, blk)
+        self.priority += 1
+      end
+      
+      # Use this to automatically handle escaping for regular expression metacharacters. For example, 
+      #   for_symbol('+') { ... }
+      # translates to:
+      #   for_pattern('\+') { ... }
+      def for_symbol(symbol, &blk)
+        if LexerSupport::OPERATOR_CHARACTERS.include?(symbol)
+          for_pattern("\\#{symbol}", &blk)
+        else
+          for_pattern(symbol, &blk)
+        end
+      end
+      
+      private
+        def inherited(specification)
+          class << specification
+            attr_accessor :items, :priority
+          end
+          specification.items = {}
+          specification.priority = 0
+        end
+    
+    end
+  end
+  
+  class LexerSpecificationItem #:nodoc:
+    include Comparable
+    attr_reader :pattern, :action, :priority
+    def initialize(pattern, priority, action)
+      @pattern, @priority, @action = pattern, priority, action
+    end
+  
+    def <=> other
+      priority <=> other.priority
+    end
+  end
+end
+    

data/test/vendor/dhaka-2.2.1/lib/dhaka/lexer/state.rb

@@ -0,0 +1,68 @@
+module Dhaka
+  module LexerSupport
+    
+    class State
+      attr_reader :transitions, :checkpoint_actions, :action
+      def initialize(state_machine, action=nil)
+        @state_machine      = state_machine
+        @transitions        = {}
+        @checkpoint_actions = []
+        @action             = action
+      end
+      
+      def accepting?
+        @action
+      end
+      
+      def process lexer_run
+        checkpoint_actions.each {|action| action.call(lexer_run)}
+        action.call(lexer_run) if accepting?
+      end
+      
+      def for_characters *characters, &blk
+        dest_state = @state_machine.instance_eval(&blk)
+        characters.each do |char|
+          transitions[char] = dest_state
+        end
+      end
+      
+      def add_checkpoint(pattern)
+        checkpoint_actions << LexerSupport::CheckpointAction.new(pattern)
+      end
+      
+      def accept(pattern)
+        @action = AcceptAction.new(pattern)
+      end
+      
+      def accept_with_lookahead(pattern)
+        @action = LookaheadAcceptAction.new(pattern)
+      end
+      
+      def recognize pattern
+        @pattern = pattern
+      end
+      
+      def compile_to_ruby_source
+        result  = "  at_state(#{object_id}) {\n"
+        result << "    #{action.compile_to_ruby_source}\n" if action
+        checkpoint_actions.each do |checkpoint_action|
+          result << "    #{checkpoint_action.compile_to_ruby_source}\n"
+        end
+        transition_keys_by_destination_state = Hash.new {|hash, key| hash[key] = []}
+        transitions.each do |key, dest_state|
+          transition_keys_by_destination_state[dest_state.object_id] << key
+        end
+
+        transition_keys_by_destination_state.keys.each do |state_id|
+          transition_keys = transition_keys_by_destination_state[state_id].collect {|transition_key| "#{transition_key.inspect}"}.join(', ')
+          result << "    for_characters(#{transition_keys}) { switch_to #{state_id} }\n"
+        end
+
+        result << "  }"
+        result
+      end
+    end
+    
+  end
+end
+  

data/test/vendor/dhaka-2.2.1/lib/dhaka/lexer/state_machine.rb

@@ -0,0 +1,37 @@
+module Dhaka
+  module LexerSupport
+    class StateMachine
+      attr_reader :start_state
+    
+      def initialize start_key
+        @states = Hash.new do |hash, key|
+          new_state = new_state_for_key key
+          hash[key] = new_state
+          transition_characters(key).each do |char|
+            dest_key                    = dest_key_for(key, char)
+            dest_state                  = hash[dest_key]
+            new_state.transitions[char] = dest_state
+          end
+          new_state
+        end
+        @start_state = @states[start_key]
+      end
+
+      def to_dot
+        Dot::Digraph.new(:fontsize => 10, :shape => :circle, :size => 5) do |g|
+          start = 'Start'
+          g.node(start, :label => start)
+          g.edge(start, @start_state)
+          @states.values.each do |state|
+            state_attributes = {}
+            state_attributes.merge!(:shape => :doublecircle, :label => state.action.to_dot) if state.accepting?
+            g.node(state, state_attributes)
+            state.transitions.each do |transition_key, dest_state|
+              g.edge(state, dest_state, :label => transition_key.inspect)
+            end
+          end
+        end.to_dot
+      end
+    end
+  end
+end

data/test/vendor/dhaka-2.2.1/lib/dhaka/parser/action.rb

@@ -0,0 +1,55 @@
+module Dhaka
+  # Encapsulates code for Parser actions.
+  class Action #:nodoc:
+    attr_reader :action_code
+  end
+
+  class ShiftAction < Action #:nodoc:
+    attr_reader :destination_state
+    def initialize destination_state
+      @destination_state = destination_state
+      @action_code       = Proc.new do
+        state_stack << destination_state
+        []
+      end
+    end
+    
+    def compile_to_ruby_source
+      "shift_to #{destination_state.id}"
+    end
+    
+    def to_s
+      "Shift"
+    end
+  end
+
+  class ReduceAction < Action #:nodoc:
+    attr_reader :production
+    
+    def initialize(production)
+      @production  = production
+      @action_code = Proc.new do
+        composite_node = ParseTreeCompositeNode.new(production)
+
+        production.expansion.each do |symbol|
+          state_stack.pop
+          composite_node.child_nodes.unshift(node_stack.pop)
+        end
+
+        node_stack << composite_node.instance_eval(&production.action)
+
+        unless composite_node.head_node?
+          @symbol_queue.concat [@current_token.symbol_name, production.symbol.name]
+        end
+      end
+    end
+    
+    def compile_to_ruby_source
+      "reduce_with #{production.name.inspect}"
+    end
+    
+    def to_s
+      "Reduce with #{production}"
+    end
+  end
+end

data/test/vendor/dhaka-2.2.1/lib/dhaka/parser/channel.rb

@@ -0,0 +1,58 @@
+module Dhaka
+  # Represents channels for pumping of lookaheads between items
+  class Channel #:nodoc:
+    attr_reader :start_item, :end_item
+
+    def initialize(grammar, start_item, end_item)
+      @grammar    = grammar
+      @start_item = start_item
+      @end_item   = end_item
+    end
+
+    def propagate cargo
+      initial_size = end_item.lookaheadset.size
+      end_item.lookaheadset.merge(cargo)
+      (end_item.lookaheadset.size - initial_size) > 0
+    end
+
+    def to_s
+      "Channel from #{start_item} to #{end_item}"
+    end
+
+    def eql? other
+      start_item.eql?(other.start_item) && end_item.eql?(other.end_item)
+    end
+    
+    def hash
+      start_item.hash ^ end_item.hash
+    end
+  end
+
+  class SpontaneousChannel < Channel #:nodoc:
+    def to_s
+      "Spontaneous " + super
+    end
+    
+    def pump
+      follow_index = start_item.next_item_index + 1
+      cargo        = Set.new
+      while follow_symbol = start_item.production.expansion[follow_index]
+        cargo.merge @grammar.first(follow_symbol)
+        return propagate(cargo) unless follow_symbol.nullable
+        follow_index += 1
+      end
+      cargo.merge start_item.lookaheadset
+      propagate cargo
+    end
+  end
+
+  class PassiveChannel < Channel #:nodoc:
+    def to_s
+      "Passive " + super
+    end
+    
+    def pump
+      propagate start_item.lookaheadset
+    end
+  end
+end

data/test/vendor/dhaka-2.2.1/lib/dhaka/parser/compiled_parser.rb

@@ -0,0 +1,51 @@
+module Dhaka
+  # Abstract base class of all compiled Parsers. It is only used by generated code.
+  class CompiledParser
+
+    class << self
+      private
+        def inherited(compiled_parser)
+          class << compiled_parser
+            attr_accessor :states, :grammar, :start_state_id, :shift_actions, :reduce_actions
+          end
+          compiled_parser.states          = Hash.new do |hash, state_id| 
+                                              hash[state_id] = ParserState.new(compiled_parser, {}, state_id)
+                                            end
+          compiled_parser.shift_actions   = Hash.new do |hash, state_id|
+                                              hash[state_id] = ShiftAction.new(compiled_parser.states[state_id])
+                                            end
+          compiled_parser.reduce_actions  = Hash.new do |hash, production_name|
+                                              hash[production_name] = ReduceAction.new(compiled_parser.grammar.production_named(production_name))
+                                            end
+        end
+
+        def at_state x, &blk
+          states[x].instance_eval(&blk)
+        end
+  
+        def start_state
+          states[start_state_id]
+        end
+  
+        def start_with start_state_id
+          self.start_state_id = start_state_id
+        end
+  
+        def reduce_with production_name
+          ReduceAction.new(grammar.production_named(production_name))
+        end
+  
+        def shift_to state_id
+          ShiftAction.new(states[state_id])
+        end
+        
+        def inspect
+          "<Dhaka::CompiledParser grammar : #{grammar}>"
+        end
+    end
+  
+    extend(ParserMethods)
+  
+  end
+
+end

data/test/vendor/dhaka-2.2.1/lib/dhaka/parser/conflict.rb

@@ -0,0 +1,54 @@
+module Dhaka
+  # Represents parser shift-reduce and reduce-reduce conflicts and encapsulates logic for resolving them.
+  class Conflict #:nodoc:
+    def initialize(state, lookahead, new_action)
+      @lookahead, @new_action, @state = lookahead, new_action, state
+    end
+
+    def build_conflict_message
+      lines = ["Parser Conflict at State:", @state.to_s(:hide_lookaheads => true)]
+      lines << "Existing: #{@state.actions[@lookahead.name]}"
+      lines << "New: #{@new_action}"
+      lines << "Lookahead: #{@lookahead}"
+      lines.join("\n")
+    end
+  end
+
+
+  class ReduceReduceConflict < Conflict #:nodoc:
+    def resolve
+      build_conflict_message
+    end
+  end
+
+  class ShiftReduceConflict < Conflict #:nodoc:
+    
+    def resolve
+      lines = [build_conflict_message]
+      shift_precedence  = @lookahead.precedence
+      reduce_precedence = @new_action.production.precedence
+      if shift_precedence && reduce_precedence
+        if shift_precedence > reduce_precedence
+          lines << "Resolving with precedence. Choosing shift over reduce."
+        elsif shift_precedence < reduce_precedence
+          lines << "Resolving with precedence. Choosing reduce over shift."
+          @state.actions[@lookahead.name] = @new_action
+        else
+          case shift_precedence.associativity
+            when :left
+              lines << "Resolving with left associativity. Choosing reduce over shift."
+              @state.actions[@lookahead.name] = @new_action
+            when :right
+              lines << "Resolving with right associativity. Choosing shift over reduce."
+            when :nonassoc
+              lines << "Resolving with non-associativity. Eliminating action."
+              @state.actions.delete(@lookahead.name)
+          end
+        end
+      else
+        lines << "No precedence rule. Choosing shift over reduce."
+      end
+      lines.join("\n")
+    end
+  end
+end

data/test/vendor/dhaka-2.2.1/lib/dhaka/parser/item.rb

@@ -0,0 +1,42 @@
+module Dhaka
+  # Represents parser state items
+  class Item #:nodoc:
+    attr_reader :production, :next_item_index, :lookaheadset
+
+    def initialize(production, next_item_index)
+      @production      = production
+      @next_item_index = next_item_index
+      @lookaheadset    = Set.new
+    end
+    
+    def next_symbol
+      production.expansion[next_item_index]
+    end
+    
+    def next_item
+      Item.new(production, @next_item_index + 1)
+    end
+    
+    def to_s(options = {})
+      expansion_symbols = production.expansion.collect {|symbol| symbol.name}
+      if next_item_index < expansion_symbols.size
+        expansion_symbols.insert(next_item_index, '->')
+      else
+        expansion_symbols << '->'
+      end
+      expansion_repr = expansion_symbols.join(' ')
+
+      item = "#{production.symbol} ::= #{expansion_repr}"
+      item << " [#{lookaheadset.collect.sort}]" unless options[:hide_lookaheads]
+      item
+    end
+   
+    def eql?(other)
+      production == other.production && next_item_index == other.next_item_index
+    end
+
+    def hash
+      production.hash ^ next_item_index.hash
+    end
+  end
+end

data/test/vendor/dhaka-2.2.1/lib/dhaka/parser/parse_result.rb

@@ -0,0 +1,50 @@
+module Dhaka
+  # Returned on successful parsing of the input token stream. 
+  class ParseSuccessResult < DelegateClass(ParseTreeCompositeNode)
+    # Contains the parse result.
+    attr_accessor :parse_tree 
+    
+    def initialize(parse_tree) #:nodoc:
+      super
+      @parse_tree = parse_tree
+    end
+    
+    # This is false.
+    def has_error? 
+      false
+    end
+    
+    # Returns the dot representation of the parse tree
+    def to_dot
+      Dot::Digraph.new(:fontsize => 10, :shape => :box, :size => 5) do |g|
+        parse_tree.to_dot(g)
+      end.to_dot
+    end
+    
+    # Deprecated. Use the +parse_tree+ accessor.
+    alias syntax_tree parse_tree
+  end
+
+  # Returned on unsuccessful parsing of the input token stream.
+  class ParseErrorResult
+    attr_reader :unexpected_token, :parser_state
+    
+    def initialize(unexpected_token, parser_state) #:nodoc:
+      @unexpected_token = unexpected_token
+      @parser_state = parser_state
+    end
+    
+    # This is true.
+    def has_error? 
+      true
+    end
+    
+    def inspect #:nodoc:
+      "<Dhaka::ParseErrorResult unexpected_token=#{unexpected_token.inspect}>"
+    end
+  end
+end
+      
+    
+  
+    

data/test/vendor/dhaka-2.2.1/lib/dhaka/parser/parse_tree.rb

@@ -0,0 +1,66 @@
+module Dhaka
+  # These are composite nodes of the syntax tree returned by the successful parsing of a token stream.
+  class ParseTreeCompositeNode 
+    attr_reader :production, :child_nodes
+    
+    def initialize(production) #:nodoc:
+      @production  = production
+      @child_nodes = []
+    end  
+    def linearize #:nodoc:
+      child_nodes.collect {|child_node| child_node.linearize}.flatten + [self]
+    end
+    
+    def tokens
+      child_nodes.collect{|child_node| child_node.tokens}.flatten
+    end
+    
+    def to_s #:nodoc:
+      "CompositeNode: #{production.symbol} --> [#{child_nodes.join(", ")}]"
+    end
+    
+    # Returns the dot representation of this node.
+    def to_dot graph
+      graph.node(self, :label => production)
+      child_nodes.each do |child|
+        graph.edge(self, child)
+        child.to_dot(graph)
+      end
+    end
+    
+    def head_node? #:nodoc:
+      production.symbol.name == START_SYMBOL_NAME
+    end
+
+  end
+
+  # These are leaf nodes of syntax trees. They contain tokens.
+  class ParseTreeLeafNode 
+    attr_reader :token
+    
+    def initialize(token) #:nodoc:
+      @token = token
+    end
+    
+    def linearize #:nodoc:
+      []
+    end
+    
+    def tokens
+      [token]
+    end
+    
+    def to_s #:nodoc:
+      "LeafNode: #{token}"
+    end
+    
+    # Returns the dot representation of this node.
+    def to_dot(graph)
+      graph.node(self, :label => token)
+    end
+    
+    def head_node? #:nodoc:
+      false
+    end
+  end
+end