RubyGems - simply_stored - Versions diffs - 0.3.9 → 0.5.0 - Mend

simply_stored 0.3.9 → 0.5.0

Files changed (132) hide show

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

@@ -1,139 +0,0 @@
-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 DELETED Viewed

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

@@ -1,8 +0,0 @@
-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 DELETED Viewed

@@ -1,21 +0,0 @@
-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 DELETED Viewed

@@ -1,44 +0,0 @@
-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 DELETED Viewed

@@ -1,24 +0,0 @@
-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 DELETED Viewed

@@ -1,131 +0,0 @@
-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 DELETED Viewed

@@ -1,17 +0,0 @@
-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 DELETED Viewed

@@ -1,9 +0,0 @@
-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 DELETED Viewed

@@ -1,21 +0,0 @@
-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 DELETED Viewed

@@ -1,22 +0,0 @@
-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 DELETED Viewed

@@ -1,16 +0,0 @@
-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 DELETED Viewed

@@ -1,17 +0,0 @@
-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 DELETED Viewed

@@ -1,17 +0,0 @@
-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 DELETED Viewed

@@ -1,10 +0,0 @@
-# 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 DELETED Viewed

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