simply_stored 0.3.9 → 0.5.0

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

@@ -1,14 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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