simplerdb 0.1

data/History.txt

@@ -0,0 +1,3 @@
+== 0.1
+
+* Initial release

data/Manifest.txt

@@ -0,0 +1,16 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/simplerdb
+lib/simplerdb.rb
+lib/simplerdb/Rakefile
+lib/simplerdb/client_exception.rb
+lib/simplerdb/db.rb
+lib/simplerdb/query_language.rb
+lib/simplerdb/servlet.rb
+lib/simplerdb/server.rb
+test/query_evaluator_test.rb
+test/query_parser_test.rb
+test/simplerdb_test.rb
+test/functional_test.rb

data/README.txt

@@ -0,0 +1,60 @@
+<b>simplerdb</b>
+    by Gary Elliott (gary@tourb.us)
+    http://simplerdb.rubyforge.org
+
+== DESCRIPTION:
+  
+SimplerDB is an in-memory implementation of Amazon's SimpleDB REST API.
+You can use it to test your application offline (for free!) or experiment with SimpleDB
+without a beta account.
+
+== FEATURES:
+  
+* Implements the current SimpleDB API specification as defined by http://docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide.
+* Start/stop a server from within your ruby unit tests
+* Run a standalone server for use by any SimpleDB client
+
+== SYNOPSIS:
+
+In order to use SimplerDB, you will need to replace Amazon's service url (http://sds.amazonaws.com)
+with http://localhost:8087 in your client. RightAWS[http://rightaws.rubyforge.org/right_aws_gem_doc]
+is the only ruby client I'm aware of that lets you do this.
+
+To write a ruby-based unit test using SimplerDB, you can use the following setup/teardown methods to
+start and stop the server for each test.
+
+  def setup
+    @server = SimplerDB::Server.new(8087)
+    @thread = Thread.new { @server.start }
+  end
+  
+  def teardown
+    @server.shutdown
+    @thread.join
+  end
+
+You will need to configure your SimpleDB client to point to http://localhost:8087 for the test,
+but otherwise your code will work just as if it was accessing Amazon's live web service.
+
+For a more complete example of a functional test using RightAWS take a look at
+http://simplerdb.rubyforge.org/svn/trunk/test/functional_test.rb
+
+Installed with the gem is the <tt>simplerdb</tt> command, which starts a standalone SimplerDB server.
+The optional command-line argument allows you to set HTTP port (8087 by default).
+
+== REQUIREMENTS:
+
+* Dhaka[http://dhaka.rubyforge.org]
+* Builder[http://builder.rubyforge.org]
+
+All dependencies should be installed automatically during the SimplerDB gem installation.
+
+== INSTALL:
+
+* <tt>sudo gem install simplerdb</tt>
+
+== CAVEATS:
+
+* Since I don't have a SimplerDB beta account this software has not been tested in comparsion to the live web service and the behavior might differ. If you discover such a scenario please report it as a bug.
+* SimplerDB has only been tested with ruby SimpleDB clients. 
+* Query performance with large numbers of items (more than 1000) in a domain could be poor. 

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rake'
+require 'rake/testtask'
+require 'rubygems'
+require 'hoe'
+require './lib/simplerdb.rb'
+
+  
+task :default => [:test]
+
+Hoe.new('simplerdb', SimplerDB::VERSION) do |p|
+  p.rubyforge_name = 'simplerdb'
+  p.author = 'Gary Elliott'
+  p.email = 'gary@tourb.us'
+  p.summary = "Test your SimpleDB application offline"
+  p.description = p.summary
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.remote_rdoc_dir = '' # Release to root
+  p.version = SimplerDB::VERSION
+  p.extra_deps = []
+  p.extra_deps << ['dhaka', '>= 2.2.1']
+  p.extra_deps << ['builder', '>= 2.0']
+end
+
+
+Rake::TestTask.new do |t|
+  t.libs << "lib"
+  t.test_files = FileList['test/*test.rb']
+  t.verbose = true
+end

data/bin/simplerdb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'simplerdb/server'
+
+port = ARGV.size > 0 ? ARGV[0] : nil
+
+SimplerDB::Server.new(port).start

data/lib/simplerdb/Rakefile

@@ -0,0 +1,14 @@
+require 'rake'
+require 'rake/testtask'
+  
+task :default => [:gen]
+
+task :gen do
+  require 'query_grammar'
+
+  parser = Dhaka::Parser.new(QueryGrammar)
+  File.open('query_parser.rb', 'w') { |file| file << parser.compile_to_ruby_source_as(:QueryParser) }
+  
+  lexer = Dhaka::Lexer.new(QueryLexerSpec)
+  File.open('query_lexer.rb', 'w') {|file| file << lexer.compile_to_ruby_source_as(:QueryLexer)}
+end

data/lib/simplerdb/client_exception.rb

@@ -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/lib/simplerdb/db.rb

@@ -0,0 +1,142 @@
+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]
+      attributes.each { |attr| item.delete_attribute(attr) } 
+    end
+    
+    def query(domain, query, max = 100, token = 0)
+      @query_executor.do_query(query, @domains[domain], max, token)
+    end
+  end
+  
+end

data/lib/simplerdb/query_language.rb

@@ -0,0 +1,266 @@
+require 'rubygems'
+require 'dhaka'
+require 'set'
+
+module SimplerDB
+  # Uses the lexer/parser/evaluator to perform the query and do simple paging
+  class QueryExecutor
+    ERROR_MARKER = ">>>"
+  
+    def initialize
+      @lexer = Dhaka::Lexer.new(QueryLexerSpec)
+      @parser = Dhaka::Parser.new(QueryGrammar)
+    end
+    
+    # Execute the query
+    def do_query(query, domain, max = 100, token = 0)
+      parse_result = @parser.parse(@lexer.lex(query))
+      token = 0 if token.nil?
+      
+      case parse_result
+        when Dhaka::TokenizerErrorResult
+          raise tokenize_error_message(parse_result.unexpected_char_index, query)
+        when Dhaka::ParseErrorResult
+          raise parse_error_message(parse_result.unexpected_token, query) 
+      end
+  
+      items = QueryEvaluator.new(domain).evaluate(parse_result)
+      results = []
+      count = 0
+      items.each do |item|
+        break if results.size == max
+        results << item if count >= token
+        count += 1
+      end
+      
+      if (count == items.size)
+        return results,nil
+      else
+        return results,count
+      end
+    end
+    
+    # From dhaka examples
+    def parse_error_message(unexpected_token, program)
+      if unexpected_token.symbol_name == Dhaka::END_SYMBOL_NAME
+        "Unexpected end of file."
+      else
+        "Unexpected token #{unexpected_token.symbol_name}:\n#{program.dup.insert(unexpected_token.input_position - 1, ERROR_MARKER)}"
+      end
+    end
+    
+    def tokenize_error_message(unexpected_char_index, program)
+      "Unexpected character #{program[unexpected_char_index - 1].chr}:\n#{program.dup.insert(unexpected_char_index - 1, ERROR_MARKER)}"
+    end
+    
+    def evaluation_error_message(evaluation_result, program)
+      "#{evaluation_result.exception}:\n#{program.dup.insert(evaluation_result.node.tokens[0].input_position, ERROR_MARKER)}"
+    end
+  
+  end
+  
+  # The SimpleDB query language grammar, as defined at
+  # http://docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/SDB_API_Query.html
+  class QueryGrammar < Dhaka::Grammar
+    for_symbol(Dhaka::START_SYMBOL_NAME) do
+      start                %w| predicates |
+    end
+  
+    for_symbol('predicates') do
+      single_predicate     %w| predicate |
+      not_predicate        %w| not predicate |
+      intersection         %w| predicate intersection predicates |
+      not_intersection     %w| not predicate intersection predicates |
+      union                %w| predicate union predicates |
+      not_union            %w| not predicate union predicates |
+    end
+    
+    for_symbol('predicate') do
+      attribute_comparison %w| [ attribute_comparison ] |
+    end
+    
+    for_symbol('attribute_comparison') do
+      single_comparison    %w| identifier comp_op constant |
+      not_comparison       %w| not identifier comp_op constant |
+      and_comparison       %w| identifier comp_op constant and attribute_comparison |
+      not_and_comparison   %w| not identifier comp_op constant and attribute_comparison |
+      or_comparison        %w| identifier comp_op constant or attribute_comparison |
+      not_or_comparison    %w| not identifier comp_op constant or attribute_comparison |
+    end
+    
+    for_symbol('comp_op') do
+      equal                %w| = |
+      greater_than         %w| > |
+      less_than            %w| < |
+      greater_or_equal     %w| >= |
+      less_or_equal        %w| <= |
+      not_equal            %w| != |
+      starts_with          %w| starts-with |
+    end
+    
+    for_symbol('identifier') do
+      identifier           %w| quoted_string |
+    end
+    
+    for_symbol('constant') do
+      constant            %w| quoted_string |
+    end
+  
+  end
+  
+  # The lexer for the query language.
+  class QueryLexerSpec < Dhaka::LexerSpecification
+    
+    %w| = > < >= <= != starts-with |.each do |op|
+      for_pattern(op) do
+        create_token(op)
+      end
+    end
+    
+    for_pattern('\[') do
+      create_token('[')
+    end
+    
+    for_pattern('\]') do
+      create_token(']')
+    end
+    
+    for_pattern('\s+') do
+      # ignore whitespace
+    end
+    
+    KEYWORDS = %w| not and or union intersection |
+    KEYWORDS.each do |keyword|
+      for_pattern(keyword) do
+        create_token(keyword)
+      end
+    end
+    
+    for_pattern("'(\\\\'|[^'])+'") do
+      create_token 'quoted_string'
+    end
+    
+  end
+  
+  # The query evaluator. This class acts on the parse tree and will return
+  # a list of item names that match the query from the evaluate method.
+  class QueryEvaluator < Dhaka::Evaluator
+    self.grammar = QueryGrammar
+    
+    def initialize(domain = nil)
+      @domain = domain
+      @predicate_identifier = nil
+      @all_items = nil
+    end
+    
+    define_evaluation_rules do
+     
+      for_single_predicate do
+        evaluate(child_nodes[0])
+      end
+      
+      for_not_predicate do
+        results = evaluate(child_nodes[1])
+        all_items.difference(results)
+      end
+      
+      for_intersection do
+        results = evaluate(child_nodes[0])
+        results.intersection(evaluate(child_nodes[2]))
+      end
+      
+      # TODO Nots are probably not handled correctly. Need to play with AWS to find out for sure.
+      for_not_intersection do
+        results = evaluate(child_nodes[1])
+        all_items.difference(results.intersection(evaluate(child_nodes[3])))
+      end
+      
+      for_union do
+        results = evaluate(child_nodes[0])
+        results.union(evaluate(child_nodes[2]))
+      end
+      
+      for_not_union do
+        results = evaluate(child_nodes[1])
+        all_items.difference(results.union(evaluate(child_nodes[3])))
+      end
+      
+      for_attribute_comparison do
+        evaluate(child_nodes[1])
+      end
+      
+      for_single_comparison do
+        do_comparison(evaluate(child_nodes[0]), evaluate(child_nodes[1]), evaluate(child_nodes[2]))
+      end
+      
+      for_not_comparison do
+        do_comparison(evaluate(child_nodes[1]), evaluate(child_nodes[2]), evaluate(child_nodes[3]), true)
+      end
+      
+      for_and_comparison do
+        results = do_comparison(evaluate(child_nodes[0]), evaluate(child_nodes[1]), evaluate(child_nodes[2]))
+        results.intersection(evaluate(child_nodes[4]))
+      end
+      
+      for_not_and_comparison do
+        results = do_comparison(evaluate(child_nodes[1]), evaluate(child_nodes[2]), evaluate(child_nodes[3]), true)
+        results.intersection(evaluate(child_nodes[5]))
+      end
+      
+      for_or_comparison do
+        results = do_comparison(evaluate(child_nodes[0]), evaluate(child_nodes[1]), evaluate(child_nodes[2]))
+        results.union(evaluate(child_nodes[4]))
+      end
+      
+      for_not_or_comparison do
+        results = do_comparison(evaluate(child_nodes[1]), evaluate(child_nodes[2]), evaluate(child_nodes[3]), true)
+        results.union(evaluate(child_nodes[5]))
+      end
+      
+      for_equal { lambda { |v1, v2| v1 == v2 } }
+      for_greater_than { lambda { |v1, v2| v1 > v2 } }
+      for_less_than { lambda { |v1, v2| v1 < v2 } }
+      for_greater_or_equal { lambda { |v1, v2| v1 >= v2 } }
+      for_less_or_equal { lambda { |v1, v2| v1 <= v2 } }
+      # TODO ['a1' != 'v2'] should return false if a1 has values v1 AND v2
+      for_not_equal { lambda { |v1, v2| v1 != v2 } }
+      for_starts_with { lambda { |v1, v2| v2[0...v1.length] == v1 } }
+      
+      for_identifier { val(child_nodes[0]) }
+      for_constant { val(child_nodes[0]) }
+    end
+  
+    def val(node)
+      node.token.value.to_s[1..-2]
+    end
+  
+    def all_items
+      unless @all_items
+        @all_items = @domain.items.collect { |k,v| k }.to_set
+      end
+      
+      return @all_items
+    end
+  
+    # Apply the given comparison params to every item in the domain
+    def do_comparison(identifier, op, constant, negate = false)  
+      results = Set.new
+      
+      if @domain
+        @domain.items.each_value do |item|
+          attrs = item.attributes[identifier]
+          
+          attrs.each do |attr|
+            match = op.call(constant, attr.value)
+            if (match && !negate) || (negate && !match)
+              results << item
+              break
+            end
+          end
+        end
+      end
+      
+      results
+    end
+  end
+end

data/lib/simplerdb/server.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'simplerdb/servlet'
+require 'webrick'
+
+# Runs the SimplerDB server
+module SimplerDB
+  class Server
+    
+    # Create the server running on the given port
+    def initialize(port = nil)
+      @port = port || 8087
+    end
+    
+    # Run the server on the configured port.
+    def start
+      config = { :Port => @port }
+      @server = WEBrick::HTTPServer.new(config)
+      @server.mount("/", SimplerDB::RESTServlet)
+      
+      ['INT', 'TERM'].each do |signal| 
+        trap(signal) { @server.shutdown }
+      end
+      
+      @server.start
+    end
+  
+    # Shut down the server
+    def shutdown
+      @server.shutdown
+    end
+    
+  end
+end

data/lib/simplerdb/servlet.rb

@@ -0,0 +1,203 @@
+require 'rubygems'
+require 'webrick'
+require 'builder'
+require 'simplerdb/db'
+require 'simplerdb/client_exception'
+
+# Force every request to be a GET. Otherwise WEBrick can't handle requests
+# from certain clients
+module WEBrick
+  class HTTPRequest
+    alias old_parse parse
+    def parse(socket=nil)
+      old_parse(socket)
+      @request_method = "GET"
+    end
+  end
+end
+
+module SimplerDB
+  
+  # A WEBrick servlet to handle API requests over REST
+  class RESTServlet < WEBrick::HTTPServlet::AbstractServlet
+      
+    def do_GET(req, res)
+      action = req.query["Action"]
+      
+      begin
+        if action.nil?
+          # Raise an error
+          raise ClientException.new(:MissingAction, "No action was supplied with this request")
+        else
+          # Process the action appropriately
+          xml = eval("do_#{action.downcase}(req)")
+          res.body = xml
+          res.status = 200
+        end
+      rescue ClientException => e
+        res.body = error_xml(e.code, e.msg)
+        res.status = 400 # What is the right status?
+      end
+      
+      res['content-type'] = 'text/xml'
+    end
+    
+    alias do_POST do_GET
+    alias do_DELETE do_GET
+    
+    # Handle CreateDomain requests
+    def do_createdomain(req)
+      name = req.query["DomainName"]
+      DB.instance.create_domain(name)
+      build_result("CreateDomain")
+    end
+    
+    # Handle ListDomains requests
+    def do_listdomains(req)
+      max = req.query["MaxNumberOfDomains"]
+      next_token = req.query["NextToken"]
+      
+      max = max.to_i if max
+      domains,token = DB.instance.list_domains(max, next_token)
+      
+      build_result("ListDomains") do |doc|
+        doc.ListDomainsResult do
+          if domains
+            domains.each do |domain|
+              doc.DomainName domain
+            end
+          end
+          
+          if token
+            doc.NextToken token
+          end
+        end
+      end
+    end
+    
+    
+    # DeleteDomains requests
+    def do_deletedomain(req)
+      name = req.query["DomainName"]
+      DB.instance.delete_domain(name)
+      build_result("DeleteDomain")  
+    end
+    
+    # PutAttributes requests
+    def do_putattributes(req)
+      domain_name = req.query["DomainName"]
+      item_name = req.query["ItemName"]
+      attrs = parse_attribute_args(req)
+      DB.instance.put_attributes(domain_name, item_name, attrs)
+      build_result("PutAttributes")
+    end
+    
+    # DeleteAttributes requests
+    def do_deleteattributes(req)
+      domain_name = req.query["DomainName"]
+      item_name = req.query["ItemName"]
+      attrs = parse_attribute_args(req)
+      DB.instance.delete_attributes(domain_name, item_name, attrs)
+      build_result("DeleteAttributes")
+    end
+    
+    # GetAttributes request
+    def do_getattributes(req)
+      domain_name = req.query["DomainName"]
+      item_name = req.query["ItemName"]
+      attr_name = req.query["AttributeName"]
+      attrs = DB.instance.get_attributes(domain_name, item_name)
+      
+      build_result("GetAttributes") do |doc|
+        doc.GetAttributesResult do
+          if attrs
+            attrs.each do |attr|
+              doc.Attribute do
+                doc.Name attr.name
+                doc.Value attr.value
+              end
+            end
+          end
+        end
+      end
+    end
+    
+    # Query request
+    def do_query(req)
+      domain_name = req.query["DomainName"]
+      max_items = req.query["MaxItems"].to_i
+      max_items = 100 if (max_items < 1 || max_items > 250)
+      next_token = req.query["NextToken"]
+      query = req.query["QueryExpression"]
+      
+      results,token = DB.instance.query(domain_name, query, max_items, next_token)
+      build_result("Query") do |doc|
+        doc.QueryResult do
+          if results
+            results.each do |res|
+              doc.ItemName res.name
+            end
+          end
+        
+          if token
+            doc.NextToken token
+          end
+        end
+      end
+    end
+    
+    # Build a result for the given action.
+    # The given block will add action-specific return fields.
+    def build_result(action)
+      xml = ''
+      doc = Builder::XmlMarkup.new(:target => xml)
+        doc.tag!("#{action}Response", :xmlns => "http://sdb.amazonaws.com/doc/2007-11-07") do
+          if block_given?
+            yield doc
+          end
+          
+          doc.ResponseMetadata do
+            doc.RequestId "1234"
+            doc.BoxUsage "0"
+          end
+        end
+        
+      xml
+    end
+    
+    # Return the error response for the given error code and message
+    def error_xml(code, msg)
+      xml = ''
+      doc = Builder::XmlMarkup.new(:target => xml)
+      
+      doc.Response do
+        doc.Errors do
+          doc.Error do
+            doc.Code code.to_s
+            doc.Message msg
+            doc.BoxUsage "0"
+          end
+        end
+        
+        doc.RequestID  "1234"
+      end
+      
+      xml
+    end 
+    
+    def parse_attribute_args(req)
+      args = []
+      for i in (0...100)
+        name = req.query["Attribute.#{i}.Name"]
+        value = req.query["Attribute.#{i}.Value"]
+        replace = (req.query["Attribute.#{i}.Replace"] == "true")
+        if name && value
+          args << AttributeParam.new(name, value, replace)
+        end
+      end
+      
+      args
+    end
+  end
+  
+end

data/lib/simplerdb.rb

@@ -0,0 +1,3 @@
+class SimplerDB
+  VERSION = '0.1'
+end

data/test/functional_test.rb

@@ -0,0 +1,81 @@
+require "test/unit"
+require 'rubygems'
+require 'right_aws'
+require 'simplerdb/server'
+
+# Test the live, running service over HTTP
+class FunctionalTest < Test::Unit::TestCase
+  
+  def setup
+    @server = SimplerDB::Server.new(8087)
+    @thread = Thread.new { @server.start }
+    @sdb = RightAws::SdbInterface.new('access','secret',
+                                     {:server => 'localhost', :port => 8087, :protocol => 'http'})
+
+  end
+  
+  def teardown
+    @server.shutdown
+    @thread.join
+  end
+  
+  def test_domains
+    # Create/list domains
+    @sdb.create_domain("d1")
+    @sdb.create_domain("d2")
+    result = @sdb.list_domains
+    assert result[:domains].index("d1")
+    assert result[:domains].index("d2")
+    
+    # List domains with paging
+    domains = []
+    count = 0
+    @sdb.list_domains(1) do |result|
+      domains += result[:domains]
+      count += 1
+      true
+    end
+    
+    assert count == 2
+    assert domains.index("d1")
+    assert domains.index("d2")
+  end
+  
+  def test_items
+    # Create some bands with albums + genre
+    @sdb.create_domain("bands")
+    
+    attrs = {:albums => ['Being There', 'Summer Teeth'], :genre => "rock"}
+    @sdb.put_attributes("bands", "Wilco", attrs)
+    
+    attrs = {:albums => ['OK Computer', 'Kid A'], :genre => "alternative"}
+    @sdb.put_attributes("bands", "Radiohead", attrs)
+    
+    attrs = {:albums => ['The Soft Bulletin'], :genre => "alternative"}
+    @sdb.put_attributes("bands", "The Flaming Lips", attrs)
+    
+    # Read the attributes back
+    results = @sdb.get_attributes("bands", "Wilco")
+    assert results[:attributes]["albums"].sort == ['Being There', 'Summer Teeth']
+    assert results[:attributes]["genre"] == ["rock"]
+    
+    # Query the bands domain
+    results = @sdb.query("bands", "['genre' = 'alternative']")
+    assert results[:items].sort == ["Radiohead", "The Flaming Lips"]
+    
+    results = @sdb.query("bands", "['albums' = 'Being There']")
+    assert results[:items] == ["Wilco"]
+    
+    results = @sdb.query("bands", "['albums' starts-with 'OK' or 'albums' = 'The Soft Bulletin']")
+    assert results[:items].sort == ["Radiohead", "The Flaming Lips"]
+  
+    # Modify and re-read attributes
+    @sdb.put_attributes("bands", "The Flaming Lips", {:albums => "Yoshimi Battles the Pink Robots"})
+    @sdb.put_attributes("bands", "The Flaming Lips", {:genre => "rock"}, :replace)
+    
+    results = @sdb.get_attributes("bands", "The Flaming Lips")
+    assert results[:attributes]["albums"].sort == ["The Soft Bulletin", "Yoshimi Battles the Pink Robots"]
+    assert results[:attributes]["genre"] == ["rock"]
+  end
+  
+end

data/test/query_evaluator_test.rb

@@ -0,0 +1,73 @@
+require "test/unit"
+require 'simplerdb/query_language'
+require 'simplerdb/db'
+
+# Tests the query evaluator
+class QueryEvaluatorTest < Test::Unit::TestCase
+  include SimplerDB
+  
+  def setup
+    @db = DB.instance
+    @db.create_domain("test")
+  end
+  
+  def teardown
+    @db.reset
+  end
+  
+  def test_single_predicate
+    bulk_insert('i1' => [["a1", "v1"], ["a2", "v2"], ["a3", "bcd"]],
+                'i2' => [["a1", "vv1"]])
+    
+    assert_items 'i1', @db.query("test", "['a1' = 'v1']")
+    assert_items 'i1', @db.query("test", "['a1' != 'v2']")
+    assert_items 'i1', @db.query("test", "['a1' >= 'v1']")
+    assert_items 'i1', @db.query("test", "['a1' <= 'v1']")
+    assert_items 'i1', @db.query("test", "['a3' starts-with 'bc']")
+    assert_items 'i1', @db.query("test", "['a3' > 'cde']")
+    assert_items 'i1', @db.query("test", "['a3' < 'abc']")
+    assert_items ['i1', 'i2'], @db.query("test", "['a1' = 'v1' or 'a1' = 'vv1']")
+    assert_items ['i1', 'i2'], @db.query("test", "['a1' <= 'v1']")
+    
+    assert_empty @db.query("test", "['a2' != 'v2']")
+    assert_empty @db.query("test", "['a2' > 'v2']")
+    assert_empty @db.query("test", "['a2' = 'v1']")
+    assert_empty @db.query("testxxxxx", "['a2' = 'v2']")
+    assert_empty @db.query("test", "['a2' = 'v1']")
+  end
+  
+  def test_ops
+    
+  end
+  
+  def bulk_insert(items)
+    items.each do |name, attrs|
+      params = []
+      for attr in attrs
+        params << AttributeParam.new(attr[0], attr[1])
+      end
+      
+      @db.put_attributes("test", name, params)
+    end
+  end
+  
+  def assert_empty(results)
+    assert results[0].empty?
+  end
+  
+  def assert_items(items, results)
+    results = results[0]
+    for item in items
+      found = false
+      for result in results
+        if result.name == item
+          found = true
+          break
+        end
+      end
+      
+      assert found, "Missing item #{item}"
+    end
+  end
+  
+end

data/test/query_parser_test.rb

@@ -0,0 +1,64 @@
+require "test/unit"
+require 'simplerdb/query_language'
+
+# Tests the query parser
+class QueryParserTest < Test::Unit::TestCase
+  
+# Taken from an AWS forum post
+VALID = <<END
+            ['attrR' = 'random']
+            ['attrR' != 'random']
+            ['attrR' < 'random']
+            ['attrR' <= 'random']
+            ['attrR' starts-with 'random']
+            ['attrR' starts-with '0000009000']
+            ['attrR' = 'random1' or 'attrR' = 'random2']
+            not ['attrR'='random' or 'attrR'='random']
+            not ['attrR'='random']
+            ['attrR1' = 'random1']  union ['attrR2' = 'random2']
+            ['attrR1' = 'random1']  union ['attrR2' < 'random2']
+            ['attrR1' = 'random1']  union not ['attrR2' = 'random2']
+            ['attrR1' = 'random1']  intersection ['attrR2' = 'random2']
+            ['attrR1' = 'random1']  intersection not ['attrR2' = 'random2']
+            ['attrR1' = 'random1']  intersection ['attrR2' < 'random2']
+            ['attrR1' starts-with '0000009000'] intersection ['attrR2' >= 'random2']
+            ['attrR1' > '0000000100']  intersection ['attrR2' < '0000200000']  intersection ['attrR3' > '0000000200']
+            ['attrR1' = 'random1']  union ['attrR2' = 'random2']   intersection ['attrR3' = 'random3']
+            ['attrR1' = 'random1']  intersection ['attrR2' = 'random2']   intersection ['attrR3' = 'random3']
+            ['attrR1' = 'random1']  intersection ['attrR2' = 'random2']   intersection ['attrR3' = 'random3']
+            ['attrR1' = 'random1']  union ['attrR2' = 'random2']   union ['attrR3' = 'random3']
+            ['attrR1' > '0000000100']  intersection ['attrR2' < '0000200000']  intersection ['attrR3' > '0000000200']
+END
+
+INVALID = <<END
+            ['attrR' == 'random']
+            ['attrR' - 'random']
+            ['attrR' < 'random]
+            ['attrR' <= 'rand'om']
+            ['attrR' starts with 'random']
+            ['attrR' union '0000009000']
+            ['attrR' = 'random1' or 'attrR' = 'random2'] foo ['foo' = 'bar']
+            []
+            ['bar']
+            ['']
+END
+
+  def setup
+    @lexer = Dhaka::Lexer.new(SimplerDB::QueryLexerSpec)
+    @parser = Dhaka::Parser.new(SimplerDB::QueryGrammar)
+  end
+  
+  def test_valid_queries
+    VALID.each do |query|
+      result = @parser.parse(@lexer.lex(query.strip!))
+      assert result.is_a?(Dhaka::ParseSuccessResult), query
+    end
+  end
+  
+  def test_invalid_queries
+    INVALID.each do |query|
+      result = @parser.parse(@lexer.lex(query.strip!))
+      assert !result.is_a?(Dhaka::ParseSuccessResult), query
+    end
+  end
+end

data/test/simplerdb_test.rb

@@ -0,0 +1,80 @@
+require "test/unit"
+require 'simplerdb/db'
+
+class SimplerDBTest < Test::Unit::TestCase
+  include SimplerDB
+  
+  def setup
+    @db = DB.instance
+  end
+  
+  def teardown
+    @db.reset
+  end
+  
+  def test_create_list_domains
+    %w| a b c c c |.each { |d| @db.create_domain(d) }
+    assert @db.list_domains[0].size == 3
+    
+    domains,token = @db.list_domains(1)
+    assert domains.size == 1
+    assert token == 1
+    
+    domains,token = @db.list_domains(1, 1)
+    assert domains.size == 1
+    assert token == 2
+    
+    domains,token = @db.list_domains(10,2)
+    assert domains.size == 1
+    assert token.nil?
+  end
+  
+  def test_delete_domain
+     %w| a b c |.each { |d| @db.create_domain(d) }
+     @db.delete_domain('b')
+     domains,token = @db.list_domains
+     assert domains.size == 2
+     assert domains[0] == 'a' && domains[1] == 'c'
+     
+     @db.delete_domain('xxxxx')
+     assert domains.size == 2
+     assert domains[0] == 'a' && domains[1] == 'c'
+  end
+  
+  def test_put_get_attributes
+    @db.create_domain("test")
+    
+    attrs = [AttributeParam.new("a1", "v1"), AttributeParam.new("a1", "v2"), AttributeParam.new("a2", "v1")]
+    @db.put_attributes("test", "item1", attrs)
+    assert @db.get_attributes("test", "item1").size == 3
+    assert @db.get_attributes("test", "item1", "a2").size == 1
+    assert @db.get_attributes("test", "item1", "a1").size == 2
+    
+    attrs = [AttributeParam.new("a1", "v3")]
+    @db.put_attributes("test", "item1", attrs)
+    assert @db.get_attributes("test", "item1", "a1").size == 3
+    
+    assert @db.get_attributes("test", "itemXXXXX", "a2").size == 0
+    
+    # Replacement
+    attrs = [AttributeParam.new("a1", "v1"), AttributeParam.new("a1", "v2"), AttributeParam.new("a1", "v3")]
+    @db.put_attributes("test", "item_repl", attrs)
+    assert @db.get_attributes("test", "item_repl", "a1").size == 3
+    attrs = [AttributeParam.new("a1", "v4", true)]
+    @db.put_attributes("test", "item_repl", attrs)
+    assert @db.get_attributes("test", "item_repl", "a1").size == 1
+    @db.get_attributes("test", "item_repl", "a1")[0].value == "v4"
+  end
+  
+  def test_delete_attributes
+    @db.create_domain("test")
+    
+    attrs = [AttributeParam.new("a1", "v1"), AttributeParam.new("a1", "v2"), AttributeParam.new("a2", "v1")]
+    @db.put_attributes("test", "item1", attrs)
+    @db.delete_attributes("test", "item1", [AttributeParam.new("a1", "v1")])
+    assert @db.get_attributes("test", "item1").size == 2
+    @db.delete_attributes("test", "item1", [AttributeParam.new("a1", "v1")])
+    assert @db.get_attributes("test", "item1").size == 2
+  end
+  
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: simplerdb
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2008-03-15 00:00:00 -04:00
+summary: Test your SimpleDB application offline
+require_paths: 
+- lib
+email: gary@tourb.us
+homepage: "    by Gary Elliott (gary@tourb.us)"
+rubyforge_project: simplerdb
+description: Test your SimpleDB application offline
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Gary Elliott
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/simplerdb
+- lib/simplerdb.rb
+- lib/simplerdb/Rakefile
+- lib/simplerdb/client_exception.rb
+- lib/simplerdb/db.rb
+- lib/simplerdb/query_language.rb
+- lib/simplerdb/servlet.rb
+- lib/simplerdb/server.rb
+- test/query_evaluator_test.rb
+- test/query_parser_test.rb
+- test/simplerdb_test.rb
+- test/functional_test.rb
+test_files: []
+
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+executables: 
+- simplerdb
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: dhaka
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.2.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.0
+    version: