dynamoid 0.5.0 → 0.6.0

data/Dynamoid.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "dynamoid"
-  s.version = "0.5.0"
+  s.version = "0.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Josh Symonds"]
-  s.date = "2012-08-22"
+  s.date = "2012-12-19"
   s.description = "Dynamoid is an ORM for Amazon's DynamoDB that supports offline development, associations, querying, and everything else you'd expect from an ActiveRecord-style replacement."
   s.email = "josh@joshsymonds.com"
   s.extra_rdoc_files = [
@@ -139,7 +139,7 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/Veraticus/Dynamoid"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.23"
+  s.rubygems_version = "1.8.24"
   s.summary = "Dynamoid is an ORM for Amazon's DynamoDB"
 
   if s.respond_to? :specification_version then

data/README.markdown

@@ -17,15 +17,72 @@ Installing Dynamoid is pretty simple. First include the Gem in your Gemfile:
 ```ruby
 gem 'dynamoid'
 ```
+## Prerequisities
 
-Then you need to initialize it to get it going. Put code similar to this somewhere (a Rails initializer would be a great place for this if you're using Rails):
+Dynamoid depends on  the aws-sdk, and this is tested on the current version of aws-sdk (1.6.9), rails 3.2.8.
+Hence the configuration as needed for aws to work will be dealt with by aws setup. 
+
+Here are the steps to setup aws-sdk.
+
+```ruby
+gem 'aws-sdk'
+```
+(or) include the aws-sdk in your Gemfile.
+
+
+[Refer this link for aws setup](https://github.com/amazonwebservices/aws-sdk-for-ruby)
+
+1. Just like the config/database.yml this file requires an entry for each environment, create config/aws.yml as follows:
+
+Fill in your AWS Access Key ID and Secret Access Key
+
+```ruby
+
+
+  development:
+    access_key_id: REPLACE_WITH_ACCESS_KEY_ID
+    secret_access_key: REPLACE_WITH_SECRET_ACCESS_KEY
+    dynamodb_end_point:  dynamodb.ap-southeast-1.amazonaws.com
+
+  test:
+    <<: *development
+
+  production:
+    <<: *development
+
+```
+
+(or)
+
+
+2. Create config/initializers/aws.rb as follows:
+
+```ruby
+
+#Additionally include any of the dynamodb paramters as needed.
+#(eg: if you would like to change the dynamodb endpoint, then add the parameter in 
+# in the file  aws.yml or aws.rb 
+
+dynamo_db_endpoint : dynamodb.ap-southeast-1.amazonaws.com)
+
+ AWS.config({
+    :access_key_id => 'REPLACE_WITH_ACCESS_KEY_ID',
+    :secret_access_key => 'REPLACE_WITH_SECRET_ACCESS_KEY',
+    :dynamodb_end_point => dynamodb.ap-southeast-1.amazonaws.com
+  })
+
+
+```
+
+Refer code in Module: AWS, and from the link below for the other configuration options supported for dynamodb.
+
+[Module AWS](http://docs.amazonwebservices.com/AWSRubySDK/latest/frames.html#!http%3A//docs.amazonwebservices.com/AWSRubySDK/latest/AWS.html)
+
+Then you need to initialize Dynamoid config to get it going. Put code similar to this somewhere (a Rails initializer would be a great place for this if you're using Rails):
 
 ```ruby
   Dynamoid.configure do |config|
-    # config.adapter = 'aws_sdk' # This adapter establishes a connection to the DynamoDB servers using Amazon's own AWS gem.
-    # config.access_key = 'access_key' # If connecting to DynamoDB, your access key is required.
-    # config.secret_key = 'secret_key' # So is your secret key.
-    # config.endpoint = 'dynamodb.us-east-1.amazonaws.com' # Set the regional endpoint for DynamoDB.
+    config.adapter = 'aws_sdk' # This adapter establishes a connection to the DynamoDB servers using Amazon's own AWS gem.
     config.namespace = "dynamoid_app_development" # To namespace tables created by Dynamoid from other tables you might have.
     config.warn_on_scan = true # Output a warning to the logger when you perform a scan rather than a query on a table.
     config.partitioning = true # Spread writes randomly across the database. See "partitioning" below for more.
@@ -252,14 +309,22 @@ Dynamoid borrows code, structure, and even its name very liberally from the trul
 
 Also, without contributors the project wouldn't be nearly as awesome. So many thanks to:
 
+* [Logan Bowers](https://github.com/loganb)
+* [Lane LaRue](https://github.com/luxx)
+* [Craig Heneveld](https://github.com/cheneveld)
 * [Anantha Kumaran](https://github.com/ananthakumaran)
 * [Jason Dew](https://github.com/jasondew)
 
 ## Running the tests
 
-Running the tests is fairly simple. In one window, run `fake_dynamo`, and in the other, use `rake`.
+Running the tests is fairly simple. In one window, run `fake_dynamo --port 4567`, and in the other, use `rake`.
 
 ## Copyright
 
-Copyright (c) 2012 Josh Symonds. See LICENSE.txt for further details.
+Copyright (c) 2012 Josh Symonds.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/VERSION

@@ -1 +1 @@
-0.5.0
+0.6.0

data/lib/dynamoid/adapter.rb

@@ -45,16 +45,17 @@ module Dynamoid
     #
     # @param [String] table the name of the table to write the object to
     # @param [Object] object the object itself
+    # @param [Hash] options Options that are passed to the put_item call
     #
     # @return [Object] the persisted object
     #
     # @since 0.2.0
-    def write(table, object)
+    def write(table, object, options = nil)
       if Dynamoid::Config.partitioning? && object[:id]
         object[:id] = "#{object[:id]}.#{Random.rand(Dynamoid::Config.partition_size)}"
         object[:updated_at] = Time.now.to_f
       end
-      put_item(table, object)
+      put_item(table, object, options)
     end
 
     # Read one or many keys from the selected table. This method intelligently calls batch_get or get on the underlying adapter depending on
@@ -73,7 +74,7 @@ module Dynamoid
         ids = ids.collect{|id| range_key ? [id, range_key] : id}
         if Dynamoid::Config.partitioning?
           results = batch_get_item(table => id_with_partitions(ids))
-          {table => result_for_partition(results[table])}
+          {table => result_for_partition(results[table],table)}
         else
           batch_get_item(table => ids)
         end
@@ -81,7 +82,7 @@ module Dynamoid
         if Dynamoid::Config.partitioning?
           ids = range_key ? [[ids, range_key]] : ids
           results = batch_get_item(table => id_with_partitions(ids))
-          result_for_partition(results[table]).first
+          result_for_partition(results[table],table).first
         else
           get_item(table, ids, options)
         end
@@ -91,15 +92,31 @@ module Dynamoid
     # Delete an item from a table. If partitioning is turned on, deletes all partitioned keys as well.
     #
     # @param [String] table the name of the table to write the object to
-    # @param [String] id the id of the record
-    # @param [Number] range_key the range key of the record
+    # @param [Array] ids to delete, can also be a string of just one id
+    # @param [Array] range_key of the record to delete, can also be a string of just one range_key
     #
-    # @since 0.2.0
-    def delete(table, id, options = {})
-      if Dynamoid::Config.partitioning?
-        id_with_partitions(id).each {|i| delete_item(table, i, options)}
+    def delete(table, ids, options = {})
+      range_key = options[:range_key] #array of range keys that matches the ids passed in
+      if ids.respond_to?(:each)
+        if range_key.respond_to?(:each)
+          #turn ids into array of arrays each element being hash_key, range_key
+          ids = ids.each_with_index.map{|id,i| [id,range_key[i]]}
+        else
+          ids = range_key ? [[ids, range_key]] : ids
+        end
+        
+        if Dynamoid::Config.partitioning?
+          batch_delete_item(table => id_with_partitions(ids))
+        else
+          batch_delete_item(table => ids)
+        end
       else
-        delete_item(table, id, options)
+        if Dynamoid::Config.partitioning?
+          ids = range_key ? [[ids, range_key]] : ids
+          batch_delete_item(table => id_with_partitions(ids))
+        else
+          delete_item(table, ids, options)
+        end
       end
     end
 
@@ -112,7 +129,7 @@ module Dynamoid
     def scan(table, query, opts = {})
       if Dynamoid::Config.partitioning?
         results = benchmark('Scan', table, query) {adapter.scan(table, query, opts)}
-        result_for_partition(results)
+        result_for_partition(results,table)
       else
         benchmark('Scan', table, query) {adapter.scan(table, query, opts)}
       end
@@ -141,24 +158,59 @@ module Dynamoid
     def id_with_partitions(ids)
       Array(ids).collect {|id| (0...Dynamoid::Config.partition_size).collect{|n| id.is_a?(Array) ? ["#{id.first}.#{n}", id.last] : "#{id}.#{n}"}}.flatten(1)
     end
+    
+    #Get original id (hash_key) and partiton number from a hash_key
+    #
+    # @param [String] id the id or hash_key of a record, ex. xxxxx.13
+    #
+    # @return [String,String] original_id and the partition number, ex original_id = xxxxx partition = 13
+    def get_original_id_and_partition id
+      partition = id.split('.').last
+      id = id.split(".#{partition}").first
+
+      return id, partition
+    end
 
-    # Takes an array of results that are partitioned, find the most recently updated one, and return only it. Compares each result by
+    # Takes an array of query results that are partitioned, find the most recently updated ones that share an id and range_key, and return only the most recently updated. Compares each result by
     # their id and updated_at attributes; if the updated_at is the greatest, then it must be the correct result.
     #
     # @param [Array] returned partitioned results from a query
+    # @param [String] table_name the name of the table
     #
     # @since 0.2.0
-    def result_for_partition(results)
-      {}.tap do |hash|
-        Array(results).each do |result|
-          next if result.nil?
-          id = result[:id].split('.').first
-          if !hash[id] || (result[:updated_at] > hash[id][:updated_at])
-            result[:id] = id
-            hash[id] = result
+    def result_for_partition(results, table_name)
+      table = Dynamoid::Adapter::AwsSdk.get_table(table_name)
+      
+      if table.range_key     
+        range_key_name = table.range_key.name.to_sym
+        
+        final_hash = {}
+        
+        results.each do |record|
+          test_record = final_hash[record[range_key_name]]
+          
+          if test_record.nil? || ((record[range_key_name] == test_record[range_key_name]) && (record[:updated_at] > test_record[:updated_at]))
+            #get ride of our partition and put it in the array with the range key
+            record[:id], partition = get_original_id_and_partition  record[:id]
+            final_hash[record[range_key_name]] = record
           end
         end
-      end.values
+  
+        return final_hash.values
+      else
+        {}.tap do |hash|
+          Array(results).each do |result|
+            next if result.nil?
+            #Need to find the value of id with out the . and partition number
+            id, partition = get_original_id_and_partition result[:id]
+  
+            if !hash[id] || (result[:updated_at] > hash[id][:updated_at])
+              result[:id] = id
+              hash[id] = result
+            end
+          end
+        end.values
+      end
     end
 
     # Delegate all methods that aren't defind here to the underlying adapter.
@@ -168,7 +220,47 @@ module Dynamoid
       return benchmark(method, *args) {adapter.send(method, *args, &block)} if @adapter.respond_to?(method)
       super
     end
+    
+    # Query the DynamoDB table. This employs DynamoDB's indexes so is generally faster than scanning, but is
+    # only really useful for range queries, since it can only find by one hash key at once. Only provide
+    # one range key to the hash. If paritioning is on, will run a query for every parition and join the results
+    #
+    # @param [String] table_name the name of the table
+    # @param [Hash] opts the options to query the table with
+    # @option opts [String] :hash_value the value of the hash key to find
+    # @option opts [Range] :range_value find the range key within this range
+    # @option opts [Number] :range_greater_than find range keys greater than this
+    # @option opts [Number] :range_less_than find range keys less than this
+    # @option opts [Number] :range_gte find range keys greater than or equal to this
+    # @option opts [Number] :range_lte find range keys less than or equal to this
+    #
+    # @return [Array] an array of all matching items
+    #
+    def query(table_name, opts = {})
+      
+      unless Dynamoid::Config.partitioning?
+        #no paritioning? just pass to the standard query method
+        Dynamoid::Adapter::AwsSdk.query(table_name, opts)
+      else
+        #get all the hash_values that could be possible
+        ids = id_with_partitions(opts[:hash_value])
 
-  end
+        #lets not overwrite with the original options
+        modified_options = opts.clone     
+        results = []
+        
+        #loop and query on each of the partition ids
+        ids.each do |id|
+          modified_options[:hash_value] = id
+
+          query_result = Dynamoid::Adapter::AwsSdk.query(table_name, modified_options)
+          query_result = [query_result] if !query_result.is_a?(Array)
 
+          results = results + query_result unless query_result.nil? 
+        end 
+        
+        result_for_partition results, table_name
+      end
+    end
+  end
 end

data/lib/dynamoid/adapter/aws_sdk.rb

@@ -15,10 +15,30 @@ module Dynamoid
       # Establish the connection to DynamoDB.
       #
       # @return [AWS::DynamoDB::Connection] the raw DynamoDB connection
-      #
+      # Call DynamoDB new, with no parameters. 
+      # Make sure the aws.yml file or aws.rb file, refer the link for more details. 
+      #https://github.com/amazonwebservices/aws-sdk-for-ruby
+      # 1. Create config/aws.yml as follows:
+      # Fill in your AWS Access Key ID and Secret Access Key
+      # http://aws.amazon.com/security-credentials
+      #access_key_id: REPLACE_WITH_ACCESS_KEY_ID
+      #secret_access_key: REPLACE_WITH_SECRET_ACCESS_KEY
+      #(or)
+      #2, Create config/initializers/aws.rb as follows:
+      # load the libraries
+      #require 'aws'
+      # log requests using the default rails logger
+      #AWS.config(:logger => Rails.logger)
+      # load credentials from a file
+      #config_path = File.expand_path(File.dirname(__FILE__)+"/../aws.yml")
+      #AWS.config(YAML.load(File.read(config_path)))
+      #Additionally include any of the dynamodb paramters as needed 
+      #(eg: if you would like to change the dynamodb endpoint, then add the parameter in 
+      # the following paramter in the file  aws.yml or aws.rb 
+      # dynamo_db_endpoint : dynamodb.ap-southeast-1.amazonaws.com)
       # @since 0.2.0
       def connect!
-        @@connection = AWS::DynamoDB.new(:access_key_id => Dynamoid::Config.access_key, :secret_access_key => Dynamoid::Config.secret_key, :dynamo_db_endpoint => Dynamoid::Config.endpoint, :use_ssl => Dynamoid::Config.use_ssl, :dynamo_db_port => Dynamoid::Config.port)
+      @@connection = AWS::DynamoDB.new
       end
 
       # Return the established connection.
@@ -54,6 +74,29 @@ module Dynamoid
         end
         hash
       end
+      
+      # Delete many items at once from DynamoDB. More efficient than delete each item individually.
+      #
+      # @example Delete IDs 1 and 2 from the table testtable
+      #   Dynamoid::Adapter::AwsSdk.batch_delete_item('table1' => ['1', '2'])
+      #or
+      #   Dynamoid::Adapter::AwsSdk.batch_delete_item('table1' => [['hk1', 'rk2'], ['hk1', 'rk2']]]))
+      #
+      # @param [Hash] options the hash of tables and IDs to delete
+      #
+      # @return nil
+      #
+      def batch_delete_item(options)
+        return nil if options.all?{|k, v| v.empty?}
+        options.each do |t, ids|
+          Array(ids).in_groups_of(25, false) do |group|
+            batch = AWS::DynamoDB::BatchWrite.new(:config => @@connection.config)
+            batch.delete(t,group)
+            batch.process!          
+          end
+        end
+        nil
+      end
 
       # Create a table on DynamoDB. This usually takes a long time to complete.
       #
@@ -111,9 +154,6 @@ module Dynamoid
       # @return [Hash] a hash representing the raw item in DynamoDB
       #
       # @since 0.2.0
-
-
-
       def get_item(table_name, key, options = {})
         range_key = options.delete(:range_key)
         table = get_table(table_name)
@@ -150,9 +190,12 @@ module Dynamoid
       # @param [Object] object a hash or Dynamoid object to persist
       #
       # @since 0.2.0
-      def put_item(table_name, object)
+      def put_item(table_name, object, options = nil)
         table = get_table(table_name)
-        table.items.create(object.delete_if{|k, v| v.nil? || (v.respond_to?(:empty?) && v.empty?)})
+        table.items.create(
+          object.delete_if{|k, v| v.nil? || (v.respond_to?(:empty?) && v.empty?)},
+          options || {}
+        )
       end
 
       # Query the DynamoDB table. This employs DynamoDB's indexes so is generally faster than scanning, but is

data/lib/dynamoid/config.rb

@@ -23,7 +23,7 @@ module Dynamoid
     option :partition_size, :default => 200
     option :endpoint, :default => 'dynamodb.us-east-1.amazonaws.com'
     option :use_ssl, :default => true
-    option :port, :default => '80'
+    option :port, :default => '443'
     option :included_models, :default => []
     option :identity_map, :default => false
 

data/lib/dynamoid/criteria.rb

@@ -9,7 +9,7 @@ module Dynamoid
     
     module ClassMethods
       
-      [:where, :all, :first, :each, :limit, :start].each do |meth|
+      [:where, :all, :first, :each, :limit, :start, :scan_index_forward].each do |meth|
         # Return a criteria chain in response to a method that will begin or end a chain. For more information, 
         # see Dynamoid::Criteria::Chain.
         #

data/lib/dynamoid/criteria/chain.rb

@@ -16,6 +16,7 @@ module Dynamoid #:nodoc:
         @query = {}
         @source = source
         @consistent_read = false
+        @scan_index_forward = true
       end
 
       # The workhorse method of the criteria chain. Each key in the passed in hash will become another criteria that the
@@ -45,6 +46,63 @@ module Dynamoid #:nodoc:
       def all
         records
       end
+      
+      # Destroys all the records matching the criteria.
+      #
+      def destroy_all
+        ids = []
+        
+        if range?
+          ranges = []
+          Dynamoid::Adapter.query(source.table_name, range_query).collect do |hash| 
+            ids << hash[source.hash_key.to_sym]
+            ranges << hash[source.range_key.to_sym]
+          end
+          
+          Dynamoid::Adapter.delete(source.table_name, ids,{:range_key => ranges})
+        elsif index
+          #TODO: test this throughly and find a way to delete all index table records for one source record
+          if index.range_key?
+            results = Dynamoid::Adapter.query(index.table_name, index_query.merge(consistent_opts))
+          else
+            results = Dynamoid::Adapter.read(index.table_name, index_query[:hash_value], consistent_opts)
+          end
+          
+          results.collect do |hash| 
+            ids << hash[source.hash_key.to_sym]
+            index_ranges << hash[source.range_key.to_sym]
+          end
+        
+          unless ids.nil? || ids.empty?
+            ids = ids.to_a
+  
+            if @start
+              ids = ids.drop_while { |id| id != @start.hash_key }.drop(1)
+              index_ranges = index_ranges.drop_while { |range| range != @start.hash_key }.drop(1) unless index_ranges.nil?
+            end
+  
+            if @limit           
+              ids = ids.take(@limit) 
+              index_ranges = index_ranges.take(@limit)
+            end
+            
+            Dynamoid::Adapter.delete(source.table_name, ids)
+            
+            if index.range_key?
+              Dynamoid::Adapter.delete(index.table_name, ids,{:range_key => index_ranges})
+            else
+              Dynamoid::Adapter.delete(index.table_name, ids)
+            end
+            
+          end
+        else
+          Dynamoid::Adapter.scan(source.table_name, query, scan_opts).collect do |hash| 
+            ids << hash[source.hash_key.to_sym]
+          end
+          
+          Dynamoid::Adapter.delete(source.table_name, ids)
+        end   
+      end
 
       # Returns the first record matching the criteria.
       #
@@ -63,6 +121,11 @@ module Dynamoid #:nodoc:
         self
       end
 
+      def scan_index_forward(scan_index_forward)
+        @scan_index_forward = scan_index_forward
+        self
+      end
+
       # Allows you to use the results of a search as an enumerable over the results found.
       #
       # @since 0.2.0
@@ -145,7 +208,7 @@ module Dynamoid #:nodoc:
           raise Dynamoid::Errors::InvalidQuery, 'Consistent read is not supported by SCAN operation'
         end
 
-        Dynamoid::Adapter.scan(source.table_name, query, query_opts).collect {|hash| source.from_database(hash) }
+        Dynamoid::Adapter.scan(source.table_name, query, scan_opts).collect {|hash| source.from_database(hash) }
       end
 
       # Format the provided query so that it can be used to query results from DynamoDB.
@@ -190,7 +253,7 @@ module Dynamoid #:nodoc:
       def range_query
         opts = { :hash_value => query[source.hash_key] }
         if key = query.keys.find { |k| k.to_s.include?('.') }
-          opts.merge!(range_key(key))
+          opts.merge!(range_hash(key))
         end
         opts.merge(query_opts).merge(consistent_opts)
       end
@@ -214,15 +277,24 @@ module Dynamoid #:nodoc:
       end
 
       def start_key
-        key = { :hash_key_element => { 'S' => @start.hash_key } }
+ 	      hash_key_type = @start.class.attributes[@start.class.hash_key][:type] == :string ? 'S' : 'N'
+        key = { :hash_key_element => { hash_key_type => @start.hash_key.to_s } }
         if range_key = @start.class.range_key
           range_key_type = @start.class.attributes[range_key][:type] == :string ? 'S' : 'N'
-          key.merge!({:range_key_element => { range_key_type => @start.send(range_key) } })
+          key.merge!({:range_key_element => { range_key_type => @start.send(range_key).to_s } })
         end
         key
       end
 
       def query_opts
+        opts = {}
+        opts[:limit] = @limit if @limit
+        opts[:next_token] = start_key if @start
+        opts[:scan_index_forward] = @scan_index_forward
+        opts
+      end
+      
+      def scan_opts
         opts = {}
         opts[:limit] = @limit if @limit
         opts[:next_token] = start_key if @start

data/lib/dynamoid/document.rb

@@ -8,8 +8,9 @@ module Dynamoid #:nodoc:
     include Dynamoid::Components
 
     included do
-      class_attribute :options
+      class_attribute :options, :read_only_attributes
       self.options = {}
+      self.read_only_attributes = []
 
       Dynamoid::Config.included_models << self
     end
@@ -29,6 +30,10 @@ module Dynamoid #:nodoc:
         self.options = options
       end
 
+      def attr_readonly(*read_only_attributes)
+        self.read_only_attributes.concat read_only_attributes.map(&:to_s)
+      end
+
       # Returns the read_capacity for this table.
       #
       # @since 0.4.0

data/lib/dynamoid/fields.rb

@@ -81,7 +81,23 @@ module Dynamoid #:nodoc:
     # @since 0.2.0
     def update_attributes(attributes)
       attributes.each {|attribute, value| self.write_attribute(attribute, value)}
-      save
+      if self.new_record # if never saved save.
+        save
+      else # update attributes if we have saved.
+        # next if self.read_only_attributes.include? attribute.to_s put this back in.
+        run_callbacks(:save) do
+          update! do |u|
+            attributes.each do |attribute, value|
+              u.set attribute => dump_field(
+                self.read_attribute(attribute),
+                self.class.attributes[attribute.to_sym]
+              )
+            end
+          end
+        end
+        
+        save
+      end
     end
 
     # Update a single attribute, saving the object afterwards.

data/lib/dynamoid/persistence.rb

@@ -17,7 +17,7 @@ module Dynamoid
       #
       # @since 0.2.0
       def table_name
-        "#{Dynamoid::Config.namespace}_#{options[:name] ? options[:name] : self.name.downcase.pluralize}"
+        "#{Dynamoid::Config.namespace}_#{options[:name] ? options[:name] : self.name.split('::').last.downcase.pluralize}"
       end
 
       # Creates a table.
@@ -53,7 +53,7 @@ module Dynamoid
       #
       # @since 0.2.0
       def table_exists?(table_name)
-        Dynamoid::Adapter.tables.include?(table_name)
+        Dynamoid::Adapter.tables ? Dynamoid::Adapter.tables.include?(table_name) : false
       end
 
       def from_database(attrs = {})
@@ -109,6 +109,15 @@ module Dynamoid
           else
             value
           end
+        when :boolean
+          # persisted as 't', but because undump is called during initialize it can come in as true
+          if value == 't' || value == true
+            true
+          elsif value == 'f' || value == false
+            false
+          else
+            raise ArgumentError, "Boolean column neither true nor false"
+          end
         end
       end
 
@@ -146,9 +155,12 @@ module Dynamoid
     # @since 0.2.0
     def save(options = {})
       self.class.create_table
-
+      
       if new_record?
-        run_callbacks(:create) { persist }
+        conditions = { :unless_exists => [self.class.hash_key]}
+        conditions[:unless_exists] << range_key if(range_key)
+
+        run_callbacks(:create) { persist(conditions) }
       else
         persist
       end
@@ -225,6 +237,10 @@ module Dynamoid
         value.to_time.to_f
       when :serialized
         options[:serializer] ? options[:serializer].dump(value) : value.to_yaml
+      when :boolean
+        value.to_s[0]
+      else
+        raise ArgumentError, "Unknown type #{options[:type]}"
       end
     end
 
@@ -232,10 +248,10 @@ module Dynamoid
     # save its indexes.
     #
     # @since 0.2.0
-    def persist
+    def persist(conditions = nil)
       run_callbacks(:save) do
         self.hash_key = SecureRandom.uuid if self.hash_key.nil? || self.hash_key.blank?
-        Dynamoid::Adapter.write(self.class.table_name, self.dump)
+        Dynamoid::Adapter.write(self.class.table_name, self.dump, conditions)
         save_indexes
         @new_record = false
         true

data/spec/app/models/address.rb

@@ -3,6 +3,7 @@ class Address
   
   field :city
   field :options, :serialized
+  field :deliverable, :boolean
 
   def zip_code=(zip_code)
     self.city = "Chicago"

data/spec/dynamoid/adapter/aws_sdk_spec.rb

@@ -16,11 +16,12 @@ describe Dynamoid::Adapter::AwsSdk do
       end
     end
 
-    context 'with a preexisting table' do
+    context 'with a preexisting table without paritioning' do
       before(:all) do
         Dynamoid::Adapter.create_table('dynamoid_tests_TestTable1', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable1')
         Dynamoid::Adapter.create_table('dynamoid_tests_TestTable2', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable2')
         Dynamoid::Adapter.create_table('dynamoid_tests_TestTable3', :id, :range_key => { :range => :number }) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable3')
+        Dynamoid::Adapter.create_table('dynamoid_tests_TestTable4', :id, :range_key => { :range => :number }) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable4')
       end
 
       # GetItem, PutItem and DeleteItem
@@ -99,6 +100,56 @@ describe Dynamoid::Adapter::AwsSdk do
         results['dynamoid_tests_TestTable3'].should include({:name => 'Josh', :id => '1', :range => 1.0})
         results['dynamoid_tests_TestTable3'].should include({:name => 'Justin', :id => '2', :range => 2.0})
       end
+      
+      # BatchDeleteItem
+      it "performs BatchDeleteItem with singular keys" do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable2', {:id => '1', :name => 'Justin'})
+
+        Dynamoid::Adapter.batch_delete_item('dynamoid_tests_TestTable1' => ['1'], 'dynamoid_tests_TestTable2' => ['1'])
+        
+        results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable1' => '1', 'dynamoid_tests_TestTable2' => '1')
+        results.size.should == 0
+        
+        results['dynamoid_tests_TestTable1'].should_not include({:name => 'Josh', :id => '1'})
+        results['dynamoid_tests_TestTable2'].should_not include({:name => 'Justin', :id => '1'})
+      end
+
+      it "performs BatchDeleteItem with multiple keys" do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Justin'})
+
+        Dynamoid::Adapter.batch_delete_item('dynamoid_tests_TestTable1' => ['1', '2'])
+        
+        results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable1' => ['1', '2'])
+        results.size.should == 0
+        
+        results['dynamoid_tests_TestTable1'].should_not include({:name => 'Josh', :id => '1'})
+        results['dynamoid_tests_TestTable1'].should_not include({:name => 'Justin', :id => '2'})
+      end
+
+      it 'performs BatchDeleteItem with one ranged key' do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :name => 'Josh', :range => 1.0})
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '2', :name => 'Justin', :range => 2.0})
+
+        Dynamoid::Adapter.batch_delete_item('dynamoid_tests_TestTable3' => [['1', 1.0]])
+        results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable3' => [['1', 1.0]])
+        results.size.should == 0
+
+        results['dynamoid_tests_TestTable3'].should_not include({:name => 'Josh', :id => '1', :range => 1.0})
+      end
+
+      it 'performs BatchDeleteItem with multiple ranged keys' do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :name => 'Josh', :range => 1.0})
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '2', :name => 'Justin', :range => 2.0})
+
+        Dynamoid::Adapter.batch_delete_item('dynamoid_tests_TestTable3' => [['1', 1.0],['2', 2.0]])
+        results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable3' => [['1', 1.0],['2', 2.0]])
+        results.size.should == 0
+         
+        results['dynamoid_tests_TestTable3'].should_not include({:name => 'Josh', :id => '1', :range => 1.0})
+        results['dynamoid_tests_TestTable3'].should_not include({:name => 'Justin', :id => '2', :range => 2.0})
+      end
 
       # ListTables
       it 'performs ListTables' do
@@ -174,6 +225,152 @@ describe Dynamoid::Adapter::AwsSdk do
 
         Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', {}).should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
       end
+      
+      context 'correct ordering ' do
+        before do
+          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 1, :range => 1.0})
+          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 2, :range => 2.0})
+          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 3, :range => 3.0})
+          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 4, :range => 4.0})
+          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 5, :range => 5.0})
+          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 6, :range => 6.0})
+        end
+
+        it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward true' do
+          query = Dynamoid::Adapter.query('dynamoid_tests_TestTable4', :hash_value => '1', :range_greater_than => 0, :scan_index_forward => true)
+          query[0].should == {:id => '1', :order => 1, :range => BigDecimal.new(1)}
+          query[1].should == {:id => '1', :order => 2, :range => BigDecimal.new(2)}
+          query[2].should == {:id => '1', :order => 3, :range => BigDecimal.new(3)}
+          query[3].should == {:id => '1', :order => 4, :range => BigDecimal.new(4)}
+          query[4].should == {:id => '1', :order => 5, :range => BigDecimal.new(5)}
+          query[5].should == {:id => '1', :order => 6, :range => BigDecimal.new(6)}
+        end
+        
+        it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward false' do
+          query = Dynamoid::Adapter.query('dynamoid_tests_TestTable4', :hash_value => '1', :range_greater_than => 0, :scan_index_forward => false)
+          query[5].should == {:id => '1', :order => 1, :range => BigDecimal.new(1)}
+          query[4].should == {:id => '1', :order => 2, :range => BigDecimal.new(2)}
+          query[3].should == {:id => '1', :order => 3, :range => BigDecimal.new(3)}
+          query[2].should == {:id => '1', :order => 4, :range => BigDecimal.new(4)}
+          query[1].should == {:id => '1', :order => 5, :range => BigDecimal.new(5)}
+          query[0].should == {:id => '1', :order => 6, :range => BigDecimal.new(6)}
+        end
+      end
+    end
+    
+    context 'with a preexisting table with paritioning' do
+      before(:all) do
+        @previous_value = Dynamoid::Config.partitioning
+        Dynamoid::Config.partitioning = true
+        
+        Dynamoid::Adapter.create_table('dynamoid_tests_TestTable1', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable1')
+        Dynamoid::Adapter.create_table('dynamoid_tests_TestTable2', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable2')
+        Dynamoid::Adapter.create_table('dynamoid_tests_TestTable3', :id, :range_key => { :range => :number }) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable3')
+      end
+
+      after(:all) do
+        Dynamoid::Config.partitioning = @previous_value
+      end
+
+      # Query
+      it 'performs query on a table and returns items' do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
+
+        Dynamoid::Adapter.query('dynamoid_tests_TestTable1', :hash_value => '1').first.should == { :id=> '1', :name=>"Josh" }
+      end
+
+      it 'performs query on a table and returns items if there are multiple items' do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2.1', :name => 'Justin'})
+
+        Dynamoid::Adapter.query('dynamoid_tests_TestTable1', :hash_value => '1').first.should == { :id=> '1', :name=>"Josh" }
+      end
+
+      context 'range queries' do
+        before do
+          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1.1', :range => 1.0})
+          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1.1', :range => 3.0})
+        end
+
+        it 'performs query on a table with a range and selects items in a range' do
+          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_value => 0.0..3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
+        end
+
+        it 'performs query on a table with a range and selects items greater than' do
+          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_greater_than => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(3)}]
+        end
+
+        it 'performs query on a table with a range and selects items less than' do
+          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_less_than => 2.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}]
+        end
+
+        it 'performs query on a table with a range and selects items gte' do
+          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_gte => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
+        end
+
+        it 'performs query on a table with a range and selects items lte' do
+          Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_lte => 3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
+        end
+      end
+
+      # Scan
+      it 'performs scan on a table and returns items' do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
+
+        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
+      end
+
+      it 'performs scan on a table and returns items if there are multiple items but only one match' do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2.1', :name => 'Justin'})
+
+        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
+      end
+
+      it 'performs scan on a table and returns multiple items if there are multiple matches' do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2.1', :name => 'Josh'})
+
+        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
+      end
+
+      it 'performs scan on a table and returns all items if no criteria are specified' do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2.1', :name => 'Josh'})
+
+        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', {}).should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
+      end
+      
+      context 'correct ordering ' do
+        before do
+          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.1', :range => 1.0})
+          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.2', :range => 2.0})
+          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.3', :range => 3.0})
+          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.4', :range => 4.0})
+          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.5', :range => 5.0})
+          Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.6', :range => 6.0})
+        end
+
+        it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward true' do
+          query = Dynamoid::Adapter.query('dynamoid_tests_TestTable4', :hash_value => '1', :range_greater_than => 0, :scan_index_forward => true)
+          query[0].should == {:id => '1', :range => BigDecimal.new(1)}
+          query[1].should == {:id => '1', :range => BigDecimal.new(2)}
+          query[2].should == {:id => '1', :range => BigDecimal.new(3)}
+          query[3].should == {:id => '1', :range => BigDecimal.new(4)}
+          query[4].should == {:id => '1', :range => BigDecimal.new(5)}
+          query[5].should == {:id => '1', :range => BigDecimal.new(6)}
+        end
+        
+        it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward false' do
+          query = Dynamoid::Adapter.query('dynamoid_tests_TestTable4', :hash_value => '1', :range_greater_than => 0, :scan_index_forward => false)
+          query[5].should == {:id => '1', :range => BigDecimal.new(1)}
+          query[4].should == {:id => '1', :range => BigDecimal.new(2)}
+          query[3].should == {:id => '1', :range => BigDecimal.new(3)}
+          query[2].should == {:id => '1', :range => BigDecimal.new(4)}
+          query[1].should == {:id => '1', :range => BigDecimal.new(5)}
+          query[0].should == {:id => '1', :range => BigDecimal.new(6)}
+        end
+      end
     end
 
     # DescribeTable

data/spec/dynamoid/adapter_spec.rb

@@ -25,7 +25,7 @@ describe "Dynamoid::Adapter" do
     end
     
     it 'writes through the adapter' do
-      Dynamoid::Adapter.expects(:put_item).with('dynamoid_tests_TestTable', {:id => '123'}).returns(true)
+      Dynamoid::Adapter.expects(:put_item).with('dynamoid_tests_TestTable', {:id => '123'}, nil).returns(true)
 
       Dynamoid::Adapter.write('dynamoid_tests_TestTable', {:id => '123'})
     end
@@ -42,6 +42,18 @@ describe "Dynamoid::Adapter" do
       Dynamoid::Adapter.read('dynamoid_tests_TestTable', ['1', '2'])
     end
     
+    it 'delete through the adapter for one ID' do
+      Dynamoid::Adapter.expects(:delete_item).with('dynamoid_tests_TestTable', '123', {}).returns(nil)
+
+      Dynamoid::Adapter.delete('dynamoid_tests_TestTable', '123')
+    end
+    
+    it 'deletes through the adapter for many IDs' do
+      Dynamoid::Adapter.expects(:batch_delete_item).with({'dynamoid_tests_TestTable' => ['1', '2']}).returns(nil)
+
+      Dynamoid::Adapter.delete('dynamoid_tests_TestTable', ['1', '2'])
+    end
+    
     it 'reads through the adapter for one ID and a range key' do
       Dynamoid::Adapter.expects(:get_item).with('dynamoid_tests_TestTable', '123', :range_key => 2.0).returns(true)
 
@@ -53,6 +65,18 @@ describe "Dynamoid::Adapter" do
 
       Dynamoid::Adapter.read('dynamoid_tests_TestTable', ['1', '2'], :range_key => 2.0)
     end
+    
+    it 'deletes through the adapter for one ID and a range key' do
+      Dynamoid::Adapter.expects(:delete_item).with('dynamoid_tests_TestTable', '123', :range_key => 2.0).returns(nil)
+
+      Dynamoid::Adapter.delete('dynamoid_tests_TestTable', '123', :range_key => 2.0)      
+    end
+    
+    it 'deletes through the adapter for many IDs and a range key' do
+      Dynamoid::Adapter.expects(:batch_delete_item).with({'dynamoid_tests_TestTable' => [['1', 2.0], ['2', 2.0]]}).returns(nil)
+
+      Dynamoid::Adapter.delete('dynamoid_tests_TestTable', ['1', '2'], :range_key => [2.0,2.0])
+    end
   end
   
   context 'with partitioning' do
@@ -109,9 +133,38 @@ describe "Dynamoid::Adapter" do
       @time = DateTime.now
       @array =[{:id => '1.0', :updated_at => @time - 6.hours}, {:id => '1.1', :updated_at => @time - 3.hours}, {:id => '1.2', :updated_at => @time - 1.hour}, {:id => '1.3', :updated_at => @time - 6.hours}, {:id => '2.0', :updated_at => @time}]
     
-      Dynamoid::Adapter.result_for_partition(@array).should =~ [{:id => '1', :updated_at => @time - 1.hour}, {:id => '2', :updated_at => @time}]
+      Dynamoid::Adapter.result_for_partition(@array,"dynamoid_tests_TestTable").should =~ [{:id => '1', :updated_at => @time - 1.hour}, {:id => '2', :updated_at => @time}]
     end
     
+    it 'returns a valid original id and partition number' do
+      @id = "12345.387327.-sdf3"
+      @partition_number = "4"
+      Dynamoid::Adapter.get_original_id_and_partition("#{@id}.#{@partition_number}").should == [@id, @partition_number]
+    end
+    
+    it 'delete through the adapter for one ID' do
+      Dynamoid::Adapter.expects(:batch_delete_item).with('dynamoid_tests_TestTable' => (0...Dynamoid::Config.partition_size).collect{|n| "123.#{n}"}).returns(nil)
+
+      Dynamoid::Adapter.delete('dynamoid_tests_TestTable', '123')
+    end
+    
+    it 'deletes through the adapter for many IDs' do
+      Dynamoid::Adapter.expects(:batch_delete_item).with('dynamoid_tests_TestTable' => (0...Dynamoid::Config.partition_size).collect{|n| "1.#{n}"} + (0...Dynamoid::Config.partition_size).collect{|n| "2.#{n}"}).returns(nil)
+
+      Dynamoid::Adapter.delete('dynamoid_tests_TestTable', ['1', '2'])
+    end
+    
+    it 'deletes through the adapter for one ID and a range key' do
+      Dynamoid::Adapter.expects(:batch_delete_item).with('dynamoid_tests_TestTable' => (0...Dynamoid::Config.partition_size).collect{|n| ["123.#{n}", 2.0]}).returns(nil)
+
+      Dynamoid::Adapter.delete('dynamoid_tests_TestTable', '123', :range_key => 2.0)      
+    end
+    
+    it 'deletes through the adapter for many IDs and a range key' do
+      Dynamoid::Adapter.expects(:batch_delete_item).with('dynamoid_tests_TestTable' => (0...Dynamoid::Config.partition_size).collect{|n| ["1.#{n}", 2.0]} + (0...Dynamoid::Config.partition_size).collect{|n| ["2.#{n}", 2.0]}).returns(nil)
+
+      Dynamoid::Adapter.delete('dynamoid_tests_TestTable', ['1', '2'], :range_key => [2.0,2.0])
+    end
   end
 
 end

data/spec/dynamoid/criteria/chain_spec.rb

@@ -136,5 +136,28 @@ describe "Dynamoid::Associations::Chain" do
       @chain.send(:records_with_range).should == [@tweet3]
     end
   end
+  
+  context 'destroy alls' do
+    before do
+      @tweet1 = Tweet.create(:tweet_id => "x", :group => "one")
+      @tweet2 = Tweet.create(:tweet_id => "x", :group => "two")
+      @tweet3 = Tweet.create(:tweet_id => "xx", :group => "two")
+      @chain = Dynamoid::Criteria::Chain.new(Tweet)
+    end
+    
+    it 'destroys tweet with a range simple range query' do
+      @chain.query = { :tweet_id => "x" }
+      @chain.all.size.should == 2
+      @chain.destroy_all
+      @chain.consistent.all.size.should == 0
+    end
 
+    it 'deletes one specific tweet with range' do
+      @chain = Dynamoid::Criteria::Chain.new(Tweet)
+      @chain.query = { :tweet_id => "xx", :group => "two" }
+      @chain.all.size.should == 1
+      @chain.destroy_all
+      @chain.consistent.all.size.should == 0
+    end
+  end
 end

data/spec/dynamoid/document_spec.rb

@@ -6,7 +6,7 @@ describe "Dynamoid::Document" do
     @address = Address.new
     
     @address.new_record.should be_true
-    @address.attributes.should == {:id=>nil, :created_at=>nil, :updated_at=>nil, :city=>nil, :options=>nil}
+    @address.attributes.should == {:id=>nil, :created_at=>nil, :updated_at=>nil, :city=>nil, :options=>nil, :deliverable => nil}
   end
 
   it 'responds to will_change! methods for all fields' do
@@ -22,7 +22,7 @@ describe "Dynamoid::Document" do
     
     @address.new_record.should be_true
     
-    @address.attributes.should == {:id=>nil, :created_at=>nil, :updated_at=>nil, :city=>"Chicago", :options=>nil}
+    @address.attributes.should == {:id=>nil, :created_at=>nil, :updated_at=>nil, :city=>"Chicago", :options=>nil, :deliverable => nil}
   end
 
   it 'initializes a new document with a virtual attribute' do
@@ -30,7 +30,7 @@ describe "Dynamoid::Document" do
     
     @address.new_record.should be_true
     
-    @address.attributes.should == {:id=>nil, :created_at=>nil, :updated_at=>nil, :city=>"Chicago", :options=>nil}
+    @address.attributes.should == {:id=>nil, :created_at=>nil, :updated_at=>nil, :city=>"Chicago", :options=>nil, :deliverable => nil}
   end
 
   it 'allows interception of write_attribute on load' do

data/spec/dynamoid/fields_spec.rb

@@ -36,13 +36,13 @@ describe "Dynamoid::Fields" do
     @address.updated_at.should_not be_nil
     @address.updated_at.class.should == DateTime
   end
-
+  
   context 'with a saved address' do
     before do
-      @address = Address.create
+      @address = Address.create(:deliverable => true)
       @original_id = @address.id
     end
-
+    
     it 'should write an attribute correctly' do
       @address.write_attribute(:city, 'Chicago')
     end
@@ -85,7 +85,7 @@ describe "Dynamoid::Fields" do
     end
 
     it 'returns all attributes' do
-      Address.attributes.should == {:id=>{:type=>:string}, :created_at=>{:type=>:datetime}, :updated_at=>{:type=>:datetime}, :city=>{:type=>:string}, :options=>{:type=>:serialized}}
+      Address.attributes.should == {:id=>{:type=>:string}, :created_at=>{:type=>:datetime}, :updated_at=>{:type=>:datetime}, :city=>{:type=>:string}, :options=>{:type=>:serialized}, :deliverable => {:type => :boolean}}
     end
   end
 

data/spec/dynamoid/persistence_spec.rb

@@ -89,6 +89,20 @@ describe "Dynamoid::Persistence" do
     @address.options = (hash = {:x => [1, 2], "foobar" => 3.14})
     Address.undump(@address.send(:dump))[:options].should == hash
   end
+  
+  it 'dumps a boolean field' do
+    @address.deliverable = true
+    Address.undump(@address.send(:dump))[:deliverable].should == true
+  end
+  
+  it 'raises on an invalid boolean value' do
+    expect do
+      @address.deliverable = true
+      data = @address.send(:dump)
+      data[:deliverable] = 'foo'
+      Address.undump(data)
+    end.to raise_error(ArgumentError)
+  end
 
   it 'loads a hash into a serialized field' do
     hash = {foo: :bar}
@@ -126,6 +140,38 @@ describe "Dynamoid::Persistence" do
 
     lambda {Address.create(hash)}.should_not raise_error
   end
+  
+  context 'create' do
+    {
+      Tweet   => ['with range',    { :tweet_id => 1, :group => 'abc' }],
+      Message => ['without range', { :message_id => 1, :text => 'foo', :time => DateTime.now }]
+    }.each_pair do |clazz, fields|
+      it "checks for existence of an existing object #{fields[0]}" do
+        t1 = clazz.new(fields[1])
+        t2 = clazz.new(fields[1])
+      
+        t1.save
+        expect do
+          t2.save!
+        end.to raise_exception AWS::DynamoDB::Errors::ConditionalCheckFailedException
+      end
+    end
+  end
+
+  it 'raises when dumping a column with an unknown field type' do
+    clazz = Class.new do
+      include Dynamoid::Document
+      table :name => :addresses
+
+      field :city
+      field :options, :serialized
+      field :deliverable, :bad_type_specifier
+    end
+    
+    expect do
+      clazz.new(:deliverable => true).dump
+    end.to raise_error(ArgumentError)
+  end
 
   context 'update' do
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamoid
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-22 00:00:00.000000000 Z
+date: 2012-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -362,7 +362,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 396768872286184895
+      hash: 1769474617671935621
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -371,7 +371,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Dynamoid is an ORM for Amazon's DynamoDB