simply_stored 0.3.9 → 0.5.0

data/test/vendor/dhaka-2.2.1/lib/dhaka/dot/dot.rb

@@ -1,29 +0,0 @@
-module Dhaka
-  module Dot #:nodoc:
-    class Digraph #:nodoc:
-      def initialize(node_attributes = {})
-        @result = ["digraph x {"]
-        @result << %(node #{dotify_hash(node_attributes)})
-        yield(self)
-        @result << '}'
-      end
-
-      def node(obj, attributes = {})
-        @result << "#{obj.object_id} #{dotify_hash(attributes)}"
-      end
-
-      def edge(src, dest, attributes = {})
-        @result << "#{src.object_id} -> #{dest.object_id} #{dotify_hash(attributes)}"
-      end
-
-      def dotify_hash hash
-        sorted_key_value_pairs = hash.collect {|key, value| [key.to_s, value.to_s]}.sort
-        hash.empty? ? "" : '[' + sorted_key_value_pairs.collect {|key, value| "#{key}=#{value.to_s.inspect}"}.join(' ') + ']'
-      end
-
-      def to_dot
-        @result.join("\n")
-      end
-    end
-  end
-end

data/test/vendor/dhaka-2.2.1/lib/dhaka/evaluator/evaluator.rb

@@ -1,133 +0,0 @@
-module Dhaka
-  # Abstract base class for evaluators.
-  #
-  # Defining an evaluator is an easy way to perform syntax-directed evaluation without having to generate an abstract
-  # syntax tree representation of the input. 
-  #
-  # An evaluation rule for a given production named +bar+ is defined by calling +for_bar+ with
-  # a block that performs the evaluation. For detailed examples, see the evaluators in the 
-  # test suite.
-  # 
-  # The following is an evaluator for arithmetic expressions. When a parse tree node is encountered that
-  # corresponds to the production named +addition+, the block passed to +for_addition+ is invoked. The +evaluate+
-  # method is then recursively called on the child nodes, in this case the operands to the addition operation. The
-  # result is obtained by adding the evaluation results of the child nodes.
-  # 
-  #    class ArithmeticPrecedenceEvaluator < Dhaka::Evaluator
-  #
-  #      self.grammar = ArithmeticPrecedenceGrammar
-  #
-  #      define_evaluation_rules do
-  #
-  #        for_subtraction do 
-  #          evaluate(child_nodes[0]) - evaluate(child_nodes[2])
-  #        end
-  #
-  #        for_addition do
-  #          evaluate(child_nodes[0]) + evaluate(child_nodes[2])
-  #        end
-  #
-  #        for_division do
-  #          evaluate(child_nodes[0]).to_f/evaluate(child_nodes[2]) 
-  #        end
-  #
-  #        for_multiplication do
-  #          evaluate(child_nodes[0]) * evaluate(child_nodes[2])
-  #        end
-  #
-  #        for_literal do
-  #          child_nodes[0].token.value.to_i
-  #        end
-  #
-  #        for_parenthetized_expression do
-  #          evaluate(child_nodes[1])
-  #        end
-  #
-  #        for_negated_expression do
-  #          -evaluate(child_nodes[1])
-  #        end
-  #
-  #        for_power do
-  #          evaluate(child_nodes[0])**evaluate(child_nodes[2])
-  #        end
-  #
-  #      end
-  #
-  #    end
-
-  class Evaluator < SimpleDelegator
-    class << self
-      # Define evaluation rules within a block passed to this method. The evaluator will define
-      # default evaluation rules for pass-through productions (i.e. productions with expansions
-      # consisting of exactly one grammar symbol). The default evaluation rule for such productions
-      # is to simply return the result of calling +evaluate+ on the unique child node. Setting the
-      # <tt>:raise_error</tt> option to true tells the evaluator to throw an exception if you neglect
-      # to define a rule for a non-pass-through production (one where the expansion consists of
-      # multiple symbols), listing all the productions that absolutely need to be defined before you
-      # can continue.
-      def define_evaluation_rules(options = {})
-        yield
-        check_definitions(options)
-      end
-      
-      private
-
-      def check_definitions(options)
-        filter = lambda {|productions| productions.map {|production| production.name} - actions}
-        pass_through_productions_without_rules = filter[grammar.productions.select {|production| production.expansion.size == 1}]
-        pass_through_productions_without_rules.each do |rule_name|
-          send(:define_method, rule_name) do
-            evaluate(child_nodes.first)
-          end
-        end
-        non_trivial_productions_with_rules_undefined = filter[grammar.productions.select {|production| production.expansion.size != 1}]
-        raise EvaluatorDefinitionError.new(non_trivial_productions_with_rules_undefined) unless non_trivial_productions_with_rules_undefined.empty? || !options[:raise_error]
-      end
-
-      def inherited(evaluator)
-        class << evaluator
-          attr_accessor :grammar, :actions
-        end
-        evaluator.actions = []
-      end
-    
-      def method_missing(method_name, *args, &blk)
-        name = method_name.to_s
-        if name =~ /^for_(.+)$/
-          rule_name = $1
-          raise "Attempted to define evaluation rule for non-existent production '#{rule_name}'" unless grammar.production_named(rule_name)
-          actions   << rule_name
-          send(:define_method, rule_name, &blk)
-        else
-          super
-        end
-      end
-    end
-
-    # Evaluate a parse tree node.
-    def evaluate node
-      @node_stack ||= []
-      @node_stack << node
-      __setobj__(@node_stack.last)
-      result      = send(node.production.name)
-      @node_stack.pop
-      __setobj__(@node_stack.last)
-      result
-    end
-
-    def initialize
-      
-    end
-  end
-
-  class EvaluatorDefinitionError < StandardError #:nodoc:
-    def initialize(non_trivial_productions_with_rules_undefined)
-      @non_trivial_productions_with_rules_undefined = non_trivial_productions_with_rules_undefined
-    end
-  
-    def to_s
-      result = "The following non-trivial productions do not have any evaluation rules defined:\n" 
-      result << @non_trivial_productions_with_rules_undefined.join("\n")
-    end
-  end
-end

data/test/vendor/dhaka-2.2.1/lib/dhaka/grammar/closure_hash.rb

@@ -1,15 +0,0 @@
-module Dhaka
-  # A subclass of Hash with a dirty flag
-  class ClosureHash < Hash #:nodoc:
-    attr_accessor :dirty
-
-    def initialize
-      super
-      @dirty = false
-    end
-
-    def load_set(set)
-      set.each {|item| self[item] = item}
-    end
-  end
-end

data/test/vendor/dhaka-2.2.1/lib/dhaka/grammar/grammar.rb

@@ -1,240 +0,0 @@
-module Dhaka
-  
-  # Reserved name for the start symbol for all grammars. 
-  START_SYMBOL_NAME = "_Start_"
-  END_SYMBOL_NAME   = "_End_" #:nodoc:
-  
-  # Productions for specific grammar symbols are defined in the context of this class.
-  class ProductionBuilder
-    # +symbol+ is the grammar symbol that productions are being defined for.
-    def initialize(grammar, symbol)
-      @grammar = grammar
-      @symbol  = symbol
-    end
-  
-    def to_byte(char)
-      char.respond_to?(:bytes) ? char.bytes.first : char[0]
-    end
-  
-    # Creates a new production for +symbol+ with an expansion of +expansion+. The options hash can include
-    # a directive <tt>:prec</tt>, the value of which is a grammar symbol name. The precedence of the production is then
-    # set to the precedence of the grammar symbol corresponding to that name. 
-    #
-    # See the arithmetic precedence grammar in the test suites for an example.
-    def method_missing(production_name, expansion, options = {}, &blk)
-      expansion_symbols = Array(expansion).collect {|name| @grammar.symbols[name]}
-      production_args   = [@symbol, expansion_symbols, production_name.to_s, blk, @grammar.production_index]
-      if precedence_symbol_name = options[:prec] 
-        production_args << @grammar.symbol_for_name(precedence_symbol_name).precedence
-      end
-      
-      production = Production.new(*production_args)
-      @grammar.production_index += 1
-      
-      @symbol.nullable = true if expansion_symbols.empty?
-      @grammar.productions_by_symbol[production.symbol] << production
-      raise "Duplicate production named #{production.name}" if @grammar.productions_by_name[production.name]
-      @grammar.productions_by_name[production.name] = production
-    end
-  end
-
-  # The precedence builder defines three methods, +left+, +right+ and +nonassoc+. These accept arrays of grammar
-  # symbols all of which have the same precedence level and associativity.
-  #
-  # See the arithmetic precedence grammar in the test suites for an example of how this works.
-  class PrecedenceBuilder
-    def initialize(grammar) #:nodoc:
-      @grammar          = grammar
-      @precedence_level = 0
-    end
-    
-    [:left, :right, :nonassoc].each do |associativity| 
-      define_method(associativity) do |symbols|
-        assign_precedences associativity, symbols
-      end
-    end
-
-    private
-    def assign_precedences(associativity, symbol_names)
-      symbol_names.each do |symbol_name|
-        symbol            = @grammar.symbols[symbol_name]
-        symbol.precedence = Precedence.new(@precedence_level, associativity)
-      end
-      @precedence_level += 1
-    end
-  end
-
-  # Abstract base class for grammar specifications.
-  # 
-  # The following is a grammar specification for simple arithmetic. Precedences are specified as in Yacc -
-  # in ascending order of binding strength, with equal-strength symbols on the same level. 
-  # Production rules are specified for each symbol by specifying the name of the production (used when
-  # encoding the Evaluator) and the expansion for that particular production. For example, the production named 
-  # +addition+ expands the symbol <tt>'E'</tt> to the list of symbols <tt>['E', '+', 'E']</tt>.
-  #
-  #  class ArithmeticPrecedenceGrammar < Dhaka::Grammar
-  #    precedences do
-  #      left ['+', '-']
-  #      left ['*', '/']
-  #      nonassoc ['^']
-  #    end
-  #
-  #    for_symbol(Dhaka::START_SYMBOL_NAME) do
-  #      expression ['E']
-  #    end
-  #
-  #    for_symbol('E') do
-  #      addition ['E', '+', 'E']
-  #      subtraction ['E', '-', 'E']
-  #      multiplication ['E', '*', 'E']
-  #      division ['E', '/', 'E']
-  #      power ['E', '^', 'E']
-  #      literal ['n']
-  #      parenthetized_expression ['(', 'E', ')']
-  #      negated_expression ['-', 'E'], :prec => '*'
-  #    end
-  #  end
-  #
-  # In the above grammar, the symbols <tt>+</tt> and <tt>-</tt> are declared as being +left+-associative, meaning that 
-  # 1 + 2 + 3 is parsed as (1 + 2) + 3 as opposed to 1 + (2 + 3) (+right+-associativity). The symbol <tt>^</tt> is declared
-  # +nonassoc+ which means that expressions such as 2 ^ 3 ^ 4 are not allowed (non-associative). <tt>+</tt> and <tt>-</tt> are listed 
-  # before <tt>^</tt> which means that they bind lower, and an expression such as 2 + 3 ^ 5 will be always be parsed as
-  # 2 + (3 ^ 5) and not (2 + 3) ^ 5.
-  class Grammar
-    class << self
-      # Used for defining the Production-s for the symbol with name +symbol+. The block +blk+ is 
-      # evaluated in the context of a ProductionBuilder.
-      def for_symbol symbol, &blk
-        symbol              = symbols[symbol]
-        symbol.non_terminal = true
-        ProductionBuilder.new(self, symbol).instance_eval(&blk)
-      end
-
-      # Used for defining the precedences and associativities of symbols. The block +blk+ is
-      # evaluated in the context of a PrecedenceBuilder.
-      def precedences &blk
-        PrecedenceBuilder.new(self).instance_eval(&blk)
-      end
-
-      # Returns the grammar symbol identified by +name+
-      def symbol_for_name(name)
-        if symbols.has_key? name
-          symbols[name]
-        else
-          raise "No symbol with name #{name} found"
-        end
-      end
-      
-      # Returns a list of all the Production-s in this grammar.
-      def productions 
-        productions_by_name.values
-      end
-      
-      def productions_for_symbol(symbol) #:nodoc:
-        productions_by_symbol[symbol]
-      end
-      
-      def closure(kernel) #:nodoc:
-        channels = Hash.new {|hash, start_item| hash[start_item] = Set.new}
-        result = compute_closure(kernel) do |hash, item|    
-          if item.next_symbol and item.next_symbol.non_terminal
-            productions_by_symbol[item.next_symbol].each do |production|
-              new_channel = spontaneous_channel(item, hash[Item.new(production, 0)])
-              channels[item] << new_channel
-            end
-          end
-        end
-        [result, channels]
-      end
-      
-      def passive_channel(start_item, end_item) #:nodoc:
-        PassiveChannel.new(self, start_item, end_item)
-      end
-      
-      def first(given_symbol) #:nodoc:
-        cached_result = __first_cache[given_symbol] 
-        return cached_result if cached_result
-        result = compute_closure([given_symbol]) do |hash, symbol|
-              productions_by_symbol[symbol].each do |production| 
-                symbol_index = 0
-                while next_symbol = production.expansion[symbol_index]
-                  hash[next_symbol]
-                  break unless next_symbol.nullable
-                  symbol_index += 1
-                end
-              end if symbol.non_terminal
-          end.values.select {|symbol| symbol.terminal}.to_set
-        __first_cache[given_symbol] = result
-        result
-      end
-      
-      # Returns the Production identified by +name+.
-      def production_named(name)
-        productions_by_name[name]
-      end
-      
-      # Returns the set of terminal symbols in the grammar.
-      def terminal_symbols
-        symbols.values.select {|symbol| symbol.terminal}
-      end
-      
-      # Returns the set of non-terminal symbols in the grammar.
-      def non_terminal_symbols
-        symbols.values.select {|symbol| symbol.non_terminal}
-      end
-      
-      # Export the grammar to a BNF-like format
-      def to_bnf
-        result = []
-        last_symbol = nil
-        productions.sort.each do |production|
-          if production.symbol != last_symbol
-            result << ""
-            result << "#{production.symbol.name.inspect} :"
-            last_symbol = production.symbol
-          end
-          result << "  | #{production.expansion.collect{|symbol| symbol.name.inspect}.join(' ')}"
-        end
-        result.join("\n")
-      end
-      
-      private 
-      
-        def inherited(grammar)
-          class << grammar
-            attr_accessor :symbols, :productions_by_symbol, :productions_by_name, :start_symbol, :end_symbol, :__first_cache, :production_index
-          end
-          grammar.symbols               = Hash.new {|hash, name| hash[name] = GrammarSymbol.new(name)}
-          grammar.productions_by_symbol = Hash.new {|hash, name| hash[name] = Set.new([])}
-          grammar.productions_by_name   = {}
-          grammar.end_symbol            = grammar.symbols[END_SYMBOL_NAME]
-          grammar.start_symbol          = grammar.symbols[START_SYMBOL_NAME]
-          grammar.__first_cache         = {}
-          grammar.production_index      = 0
-        end
-  
-        def spontaneous_channel(start_item, end_item)
-          SpontaneousChannel.new(self, start_item, end_item)
-        end
-
-        def compute_closure(initial)
-          closure_hash = ClosureHash.new do |hash, item|
-            hash.dirty = true
-            hash[item] = item
-          end
-          
-          closure_hash.load_set(initial)
-          
-          loop do
-            closure_hash.keys.each do |element|
-              yield closure_hash, element
-            end
-            break unless closure_hash.dirty
-            closure_hash.dirty = false
-          end
-          closure_hash
-        end
-      end
-  end
-
-end

data/test/vendor/dhaka-2.2.1/lib/dhaka/grammar/grammar_symbol.rb

@@ -1,27 +0,0 @@
-module Dhaka
-  # Each grammar symbol is uniquely identified by a string name. The name of a symbol can 
-  # be anything (except the two reserved names <tt>'\_Start_'</tt> and <tt>'\_End_'</tt>) and need not 
-  # correspond to its character representation. For example, an ampersand in the input string could 
-  # be tokenized as a symbol with a name 'AND_OP'. You never have to directly instantiate a 
-  # GrammarSymbol. It is done implicitly for you when you define a Grammar.
-  class GrammarSymbol
-    attr_reader :name
-    attr_accessor :non_terminal, :nullable, :precedence, :associativity
-
-    def initialize(name)
-      @name = name
-    end
-
-    def terminal
-      !non_terminal
-    end
-
-    def to_s #:nodoc:
-      name.dup
-    end
-
-    def <=> other
-      name <=> other.name
-    end
-  end
-end

data/test/vendor/dhaka-2.2.1/lib/dhaka/grammar/precedence.rb

@@ -1,19 +0,0 @@
-module Dhaka
-  class Precedence #:nodoc:
-    include Comparable
-    attr_reader :precedence_level, :associativity
-    
-    def initialize(precedence_level, associativity)
-      @precedence_level = precedence_level
-      @associativity    = associativity
-    end
-    
-    def <=> other
-      precedence_level <=> other.precedence_level
-    end
-    
-    def to_s
-      "Precedence: #{precedence_level} Associativity: #{associativity}"
-    end
-  end
-end

data/test/vendor/dhaka-2.2.1/lib/dhaka/grammar/production.rb

@@ -1,36 +0,0 @@
-module Dhaka
-  class Production
-    include Comparable
-    
-    attr_reader :symbol, :expansion, :name, :action, :priority
-
-    def initialize(symbol, expansion, name, action, priority, precedence = nil)
-      @symbol     = symbol
-      @expansion  = expansion
-      @name       = name
-      @precedence = precedence
-      @action     = action || proc { self }
-      @priority   = priority
-    end
-
-    def precedence
-      unless @precedence
-        expansion.reverse_each do |symbol|
-          if symbol.terminal
-            @precedence = symbol.precedence
-            break
-          end
-        end 
-      end
-      @precedence
-    end
-
-    def to_s #:nodoc:
-      "#{name} #{symbol} ::= #{expansion.join(' ')}"
-    end
-
-    def <=> other
-      priority <=> other.priority
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-module Dhaka
-  module LexerSupport
-    class AcceptAction
-      attr_reader :pattern
-      def initialize(pattern)
-        @pattern = pattern
-      end
-
-      def call(lexer_run)
-        lexer_run.accept(pattern)
-      end
-
-      def compile_to_ruby_source
-        "accept(#{pattern.inspect})"
-      end
-      
-      def to_dot
-        "Accept #{pattern.inspect}"
-      end
-    end
-
-    class LookaheadAcceptAction < AcceptAction
-      def call(lexer_run)
-          lexer_run.accept_last_saved_checkpoint(pattern)
-      end
-
-      def compile_to_ruby_source
-        "accept_with_lookahead(#{pattern.inspect})"
-      end
-      
-      def to_dot
-        "Accept With Lookahead #{pattern.inspect}"
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module Dhaka
-  module LexerSupport
-    DIGITS                  = ('0'..'9').to_a
-    LOWERCASE_LETTERS       = ('a'..'z').to_a
-    UPPERCASE_LETTERS       = ('A'..'Z').to_a
-    LETTERS                 = LOWERCASE_LETTERS + UPPERCASE_LETTERS 
-    WHITESPACE              = [" ", "\r", "\n", "\t"]
-    SYMBOLS                 = %w| ~ ` ! @ # % & _ = : ; " ' < , > - |
-    CLASSES                 = {'d' => DIGITS, 'w' => LETTERS, 's' => WHITESPACE}
-                           
-    OPERATOR_CHARACTERS     = {'(' => 'open_parenth', ')' => 'close_parenth', '[' => 'open_square_bracket', 
-                              ']' => 'close_square_bracket', '+' => 'plus', '*' => 'asterisk', 
-                              '?' => 'question_mark', '.' => 'period', '\\' => 'back_slash', 
-                              '|' => 'pipe', '{' => 'left_curly_brace', '}' => 'right_curly_brace', 
-                              '/' => 'forward_slash', '^' => 'caret', '$' => 'dollar'}
-
-    SET_OPERATOR_CHARACTERS = %w| - ^ [ ] \\ |
-
-    ALL_CHARACTERS          = DIGITS + LETTERS + SYMBOLS + WHITESPACE + OPERATOR_CHARACTERS.keys
-  end
-end

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

@@ -1,46 +0,0 @@
-module Dhaka
-  # Abstract base class of all compiled Lexers. It is only used by generated code.
-  class CompiledLexer
-
-    class << self
-      # Returns a LexerRun that tokenizes +input+.
-      def lex input
-        LexerRun.new(self, input)
-      end
-
-      def start_state #:nodoc:
-        states[start_state_id]
-      end
-
-      def action_for_pattern pattern #:nodoc:
-        specification.items[pattern].action
-      end
-
-      private
-        def inherited(lexer)
-          class << lexer
-            attr_accessor :states, :specification, :start_state_id
-          end
-          lexer.states = Hash.new do |hash, state_id| 
-                           hash[state_id] = LexerSupport::State.new(lexer, nil)
-                         end
-        end
-
-        def at_state x, &blk
-          states[x].instance_eval(&blk)
-        end
-
-        def start_with start_state_id
-          self.start_state_id = start_state_id
-        end
-    
-        def switch_to dest_state_id
-          states[dest_state_id]
-        end
-    
-        def inspect
-          "<Dhaka::CompiledLexer specification : #{specification}>"
-        end
-    end
-  end
-end