hungryblank-dead_simple_db 0.0.1

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 1
+:major: 0
+:minor: 0

data/lib/dead_simple_db.rb

@@ -0,0 +1,8 @@
+require 'aws_sdb'
+require 'digest/md5'
+Dir.glob(File.dirname(__FILE__) + '/dead_simple_db/**/*.rb').each do |lib|
+  require lib
+end
+
+module DeadSimpleDb
+end

data/lib/dead_simple_db/attribute.rb

@@ -0,0 +1,35 @@
+module DeadSimpleDb
+
+  class Attribute
+
+    attr_reader :name
+
+    def initialize(name, klass, opts={})
+      @name, @opts = name, opts 
+      self.klass = klass
+    end
+
+    def set(value)
+      to_instantiate = @klass
+      value = value.first if value.is_a?(Array) && !to_instantiate.respond_to?(:multiple)
+      to_instantiate = SdbNull if SdbNull::NULL_VALUES.member?(value)
+      @value = to_instantiate.new(value, @opts)
+    end
+
+    def to_s
+      @value.to_s
+    end
+
+    def value
+      @value.casted
+    end
+
+    private
+
+      def klass=(klass)
+        @klass = instance_eval('Sdb' + klass.to_s)
+      end
+
+  end
+
+end

data/lib/dead_simple_db/attribute_definition.rb

@@ -0,0 +1,17 @@
+module DeadSimpleDb
+
+  class AttributeDefinition
+
+    attr_reader :name
+
+    def initialize(name, klass, opts={})
+      @name, @klass, @opts = name, klass, opts 
+    end
+
+    def to_attr
+      Attribute.new(@name, @klass, @opts)
+    end
+
+  end
+
+end

data/lib/dead_simple_db/datatypes/sdb_boolean.rb

@@ -0,0 +1,27 @@
+module DeadSimpleDb
+
+  class SdbBoolean
+
+    def initialize(value, opts={})
+      @value_before_cast = value
+    end
+
+    def casted
+      @casted = if @value_before_cast || false
+        if @value_before_cast.respond_to?(:downcase)
+          @value_before_cast.downcase == 'false' ? false : true
+        else
+          true
+        end
+      else
+        false
+      end
+    end
+
+    def to_s
+      casted.to_s.upcase
+    end
+
+  end
+
+end

data/lib/dead_simple_db/datatypes/sdb_date.rb

@@ -0,0 +1,31 @@
+module DeadSimpleDb
+
+  class SdbDate
+
+    DEFAULT_OPTS = {:format => '%Y-%m-%d'}
+
+    def initialize(value, opts={})
+      @opts = DEFAULT_OPTS.merge(opts)
+      @value_before_cast = value
+    end
+
+    def casted
+      @casted = @value_before_cast if @value_before_cast.is_a?(Date)
+      @casted ||= begin
+        if @value_before_cast.respond_to?(:to_date)
+          @value_before_cast.to_date
+        elsif Date.respond_to?(:strptime)
+          Date.strptime(@value_before_cast, @opts[:format])
+        else
+          Date.new(*(@value_before_cast.split('-').map { |n| n.to_i }))
+        end
+      end
+    end
+
+    def to_s
+      @string ||= casted.strftime(@opts[:format])
+    end
+
+  end
+
+end

data/lib/dead_simple_db/datatypes/sdb_float.rb

@@ -0,0 +1,28 @@
+module DeadSimpleDb
+
+  class SdbFloat
+
+    include NegativeNumber
+
+    DEFAULT_OPTS = {:digits => 8, :decimals => 2}
+
+    def initialize(value, opts={})
+      @opts = DEFAULT_OPTS.merge(opts)
+      @value_before_cast = value
+    end
+
+    def casted
+      @casted ||= @value_before_cast.to_f
+    end
+
+    def to_s
+      @string ||= prepending_minus(casted.to_s) do |string|
+          integer, decimal = *string.split('.')
+          integer.rjust(@opts[:digits] - @opts[:decimals], '0') + '.' +
+          decimal[0..@opts[:decimals] - 1].ljust(@opts[:decimals], '0')
+      end
+    end
+
+  end
+
+end

data/lib/dead_simple_db/datatypes/sdb_integer.rb

@@ -0,0 +1,26 @@
+module DeadSimpleDb
+
+  class SdbInteger
+
+    include NegativeNumber
+
+    DEFAULT_OPTS = {:digits => 6}
+
+    def initialize(value, opts={})
+      @opts = DEFAULT_OPTS.merge(opts)
+      @value_before_cast = value
+    end
+
+    def casted
+      @casted ||= @value_before_cast.to_i
+    end
+
+    def to_s
+      @string ||= prepending_minus(casted.to_s) do |string|
+        string.rjust(@opts[:digits], '0')
+      end
+    end
+
+  end
+
+end

data/lib/dead_simple_db/datatypes/sdb_null.rb

@@ -0,0 +1,21 @@
+module DeadSimpleDb
+
+  class SdbNull
+
+    NULL_VALUES = [nil, '', 'NULL']
+
+    def initialize(value, opts={})
+      raise "#{value} is not a null value" unless NULL_VALUES.member?(value)
+    end
+
+    def casted
+      nil
+    end
+
+    def to_s
+      'NULL'
+    end
+
+  end
+
+end

data/lib/dead_simple_db/datatypes/sdb_string.rb

@@ -0,0 +1,23 @@
+module DeadSimpleDb
+
+  class SdbString
+
+    def initialize(value, opts={})
+      @value_before_cast = value
+    end
+
+    def casted
+      @casted = case @value_before_cast
+        when String : @value_before_cast
+        else
+          @value_before_cast.to_s
+      end
+    end
+
+    def to_s
+      casted
+    end
+
+  end
+
+end

data/lib/dead_simple_db/datatypes/sdb_time.rb

@@ -0,0 +1,29 @@
+module DeadSimpleDb
+
+  class SdbTime
+
+    DEFAULT_OPTS = {:format => '%Y-%m-%d %H:%M:%S'}
+
+    def initialize(value, opts={})
+      @opts = DEFAULT_OPTS.merge(opts)
+      @value_before_cast = value
+    end
+
+    def casted
+      @casted = @value_before_cast if @value_before_cast.is_a?(Time)
+      @casted ||= begin
+        if @value_before_cast.respond_to?(:to_time)
+          @value_before_cast.to_time
+        else
+          Time.local(*(@value_before_cast.split(/-|\s|:/).map { |n| n.to_i }))
+        end
+      end
+    end
+
+    def to_s
+      @string ||= casted.strftime(@opts[:format])
+    end
+
+  end
+
+end

data/lib/dead_simple_db/dead_simple_db.rb

@@ -0,0 +1,173 @@
+require 'aws_sdb'
+require 'digest/md5'
+
+module DeadSimpleDb
+
+  class Base
+
+    attr_reader :attributes_hash
+
+    class << self
+      
+      #Define the SimpleDb domain you want to use to store the current class
+      #
+      #  class Employee < DeadSimpleDb::Base
+      #    
+      #    domain 'hr_application'
+      #
+      #  end
+      #
+      #this will store all the instance of Employee class in the 'hr_application' domain
+      def domain(domain = nil)
+        return @domain unless domain
+        @domain = domain
+      end
+
+      #Refresh the current connection to SimpleDB
+      def reconnect!
+        @service = AwsSdb::Service.new
+      end
+
+      #The AwsSdb::Service currently used
+      def service
+        @service ||= AwsSdb::Service.new
+      end
+
+      #Create the SimpleDB domain used by the class
+      def setup
+        service.create_domain(@domain)
+      end
+
+      #Gets a specific record identified by serial
+      #
+      # Employee.get("78af7ab2ebb10e71e7a936564621bbf3")
+      #
+      def get(serial)
+        new(service.get_attributes(@domain, serial), :serial => serial)
+      end
+
+      #Lets you query the stored data
+      #
+      #to find the first employee who's name is Chuck
+      #
+      # Employee.find(:first, "['name' = 'Chuck']")
+      #
+      #to find all the employees who are designers
+      #
+      # Employee.find(:all, "['role' = 'designer']")
+      #
+      #please note the query syntax is SimpleDB custom syntax, refer to SimpleDB docs for details
+      #
+      def find(how_many, query, opts={})
+        results = find_ids(how_many, query, opts).map { |o| get(o) }
+        return results.first if how_many == :first
+        results
+      end
+
+      #The same as find but instead of returning the full object just returns
+      #the object ids satisfyng the query
+      #
+      def find_ids(how_many, query, opts={})
+        limit = case how_many
+          when :all : nil
+          when :first : 1
+        else
+          how_many
+        end
+        service.query(@domain, query, limit).first
+      end
+
+      def attr_definitions
+        @attr_definitions ||= []
+      end
+
+      private
+
+        def attr_sdb(name, klass, opts={})
+          define_method(name) do
+            attributes_hash[name.to_sym].value
+          end
+          define_method("#{name}=") do |value|
+            attributes_hash[name.to_sym].set(value)
+          end
+          attr_definitions << AttributeDefinition.new(name, klass, opts)
+        end
+
+    end
+
+    #Instantiates a new object passing an hash
+    #
+    #  new_employee = Emloyee.new(:name => 'Arturo', :surname => 'Bandini')
+    #
+    #please note that this does't stores the object on SimpleDB
+    #it's the save method that performs the actual network operation of storing the data
+    def initialize(attributes_hash={}, opts={})
+      read_attributes(attributes_hash)
+      @serial = opts[:serial]
+    end
+
+    #Updates the attribute of the object using the hash passed as parameter
+    def update_attributes(attributes_hash, opts={})
+      read_attributes(attributes_hash)
+    end
+
+    def attributes_hash
+      @attributes_hash ||= attributes.inject({}) do |hash, attribute|
+        hash[attribute.name] = attribute
+        hash
+      end
+    end
+
+    def attributes_hash_for_call
+      attributes_hash.merge({:class_name => self.class.to_s})
+    end
+
+    #Saves the current record on SimpleDB
+    def save
+      service.put_attributes(domain, serial, attributes_hash_for_call)
+      serial
+    end
+
+    #Deletes the current record from SimpleDB
+    def destroy
+      service.delete_attributes(domain, serial)
+    end
+
+    #The unique identifier for the current record
+    def serial
+      @serial ||= begin
+        serial = serial_string
+        serial << Time.now.to_f.to_s
+        Digest::MD5.hexdigest(serial)
+      end
+    end
+
+    private
+
+      def service
+        self.class.service
+      end
+
+      def domain
+        self.class.domain
+      end
+
+      def serial_string
+        labels = attributes_hash.map { |k, v| k.to_s + v.to_s }.join('')
+      end
+
+      def read_attributes(hash)
+        attribute_names = attributes.map { |a| a.name }
+        attribute_names.map! { |an| an.to_s } if hash.keys.first.is_a?(String)
+        attributes.each_with_index do |attribute, index|
+          attribute.set(hash[attribute_names[index]])
+        end
+      end
+
+      def attributes
+        @attributes ||= self.class.attr_definitions.map { |d| d.to_attr }
+      end
+
+  end
+
+end

data/lib/dead_simple_db/negative_number.rb

@@ -0,0 +1,17 @@
+module DeadSimpleDb 
+
+  module NegativeNumber
+
+    def negative?
+      casted < 0
+    end
+
+    def prepending_minus(string)
+      raise "needs a block" unless block_given?
+      string.sub!('-', '') if negative?
+      string = yield(string)
+      negative? ? '-' + string : string
+    end
+  end
+
+end

data/test/attribute_test.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class AttributeTest < Test::Unit::TestCase
+
+  include DeadSimpleDb
+
+  should "set the name" do
+    attribute = Attribute.new(:number, 'Integer')
+    assert_equal :number, attribute.name
+  end
+
+  should "should instantiate the correct class" do
+    SdbInteger.expects(:new).with('10', :decimals => 10)
+    attribute = Attribute.new(:number, 'Integer', :decimals => 10)
+    attribute.set('10')
+  end
+
+  should "should instantiate a null when a null value is passed" do
+    null_value = SdbNull::NULL_VALUES.first
+    SdbNull.expects(:new).with(null_value, :decimals => 10)
+    attribute = Attribute.new(:number, 'Integer', :decimals => 10)
+    attribute.set(null_value)
+  end
+
+  should "should call to_s on its value" do
+    integer_mock = Mocha::Mock.new
+    SdbInteger.expects(:new).with('10', :decimals => 10).returns(integer_mock)
+    attribute = Attribute.new(:number, 'Integer', :decimals => 10)
+    attribute.set('10')
+    integer_mock.expects(:to_s)
+    attribute.to_s
+  end
+
+  should "should cast to return value" do
+    integer_mock = Mocha::Mock.new
+    SdbInteger.expects(:new).with('10', :decimals => 10).returns(integer_mock)
+    attribute = Attribute.new(:number, 'Integer', :decimals => 10)
+    attribute.set('10')
+    integer_mock.expects(:casted)
+    attribute.value
+  end
+
+end

data/test/dead_simple_db_test.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + '/test_helper'
+Dir.glob(File.dirname(__FILE__) + '/dummies/*.rb').each do |file|
+  require file
+end
+
+class DeadSimpleDbTest < Test::Unit::TestCase
+
+  include DeadSimpleDb
+
+  def setup
+    @service = Mocha::Mock.new
+    @arturo = Employee.new(:name => 'Arturo', :surname => 'Bandini')
+    AwsSdb::Service.stubs(:new).returns(@service)
+    Employee.reconnect!
+  end
+
+  should "create the domain with setup" do
+    @service.expects(:list_domains).returns([])
+    @service.expects(:create_domain).with('test_domain')
+    Employee.setup
+  end
+
+  should "put attributes on save" do
+    @arturo.expects(:serial).returns('serial_1').times(2)
+    put_hash = @arturo.attributes_hash_for_call
+    @service.expects(:put_attributes).with('test_domain', 'serial_1', put_hash).returns(nil)
+    @arturo.save
+  end
+
+
+  should "delete attributes on destroy" do
+    @arturo.expects(:serial).returns('serial_1')
+    @service.expects(:delete_attributes).with('test_domain', 'serial_1').returns(nil)
+    @arturo.destroy
+  end
+
+  should "add class name to call hash" do
+    assert_equal 'Employee', @arturo.attributes_hash_for_call[:class_name]
+  end
+
+  should "have a serial based on timestamp" do
+    Time.stubs(:now).returns(Time.utc(2000,"jan",1,20,15,1))
+    @arturo.expects(:serial_string).returns('nameArturosurnameBandini')
+    assert_equal Digest::MD5.hexdigest('nameArturosurnameBandini946757701.0'), @arturo.serial
+  end
+
+  should "get attributes when getting a specific record" do
+    @service.expects(:get_attributes).with('test_domain', 'serial_1').returns({:name => 'Arturo', :surname => 'Bandini'})
+    fetched_employee = Employee.get('serial_1')
+    assert Employee = fetched_employee.class
+    assert_equal 'serial_1', fetched_employee.serial
+  end
+
+  should "issue a query when finding ids" do
+    @service.expects(:query).with('test_domain', "['name' = 'Arturo']", nil).returns(['e34979d4dc7b5b949fa67916acb63743'])
+    Employee.find_ids(:all, "['name' = 'Arturo']")
+  end
+
+  should "fetch ids and after get attributes when finding" do
+    Employee.expects(:find_ids).with(:all, "['name' = 'Arturo']", {}).returns(['e34979d4dc7b5b949fa67916acb63743'])
+    Employee.expects(:get).with("e34979d4dc7b5b949fa67916acb63743")
+    Employee.find(:all, "['name' = 'Arturo']")
+  end
+
+  should "instantiate an attribute definition when sdb_attr is called" do
+    AttributeDefinition.expects(:new).with(:number, 'Integer', :decimals => 10).returns('w')
+    attr_def_ary = Mocha::Mock.new
+    Employee.expects(:attr_definitions).returns(attr_def_ary)
+    attr_def_ary.expects('<<').with('w')
+    Employee.send(:attr_sdb, :number, 'Integer', :decimals => 10)
+  end
+
+  should "read attributes from hash with symbols or strings" do
+    attribute = @arturo.send(:attributes).find { |a| a.name == :name }
+    attribute.expects(:set).with('Arturo')
+    @arturo.update_attributes(:name => 'Arturo')
+    attribute.expects(:set).with('Arturo string')
+    @arturo.update_attributes('name' => 'Arturo string')
+  end
+
+  should "build methods to access attributes" do
+    assert_equal 'Arturo', @arturo.name
+  end
+
+end

data/test/dummies/employee.rb

@@ -0,0 +1,12 @@
+class Employee < DeadSimpleDb::Base
+
+  domain 'test_domain'
+
+  attr_sdb :name, 'String'
+  attr_sdb :surname, 'String'
+  attr_sdb :number, 'Integer', :digits => 10
+  attr_sdb :rating, 'Float', :digits => 10, :decimals => 4
+  attr_sdb :joined, 'Date'
+  attr_sdb :last_login, 'Time'
+
+end

data/test/sdb_boolean_test.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class SdbBooleanTest < Test::Unit::TestCase
+
+  include DeadSimpleDb
+
+  should "cast correctly a true/false string" do
+    boolean = SdbBoolean.new('true')
+    assert_equal true, boolean.casted
+    boolean = SdbBoolean.new('false')
+    assert_equal false, boolean.casted
+  end
+
+  should "be identical if provided a boolean" do
+    boolean = SdbBoolean.new(true)
+    assert_equal true, boolean.casted
+    boolean = SdbBoolean.new(false)
+    assert_equal false, boolean.casted
+  end
+
+  should "be a string when converted to string" do
+    boolean = SdbBoolean.new('yeah')
+    assert_equal 'TRUE', boolean.to_s
+    boolean = SdbBoolean.new('false')
+    assert_equal 'FALSE', boolean.to_s
+  end
+
+end

data/test/sdb_date_test.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class SdbDateTest < Test::Unit::TestCase
+
+  include DeadSimpleDb
+
+  should "cast a string to date" do
+    date = SdbDate.new('2008-10-31')
+    assert_equal Date.new(2008, 10, 31), date.casted
+  end
+
+  should "be identical if provided a date" do
+    date = SdbDate.new(Date.new(2008, 10, 31))
+    assert_equal Date.new(2008, 10, 31), date.casted
+  end
+
+  should "be formatted if printed as string" do
+    date = SdbDate.new(Date.new(2008, 10, 31))
+    assert_equal '2008-10-31', date.to_s
+  end
+
+end

data/test/sdb_float_test.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class SdbFloatTest < Test::Unit::TestCase
+
+  include DeadSimpleDb
+
+  should "cast a string to float" do
+    float = SdbFloat.new('10')
+    assert_equal 10.0, float.casted
+  end
+
+  should "be identical if provided a float" do
+    float = SdbFloat.new(10.0)
+    assert_equal 10.0, float.casted
+  end
+
+  should "be casted if provided an integer" do
+    float = SdbFloat.new(10)
+    assert_equal 10.0, float.casted
+  end
+
+  should "be padded if printed as string" do
+    float = SdbFloat.new(100.1, :digits => 6)
+    assert_equal '0100.10', float.to_s
+  end
+
+  should "be trimmed if string is too long" do
+    float = SdbFloat.new(100.11231312312, :digits => 6)
+    assert_equal '0100.11', float.to_s
+  end
+
+  should "handle negative string" do
+    float = SdbFloat.new('-100.1', :digits => 6)
+    assert_equal '-0100.10', float.to_s
+  end
+
+  should "handle negative float" do
+    float = SdbFloat.new('-100.5', :digits => 6)
+    assert_equal '-0100.50', float.to_s
+  end
+
+end

data/test/sdb_integer_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class SdbIntegerTest < Test::Unit::TestCase
+
+  include DeadSimpleDb
+
+  should "cast a string to integer" do
+    integer = SdbInteger.new('10')
+    assert_equal 10, integer.casted
+  end
+
+  should "be identical if provided an integer" do
+    integer = SdbInteger.new(10)
+    assert_equal 10, integer.casted
+  end
+
+  should "be casted if provided a float" do
+    integer = SdbInteger.new(10.99)
+    assert_equal 10, integer.casted
+  end
+
+  should "be padded if printed as string" do
+    integer = SdbInteger.new(10, :digits => 6)
+    assert_equal '000010', integer.to_s
+  end
+
+  should "be padded and have minus if printed as string" do
+    integer = SdbInteger.new(-10, :digits => 6)
+    assert_equal '-000010', integer.to_s
+  end
+
+  should "handle minus if provided negative string" do
+    integer = SdbInteger.new('-15', :digits => 6)
+    assert_equal '-000015', integer.to_s
+  end
+
+end

data/test/sdb_null_test.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class SdbNullTest < Test::Unit::TestCase
+
+  include DeadSimpleDb
+
+  should "cast a string to nil" do
+    null = SdbNull.new('')
+    assert_equal nil, null.casted
+  end
+
+  should "be identical if provided a nil" do
+    null = SdbNull.new(nil)
+    assert_equal nil, null.casted
+  end
+
+  should "be a NULL when converted to string" do
+    null = SdbNull.new('')
+    assert_equal 'NULL', null.to_s
+  end
+
+  should "raise an exception if provided a non null string" do
+    assert_raise(RuntimeError) { SdbNull.new('4') }
+  end
+
+end

data/test/sdb_string_test.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class SdbStringTest < Test::Unit::TestCase
+
+  include DeadSimpleDb
+
+  should "cast a integer to string" do
+    string = SdbString.new(10)
+    assert_equal '10', string.casted
+  end
+
+  should "be identical if provided a string" do
+    string = SdbString.new('foo')
+    assert_equal 'foo', string.casted
+  end
+
+  should "be a string when converted to string" do
+    string = SdbString.new(1.1)
+    assert_equal '1.1', string.to_s
+  end
+
+end

data/test/sdb_time_test.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class SdbTimeTest < Test::Unit::TestCase
+
+  include DeadSimpleDb
+
+  should "cast a string to time" do
+    time = SdbTime.new('2008-10-31 23:35:41')
+    assert_equal Time.local(2008, 10, 31, 23, 35, 41), time.casted
+  end
+
+  should "be identical if provided a time" do
+    time = SdbTime.new(Time.local(2008, 10, 31, 23, 35, 41))
+    assert_equal Time.local(2008, 10, 31, 23, 35, 41), time.casted
+  end
+
+  should "be formatted if printed as string" do
+    time = SdbTime.new(Time.local(2008, 10, 31, 23, 35, 41))
+    assert_equal '2008-10-31 23:35:41', time.to_s
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'dead_simple_db'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: hungryblank-dead_simple_db
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Paolo Negri
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-26 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: aws-sdb
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: TODO
+email: hungryblank@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- VERSION.yml
+- lib/dead_simple_db.rb
+- lib/dead_simple_db
+- lib/dead_simple_db/negative_number.rb
+- lib/dead_simple_db/dead_simple_db.rb
+- lib/dead_simple_db/datatypes
+- lib/dead_simple_db/datatypes/sdb_time.rb
+- lib/dead_simple_db/datatypes/sdb_integer.rb
+- lib/dead_simple_db/datatypes/sdb_float.rb
+- lib/dead_simple_db/datatypes/sdb_null.rb
+- lib/dead_simple_db/datatypes/sdb_string.rb
+- lib/dead_simple_db/datatypes/sdb_date.rb
+- lib/dead_simple_db/datatypes/sdb_boolean.rb
+- lib/dead_simple_db/attribute.rb
+- lib/dead_simple_db/attribute_definition.rb
+- test/dead_simple_db_test.rb
+- test/sdb_float_test.rb
+- test/sdb_date_test.rb
+- test/dummies
+- test/dummies/employee.rb
+- test/sdb_integer_test.rb
+- test/sdb_string_test.rb
+- test/attribute_test.rb
+- test/sdb_time_test.rb
+- test/sdb_boolean_test.rb
+- test/test_helper.rb
+- test/sdb_null_test.rb
+has_rdoc: true
+homepage: http://github.com/hungryblank/dead_simple_db
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Object oriented library to store data in Amazon SimpleDB AWS
+test_files: []
+