dynamoid 0.4.1 → 0.5.0

data/lib/dynamoid/indexes/index.rb

@@ -48,7 +48,7 @@ module Dynamoid #:nodoc:
       #
       # @since 0.2.0
       def table_name
-        "#{Dynamoid::Config.namespace}_index_#{source.to_s.downcase}_#{name.collect(&:to_s).collect(&:pluralize).join('_and_')}"
+        "#{Dynamoid::Config.namespace}_index_" + source.table_name.sub("#{Dynamoid::Config.namespace}_", '').singularize + "_#{name.collect(&:to_s).collect(&:pluralize).join('_and_')}"
       end
 
       # Given either an object or a list of attributes, generate a hash key and a range key for the index. Optionally pass in 

data/lib/dynamoid/middleware/identity_map.rb

@@ -0,0 +1,16 @@
+module Dynamoid
+  module Middleware
+    class IdentityMap
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        Dynamoid::IdentityMap.clear
+        @app.call(env)
+      ensure
+        Dynamoid::IdentityMap.clear
+      end
+    end
+  end
+end

data/lib/dynamoid/persistence.rb

@@ -32,8 +32,7 @@ module Dynamoid
       # @since 0.4.0
       def create_table(options = {})
         if self.range_key
-          range_key_type = [:integer, :float].include?(attributes[range_key][:type]) ? :number : attributes[range_key][:type]
-          range_key_hash = { range_key => range_key_type}
+          range_key_hash = { range_key => dynamo_type(attributes[range_key][:type]) }
         else
           range_key_hash = nil
         end
@@ -57,6 +56,10 @@ module Dynamoid
         Dynamoid::Adapter.tables.include?(table_name)
       end
 
+      def from_database(attrs = {})
+        new(attrs).tap { |r| r.new_record = false }
+      end
+
       # Undump an object into a hash, converting each type from a string representation of itself into the type specified by the field.
       #
       # @since 0.2.0
@@ -75,7 +78,11 @@ module Dynamoid
       #
       # @since 0.2.0
       def undump_field(value, options)
-        return if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+        if value.nil? && (default_value = options[:default])
+          value = default_value.respond_to?(:call) ? default_value.call : default_value
+        else
+          return if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+        end
 
         case options[:type]
         when :string
@@ -105,6 +112,26 @@ module Dynamoid
         end
       end
 
+      def dynamo_type(type)
+        case type
+        when :integer, :float, :datetime
+          :number
+        when :string, :serialized
+          :string
+        else
+          raise 'unknown type'
+        end
+      end
+
+    end
+
+    # Set updated_at and any passed in field to current DateTime. Useful for things like last_login_at, etc.
+    #
+    def touch(name = nil)
+      now = DateTime.now
+      self.updated_at = now
+      attributes[name] = now if name
+      save
     end
 
     # Is this object persisted in the datastore? Required for some ActiveModel integration stuff.
@@ -120,8 +147,6 @@ module Dynamoid
     def save(options = {})
       self.class.create_table
 
-      @previously_changed = changes
-
       if new_record?
         run_callbacks(:create) { persist }
       else
@@ -131,6 +156,19 @@ module Dynamoid
       self
     end
 
+    def update!(conditions = {}, &block)
+      options = range_key ? {:range_key => dump_field(self.read_attribute(range_key), self.class.attributes[range_key])} : {}
+      new_attrs = Dynamoid::Adapter.update_item(self.class.table_name, self.hash_key, options.merge(:conditions => conditions), &block)
+      load(new_attrs)
+    end
+
+    def update(conditions = {}, &block)
+      update!(conditions, &block)
+      true
+    rescue Dynamoid::Errors::ConditionalCheckFailedException
+      false
+    end
+
     # Delete this object, but only after running callbacks for it.
     #
     # @since 0.2.0
@@ -146,7 +184,8 @@ module Dynamoid
     # @since 0.2.0
     def delete
       delete_indexes
-      Dynamoid::Adapter.delete(self.class.table_name, self.id)
+      options = range_key ? {:range_key => dump_field(self.read_attribute(range_key), self.class.attributes[range_key])} : {}
+      Dynamoid::Adapter.delete(self.class.table_name, self.hash_key, options)
     end
 
     # Dump this object's attributes into hash form, fit to be persisted into the datastore.

data/spec/app/models/message.rb

@@ -0,0 +1,9 @@
+class Message
+  include Dynamoid::Document
+
+  table name: :messages, key: :message_id, read_capacity: 200, write_capacity: 200
+
+  range :time, :datetime
+
+  field :text
+end

data/spec/app/models/tweet.rb

@@ -6,4 +6,7 @@ class Tweet
   range :group, :string
 
   field :msg
+  field :count, :integer
+  field :tags, :set
+  field :user_name
 end

data/spec/dynamoid/adapter/aws_sdk_spec.rb

@@ -2,20 +2,20 @@ require 'dynamoid/adapter/aws_sdk'
 require File.expand_path(File.dirname(__FILE__) + '../../../spec_helper')
 
 describe Dynamoid::Adapter::AwsSdk do
-  
+
   if ENV['ACCESS_KEY'] && ENV['SECRET_KEY']
-    
+
     context 'without a preexisting table' do
       # CreateTable and DeleteTable
       it 'performs CreateTable and DeleteTable' do
         table = Dynamoid::Adapter.create_table('CreateTable', :id, :range_key =>  { :created_at => :number })
-    
+
         Dynamoid::Adapter.connection.tables.collect{|t| t.name}.should include 'CreateTable'
-    
+
         Dynamoid::Adapter.delete_table('CreateTable')
       end
     end
-    
+
     context 'with a preexisting table' do
       before(:all) do
         Dynamoid::Adapter.create_table('dynamoid_tests_TestTable1', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable1')
@@ -34,20 +34,20 @@ describe Dynamoid::Adapter::AwsSdk do
         Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should == {:name => 'Josh', :id => '1'}
 
         Dynamoid::Adapter.delete_item('dynamoid_tests_TestTable1', '1')
-        
+
         Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should be_nil
       end
-      
+
       it 'performs GetItem for an item that does exist with a range key' do
         Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :name => 'Josh', :range => 2.0})
 
         Dynamoid::Adapter.get_item('dynamoid_tests_TestTable3', '1', :range_key => 2.0).should == {:name => 'Josh', :id => '1', :range => 2.0}
 
         Dynamoid::Adapter.delete_item('dynamoid_tests_TestTable3', '1', :range_key => 2.0)
-        
-        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable3', '1', :range_key => 2.0).should be_nil        
+
+        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable3', '1', :range_key => 2.0).should be_nil
       end
-      
+
       it 'performs DeleteItem for an item that does not exist' do
         Dynamoid::Adapter.delete_item('dynamoid_tests_TestTable1', '1')
 
@@ -59,53 +59,53 @@ describe Dynamoid::Adapter::AwsSdk do
 
         Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should == {:id => '1', :name => 'Josh'}
       end
-      
+
       # BatchGetItem
       it "performs BatchGetItem 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'})
-        
+
         results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable1' => '1', 'dynamoid_tests_TestTable2' => '1')
         results.size.should == 2
         results['dynamoid_tests_TestTable1'].should include({:name => 'Josh', :id => '1'})
         results['dynamoid_tests_TestTable2'].should include({:name => 'Justin', :id => '1'})
       end
-      
+
       it "performs BatchGetItem 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'})
-        
+
         results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable1' => ['1', '2'])
         results.size.should == 1
         results['dynamoid_tests_TestTable1'].should include({:name => 'Josh', :id => '1'})
         results['dynamoid_tests_TestTable1'].should include({:name => 'Justin', :id => '2'})
       end
-      
+
       it 'performs BatchGetItem 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})
-        
+
         results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable3' => [['1', 1.0]])
         results.size.should == 1
         results['dynamoid_tests_TestTable3'].should include({:name => 'Josh', :id => '1', :range => 1.0})
       end
-      
+
       it 'performs BatchGetItem 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})
-        
+
         results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable3' => [['1', 1.0],['2', 2.0]])
         results.size.should == 1
         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
-      
+
       # ListTables
       it 'performs ListTables' do
         Dynamoid::Adapter.list_tables.should include 'dynamoid_tests_TestTable1'
         Dynamoid::Adapter.list_tables.should include 'dynamoid_tests_TestTable2'
       end
-      
+
       # Query
       it 'performs query on a table and returns items' do
         Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
@@ -119,30 +119,30 @@ describe Dynamoid::Adapter::AwsSdk do
 
         Dynamoid::Adapter.query('dynamoid_tests_TestTable1', :hash_value => '1').should == { :id=> '1', :name=>"Josh" }
       end
-      
+
       context 'range queries' do
         before do
           Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :range => 1.0})
           Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :range => 3.0})
         end
 
-        it 'performs query on a table with a range and selects items in a range' do      
+        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      
+        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      
+        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      
+        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      
+        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
@@ -165,22 +165,22 @@ describe Dynamoid::Adapter::AwsSdk do
         Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
         Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Josh'})
 
-        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should == [{:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"}] 
+        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', :name => 'Josh'})
         Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Josh'})
 
-        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', {}).should == [{:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"}] 
-      end  
+        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', {}).should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
+      end
     end
-    
+
     # DescribeTable
-    
+
     # UpdateItem
-    
+
     # UpdateTable
-  
+
   end
 end

data/spec/dynamoid/criteria/chain_spec.rb

@@ -73,6 +73,14 @@ describe "Dynamoid::Associations::Chain" do
     @chain.send(:records_without_index).should == [@user]
   end
 
+  it "doesn't crash if it finds a nil id in the index" do
+    @chain.query = {:name => 'Josh', "created_at.gt" => @time - 1.day}
+    Dynamoid::Adapter.expects(:query).
+                      with("dynamoid_tests_index_user_created_ats_and_names", kind_of(Hash)).
+                      returns([{ids: nil}, {ids: Set.new([42])}])
+    @chain.send(:ids_from_index).should == Set.new([42])
+  end
+
   it 'defines each' do
     @chain.query = {:name => 'Josh'}
     @chain.each {|u| u.update_attribute(:name, 'Justin')}
@@ -88,10 +96,10 @@ describe "Dynamoid::Associations::Chain" do
 
   it 'finds range querys' do
     @chain = Dynamoid::Criteria::Chain.new(Tweet)
-    @chain.query = { :id => 'test' }
+    @chain.query = { :tweet_id => 'test' }
     @chain.send(:range?).should be_true
 
-    @chain.query = {:id => 'test', :group => 'xx'}
+    @chain.query = {:tweet_id => 'test', :group => 'xx'}
     @chain.send(:range?).should be_true
 
     @chain.query = { :group => 'xx' }
@@ -100,32 +108,32 @@ describe "Dynamoid::Associations::Chain" do
     @chain.query = { :group => 'xx', :msg => 'hai' }
     @chain.send(:range?).should be_false
   end
-  
+
   context 'range queries' 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")      
+      @tweet3 = Tweet.create(:tweet_id => "xx", :group => "two")
       @chain = Dynamoid::Criteria::Chain.new(Tweet)
     end
-    
+
     it 'finds tweets with a simple range query' do
       @chain.query = { :tweet_id => "x" }
       @chain.send(:records_with_range).size.should == 2
       @chain.all.size.should == 2
-      @chain.limit(1).size.should == 1      
+      @chain.limit(1).size.should == 1
     end
-    
+
     it 'finds tweets with a start' do
       @chain.query = { :tweet_id => "x" }
       @chain.start(@tweet1)
       @chain.all.should =~ [@tweet2]
     end
-    
+
     it 'finds one specific tweet' do
       @chain = Dynamoid::Criteria::Chain.new(Tweet)
       @chain.query = { :tweet_id => "xx", :group => "two" }
-      @chain.send(:records_with_range).should == [@tweet3]      
+      @chain.send(:records_with_range).should == [@tweet3]
     end
   end
 

data/spec/dynamoid/criteria_spec.rb

@@ -57,10 +57,16 @@ describe "Dynamoid::Criteria" do
     User.where(:name => 'x').consistent.first
 
     Dynamoid::Adapter.expects(:query).with { |table_name, options| options[:consistent_read] == true }.returns([])
-    Tweet.where(:id => 'xx', :group => 'two').consistent.all
+    Tweet.where(:tweet_id => 'xx', :group => 'two').consistent.all
 
     Dynamoid::Adapter.expects(:query).with { |table_name, options| options[:consistent_read] == false }.returns([])
-    Tweet.where(:id => 'xx', :group => 'two').all
+    Tweet.where(:tweet_id => 'xx', :group => 'two').all
+  end
+
+  it 'raises exception when consistent_read is used with scan' do
+    expect do
+      User.where(:password => 'password').consistent.first
+    end.to raise_error(Dynamoid::Errors::InvalidQuery)
   end
     
 end

data/spec/dynamoid/dirty_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'Dynamoid::Dirty' do
+
+  context 'changes' do
+    it 'should be empty' do
+      tweet = Tweet.new
+      tweet.msg_changed?.should be_false
+    end
+
+    it 'should not be empty' do
+      tweet = Tweet.new(:tweet_id => "1", :group => 'abc')
+      tweet.changed?.should be_true
+      tweet.group_was.should be_nil
+    end
+
+    it 'should be empty when loaded from database' do
+      Tweet.create!(:tweet_id => "1", :group => 'abc')
+      tweet = Tweet.where(:tweet_id => "1", :group => 'abc').first
+      tweet.changed?.should be_false
+      tweet.group = 'abc'
+      tweet.reload
+      tweet.changed?.should be_false
+    end
+
+    it 'track changes after saves' do
+      tweet = Tweet.new(:tweet_id => "1", :group => 'abc')
+      tweet.save!
+      tweet.changed?.should be_false
+
+      tweet.user_name = 'xyz'
+      tweet.user_name_changed?.should be_true
+      tweet.user_name_was.should be_nil
+      tweet.save!
+
+      tweet.user_name_changed?.should be_false
+      tweet.user_name = 'abc'
+      tweet.user_name_was.should == 'xyz'
+    end
+
+    it 'clear changes on save' do
+      tweet = Tweet.new(:tweet_id => "1", :group => 'abc')
+      tweet.group = 'xyz'
+      tweet.group_changed?.should be_true
+      tweet.save!
+      tweet.group_changed?.should be_false
+    end
+  end
+end