RubyGems - simply_stored - Versions diffs - 0.1.4 - Mend

simply_stored 0.1.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (121) hide show

data/test/vendor/dhaka-2.2.1/test/core/lexer_test.rb ADDED Viewed

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+class TestLexer < Test::Unit::TestCase
+  class LexerSpec < Dhaka::LexerSpecification
+    for_pattern 'zz' do
+      "two zs"
+    end
+    for_pattern '\w(\w|\d)*' do
+      "word #{current_lexeme.value}"
+    end
+    # can optionally use Regexps as well
+    for_pattern(/(\d)*(\.\d+)?/) do
+      "number #{current_lexeme.value}"
+    end
+    for_pattern '<.*>' do
+      "tag #{current_lexeme.value}"
+    end
+    for_pattern ' +' do
+      #ignores whitespace
+    end
+    for_pattern "\n+" do
+      "newline"
+    end
+    for_pattern "\r+" do
+      "carriage return"
+    end
+  end
+  def test_lexer_with_valid_input
+    lexer = Dhaka::Lexer.new(LexerSpec)
+    eval(lexer.compile_to_ruby_source_as(:SomeLexer))
+    input = "these are words a z zz caPITALIZED word \r
+    this is a float 12.00 an integer 134 a float without a leading digit .2335 another word1"
+    results =  SomeLexer.lex(input).collect
+    assert_equal(
+    ["word these",
+     "word are",
+     "word words",
+     "word a",
+     "word z",
+     "two zs",
+     "word caPITALIZED",
+     "word word",
+     "carriage return",
+     "newline",
+     "word this",
+     "word is",
+     "word a",
+     "word float",
+     "number 12.00",
+     "word an",
+     "word integer",
+     "number 134",
+     "word a",
+     "word float",
+     "word without",
+     "word a",
+     "word leading",
+     "word digit",
+     "number .2335",
+     "word another",
+     "word word1"], results[0..-2])
+  end
+  def test_lexer_with_invalid_input
+    lexer = Dhaka::Lexer.new(LexerSpec)
+    result = lexer.lex("this will cause an error here 123.").each do |result|
+    end
+    assert(result.has_error?)
+    assert_equal(34, result.unexpected_char_index)
+  end
+  def test_lexer_with_greedy_character_consumption
+    lexer = Dhaka::Lexer.new(LexerSpec)
+    results = lexer.lex("<html></html>this is a word").collect
+    assert_equal(["tag <html></html>",
+     "word this",
+     "word is",
+     "word a",
+     "word word"], results[0..-2])
+  end
+  class LexerWithLookaheadsSpec < Dhaka::LexerSpecification
+    for_pattern '\s+' do
+      # ignore whitespace
+    end
+    for_pattern ':/\w+' do
+      "a symbol qualifier"
+    end
+    for_pattern(":/[^a-zA-Z \n\r\t]*") do
+      "a colon"
+    end
+    for_pattern "ab/cd" do
+      "ab followed by cd: #{current_lexeme.value}"
+    end
+    for_pattern "abc/e" do
+      "abc followed by e: #{current_lexeme.value}"
+    end
+    for_pattern '\w+' do
+      "word #{current_lexeme.value}"
+    end
+    for_pattern '\d+' do
+      "number #{current_lexeme.value}"
+    end
+  end
+  def test_lexer_with_regexes_that_use_lookaheads
+    lexer = Dhaka::Lexer.new(LexerWithLookaheadsSpec)
+    eval(lexer.compile_to_ruby_source_as(:LexerWithTrickyLookaheads))
+    results = LexerWithTrickyLookaheads.lex("234 : :whatever :1934 abcd ::").collect
+    assert_equal(["number 234",
+     "a colon",
+     "a symbol qualifier",
+     "word whatever",
+     "a colon",
+     "number 1934",
+     "ab followed by cd: ab",
+     "word cd",
+     "a colon",
+     "a colon"], results[0..-2])
+  end
+end

data/test/vendor/dhaka-2.2.1/test/core/malformed_grammar.rb ADDED Viewed

@@ -0,0 +1,7 @@
+class MalformedGrammar < Dhaka::Grammar
+  for_symbol('foo') do
+    bar %w| baz |
+  end
+end

data/test/vendor/dhaka-2.2.1/test/core/malformed_grammar_test.rb ADDED Viewed

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + "/malformed_grammar"
+class TestMalformedGrammar < Test::Unit::TestCase
+  def test_must_have_a_start_symbol_in_order_to_generate_a_parser
+    assert_raises(Dhaka::NoStartProductionsError) {Dhaka::Parser.new(MalformedGrammar)}
+  end
+end

data/test/vendor/dhaka-2.2.1/test/core/nullable_grammar.rb ADDED Viewed

@@ -0,0 +1,21 @@
+class NullableGrammar < Dhaka::Grammar
+  for_symbol(Dhaka::START_SYMBOL_NAME) do
+    tuple                     %w| Tuple |
+  end
+  for_symbol('Tuple') do
+    element_list              %w| ( Elements ) |
+  end
+  for_symbol('Elements') do
+    empty_element_list        %w| |
+    concatenate_element_lists %w| Character Elements |
+  end
+  for_symbol('Character') do
+    literal_a                 %w| a |
+    literal_b                 %w| b |
+  end
+end

data/test/vendor/dhaka-2.2.1/test/core/parse_result_test.rb ADDED Viewed

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + '/simple_grammar'
+class TestParseSuccessResult < Test::Unit::TestCase
+  include Dhaka
+  def composite_node(production, child_nodes, dot_name)
+    node = ParseTreeCompositeNode.new(SimpleGrammar.production_named(production))
+    node.child_nodes.concat child_nodes
+    node.stubs(:object_id).returns(dot_name)
+    node
+  end
+  def leaf_node(token, value, dot_name)
+    node = ParseTreeLeafNode.new(Token.new(token, value, nil))
+    node.stubs(:object_id).returns(dot_name)
+    node
+  end
+  def test_parse_tree_can_be_exported_to_dot_format
+    first_term    = composite_node('literal', [leaf_node('n', 1, "literal_1")], "first_term")
+    second_term   = composite_node('literal', [leaf_node('n', 2, "literal_2")], "second_term")
+    addition_term = leaf_node('-', nil, "subtraction_operator")
+    tree          = composite_node('subtraction', [first_term, addition_term, second_term], "expression")
+    result        = ParseSuccessResult.new(tree)
+    assert_equal(
+%(digraph x {
+node [fontsize="10" shape="box" size="5"]
+expression [label="subtraction E ::= E - T"]
+expression -> first_term
+first_term [label="literal T ::= n"]
+first_term -> literal_1
+literal_1 [label="n : 1"]
+expression -> subtraction_operator
+subtraction_operator [label="-"]
+expression -> second_term
+second_term [label="literal T ::= n"]
+second_term -> literal_2
+literal_2 [label="n : 2"]
+}),
+    result.to_dot)
+  end
+end

data/test/vendor/dhaka-2.2.1/test/core/parser_state_test.rb ADDED Viewed

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+class TestParserState < Test::Unit::TestCase
+  include Dhaka
+  def test_unique_identifier
+    states = (0...5).collect {|i| ParserState.new(nil, {})}
+    ids = Set.new
+    states.each do |state|
+      assert(/^State(\d+)$/ =~ state.unique_name)
+      ids << $1.to_i
+    end
+    assert_equal(5, ids.size)
+  end
+  def test_to_s_method
+    options = {:some_option => true}
+    item1 = mock()
+    item1.stubs(:to_s).with(options).returns("i'm item 1")
+    item2 = mock()
+    item2.stubs(:to_s).with(options).returns("i'm item 2")
+    state = ParserState.new(nil, {item1 => item1, item2 => item2})
+    assert_equal(["i'm item 1", "i'm item 2"], state.to_s(options).split("\n").sort)
+  end
+end

data/test/vendor/dhaka-2.2.1/test/core/parser_test.rb ADDED Viewed

@@ -0,0 +1,131 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + '/simple_grammar'
+require File.dirname(__FILE__) + '/nullable_grammar'
+require File.dirname(__FILE__) + '/lalr_but_not_slr_grammar'
+require File.dirname(__FILE__) + '/another_lalr_but_not_slr_grammar'
+require File.dirname(__FILE__) + '/rr_conflict_grammar'
+require File.dirname(__FILE__) + '/sr_conflict_grammar'
+class ParserTest < Test::Unit::TestCase
+  def build_tokens(token_symbol_names)
+    token_symbol_names.collect {|symbol_name| Dhaka::Token.new(symbol_name, nil, nil)}
+  end
+  def setup
+    @grammar = SimpleGrammar
+    @parser = Dhaka::Parser.new(@grammar)
+  end
+  def contains(given_member, set)
+    set.inject(false) {|result, member| result ||= (Set.new(member) == Set.new(given_member))}
+  end
+  def assert_collection_equal(expected, actual)
+    assert_equal(expected.size, actual.size)
+    actual.each do |actual_member|
+      assert(contains(actual_member, expected), "Should have found #{actual_member} in expected set.")
+    end
+  end
+  def test_parser_generates_states_with_correct_items
+    expected_states = [
+                       ['_Start_ ::= -> S # [_End_]',
+                          'S ::= -> E [#]',
+                          'E ::= -> E - T [#-]',
+                          'E ::= -> T [#-]',
+                          'T ::= -> n [#-]',
+                          'T ::= -> ( E ) [#-]'],
+                       ['E ::= T -> [#)-]'],
+                       ['T ::= n -> [#)-]'],
+                       ['S ::= E -> [#]',
+                          'E ::= E -> - T [#-]'],
+                       ['_Start_ ::= S -> # [_End_]'],
+                       ['T ::= ( -> E ) [#)-]',
+                          'E ::= -> E - T [)-]',
+                          'E ::= -> T [)-]',
+                          'T ::= -> n [)-]',
+                          'T ::= -> ( E ) [)-]'],
+                       ['E ::= E - -> T [#)-]',
+                          'T ::= -> n [#)-]',
+                          'T ::= -> ( E ) [#)-]'],
+                       ['E ::= E - T -> [#)-]'],
+                       ['T ::= ( E -> ) [#)-]',
+                          'E ::= E -> - T [)-]'],
+                       ['T ::= ( E ) -> [#)-]'],
+                       ['_Start_ ::= S # -> [_End_]']]
+    actual_states = @parser.send('states').collect {|state| state.items.values.collect {|item| item.to_s}}
+    assert_collection_equal(expected_states, actual_states)
+  end
+  def test_parser_can_be_exported_to_dot_format
+    dot_representation = @parser.to_dot
+  end
+  def test_parser_generates_parse_tree_given_a_stream_of_symbols
+    parse_tree = @parser.parse(build_tokens(['(','n','-','(','n','-','n',')',')','-','n','#', Dhaka::END_SYMBOL_NAME]))
+    assert_equal \
+      ["literal",
+       "term",
+       "literal",
+       "term",
+       "literal",
+       "subtraction",
+       "parenthetized_expression",
+       "subtraction",
+       "parenthetized_expression",
+       "term",
+       "literal",
+       "subtraction",
+       "expression",
+       "start"], parse_tree.linearize.collect {|node| node.production.name}
+  end
+  def get_linearized_parse_result(input, parser)
+    parser.parse(build_tokens(input)).parse_tree.linearize.collect {|node| node.production.name}
+  end
+  def test_with_a_grammar_with_nullables_after_terminals
+    grammar      = NullableGrammar
+    parser       = Dhaka::Parser.new(grammar)
+    parser_input = ['(','a',')', Dhaka::END_SYMBOL_NAME]
+    assert_equal \
+      ["literal_a",
+       "empty_element_list",
+       "concatenate_element_lists",
+       "element_list",
+       "tuple"], get_linearized_parse_result(parser_input, parser)
+  end
+  def test_with_a_grammar_that_is_not_SLR
+    grammar      = LALRButNotSLRGrammar
+    parser       = Dhaka::Parser.new(grammar)
+    parser_input = ['b','d','c', Dhaka::END_SYMBOL_NAME]
+    assert_equal(["A_d", "E_bAc", "start"], get_linearized_parse_result(parser_input, parser))
+  end
+  def test_with_another_grammar_that_is_not_SLR
+    grammar      = AnotherLALRButNotSLRGrammar
+    parser       = Dhaka::Parser.new(grammar)
+    parser_input = ['*', 'id', '=', 'id', Dhaka::END_SYMBOL_NAME]
+    assert_equal(["identifier", "l_value", "contents", "identifier", "l_value", "assignment"], get_linearized_parse_result(parser_input, parser))
+  end
+  def test_debug_output_with_a_grammar_that_should_generate_an_RR_conflict
+    fake_logger = FakeLogger.new
+    Dhaka::ParserState.any_instance.stubs(:unique_name).returns("StateXXX")
+    parser = Dhaka::Parser.new(RRConflictGrammar, fake_logger)
+    num_states = parser.send(:states).size
+    assert_equal(['Created StateXXX.'] * num_states, fake_logger.debugs[0...num_states])
+    assert_equal(1, fake_logger.errors.size)
+    assert(fake_logger.errors.first.match(/^Parser Conflict at State:\n(.+)\n(.+)\nExisting: (.+)\nNew: (.+)\nLookahead: (.+)$/))
+    assert_equal(["A ::= x y ->", "B ::= x y ->", "Reduce with xy A ::= x y", "Reduce with xy_again B ::= x y", "c"],
+        $~[1..5].sort)
+  end
+  def write_parser(parser)
+    File.open('parser.dot', 'w') do |file|
+      file << parser.to_dot
+    end
+  end
+end

data/test/vendor/dhaka-2.2.1/test/core/precedence_grammar.rb ADDED Viewed

@@ -0,0 +1,17 @@
+class PrecedenceGrammar < Dhaka::Grammar
+  precedences do
+    left       %w| * |
+  end
+  for_symbol(Dhaka::START_SYMBOL_NAME) do
+    expression %w| E * F |
+    whatever   %w| E F |, :prec => '*'
+  end
+  for_symbol('F') do
+    something  %w| foo |
+  end
+end

data/test/vendor/dhaka-2.2.1/test/core/precedence_grammar_test.rb ADDED Viewed

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + "/precedence_grammar"
+class TestPrecedenceGrammar < Test::Unit::TestCase
+  def test_precedences_are_computed_correctly
+    assert_equal(:left, PrecedenceGrammar.production_named('expression').precedence.associativity)
+    assert_equal(:left, PrecedenceGrammar.production_named('whatever').precedence.associativity)
+  end
+end

data/test/vendor/dhaka-2.2.1/test/core/rr_conflict_grammar.rb ADDED Viewed

@@ -0,0 +1,21 @@
+class RRConflictGrammar < Dhaka::Grammar
+  for_symbol(Dhaka::START_SYMBOL_NAME) do
+    start       %w| S |
+  end
+  for_symbol('S') do
+    a_expansion %w| A c d |
+    b_expansion %w| B c e |
+  end
+  for_symbol('A') do
+    xy          %w| x y |
+  end
+  for_symbol('B') do
+    xy_again    %w| x y |
+  end
+end

data/test/vendor/dhaka-2.2.1/test/core/simple_grammar.rb ADDED Viewed

@@ -0,0 +1,22 @@
+class SimpleGrammar < Dhaka::Grammar
+  for_symbol(Dhaka::START_SYMBOL_NAME) do
+    start                    %w| S # |
+  end
+  for_symbol('S') do
+    expression               %w| E |
+  end
+  for_symbol('E') do
+    subtraction              %w| E - T |
+    term                     %w| T |
+  end
+  for_symbol('T') do
+    literal                  %w| n |
+    parenthetized_expression %w| ( E ) |
+  end
+end

data/test/vendor/dhaka-2.2.1/test/core/sr_conflict_grammar.rb ADDED Viewed

@@ -0,0 +1,16 @@
+class SRConflictGrammar < Dhaka::Grammar
+  for_symbol(Dhaka::START_SYMBOL_NAME) do
+    statement              %w| statement |
+  end
+  for_symbol('statement') do
+    if_statement           %w| if_statement |
+  end
+  for_symbol('if_statement') do
+    if_then_statement      %w| IF expr THEN statement |
+    if_then_else_statement %w| IF expr THEN statement ELSE statement END |
+  end
+end

data/test/vendor/dhaka-2.2.1/test/dhaka_test_helper.rb ADDED Viewed

@@ -0,0 +1,17 @@
+unless defined? Dhaka
+  require File.dirname(__FILE__) + '/../lib/dhaka'
+end
+require File.dirname(__FILE__) + '/fake_logger'
+require 'test/unit'
+begin
+  require 'mocha'
+rescue LoadError
+  puts "
+  The tests depend on Mocha. Please install it if you wish to run them:
+    sudo gem install mocha
+  This gem is not required for using the library."
+  exit
+end

data/test/vendor/dhaka-2.2.1/test/fake_logger.rb ADDED Viewed

@@ -0,0 +1,17 @@
+class FakeLogger
+  attr_reader :warnings, :debugs, :errors
+  def initialize
+    @warnings = []
+    @debugs = []
+    @errors = []
+  end
+  def debug message
+    @debugs << message
+  end
+  def error message
+    @errors << message
+  end
+  def warn message
+    @warnings << message
+  end
+end

data/test/vendor/simplerdb-0.2/lib/simplerdb/client_exception.rb ADDED Viewed

@@ -0,0 +1,10 @@
+# Exceptions that are caused by an invalid request from the client.
+class ClientException < Exception
+  attr_accessor :code, :msg
+  def initialize(code, msg)
+    @code = code
+    @msg = msg
+  end
+end

data/test/vendor/simplerdb-0.2/lib/simplerdb/db.rb ADDED Viewed

@@ -0,0 +1,146 @@
+require 'singleton'
+require 'simplerdb/query_language'
+module SimplerDB
+  class Domain
+    attr_accessor :name, :items
+    def initialize(name)
+      @name = name
+      @items = Hash.new { |hash, key| hash[key] = Item.new(key) }
+    end
+  end
+  class Item
+    attr_accessor :name, :attributes
+    def initialize(name)
+      @name = name
+      @attributes = Hash.new { |hash, key| hash[key] = [] }
+    end
+    def put_attribute(attr, replace = false)
+      @attributes[attr.name].clear if replace
+      @attributes[attr.name] << attr
+    end
+    def delete_attribute(attr)
+      if attr.value.nil?
+        @attributes[attr.name].clear
+      else
+        @attributes[attr.name].delete(attr)
+      end
+      if @attributes[attr.name].size == 0
+        @attributes.delete(attr.name)
+      end
+    end
+    def get_attributes(attribute_name = nil)
+      attrs = []
+      @attributes.each do |key, value|
+        if (attribute_name.nil? || attribute_name == key)
+          attrs += value
+        end
+      end
+      return attrs
+    end
+  end
+  class Attribute
+    attr_accessor :name, :value
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+    def ==(other)
+      @name == other.name && @value == other.value
+    end
+  end
+  class AttributeParam < Attribute
+    attr_accessor :replace
+    def initialize(name, value, replace = false)
+      super(name, value)
+      @replace = replace
+    end
+    def to_attr
+      Attribute.new(self.name, self.value)
+    end
+  end
+  # The main SimplerDB class, containing methods that correspond to the
+  # AWS API.
+  class DB
+    include Singleton
+    def initialize
+      reset
+    end
+    # For testing
+    def reset
+      @domains = {}
+      @query_executor = QueryExecutor.new
+    end
+    def create_domain(name)
+      @domains[name] ||= Domain.new(name)
+    end
+    def delete_domain(name)
+      @domains.delete(name)
+    end
+    def list_domains(max = 100, token = 0)
+      doms = []
+      count = 0
+      token = 0 unless token
+      @domains.keys.each do |domain|
+        break if doms.size == max
+        doms << domain if count >= token.to_i
+        count += 1
+      end
+      if (count >= @domains.size)
+        return doms,nil
+      else
+        return doms,count
+      end
+    end
+    def get_attributes(domain_name, item_name, attribute_name = nil)
+      domain = @domains[domain_name]
+      item = domain.items[item_name]
+      return item.get_attributes(attribute_name)
+    end
+    def put_attributes(domain_name, item_name, attribute_params)
+      domain = @domains[domain_name]
+      item = domain.items[item_name]
+      attribute_params.each { |attr| item.put_attribute(attr.to_attr, attr.replace) }
+    end
+    def delete_attributes(domain_name, item_name, attributes)
+      domain = @domains[domain_name]
+      item = domain.items[item_name]
+      if attributes.empty?
+        domain.items.delete(item_name)
+      else
+        attributes.each { |attr| item.delete_attribute(attr) }
+      end
+    end
+    def query(domain, query, max = 100, token = 0)
+      @query_executor.do_query(query, @domains[domain], max, token)
+    end
+  end
+end