dynamoid 0.1.1 → 0.1.2

data/lib/dynamoid/finders.rb

@@ -12,14 +12,14 @@ module Dynamoid #:nodoc:
         if id.count == 1
           self.find_by_id(id.first)
         else
-          items = Dynamoid::Adapter.batch_get_item(self.table_name => id)
+          items = Dynamoid::Adapter.read(self.table_name, id)
           items[self.table_name].collect{|i| o = self.build(i); o.new_record = false; o}
         end
       end
       
       def find_by_id(id)
-        if item = Dynamoid::Adapter.get_item(self.table_name, id)
-          obj = self.new(Dynamoid::Adapter.get_item(self.table_name, id))
+        if item = Dynamoid::Adapter.read(self.table_name, id)
+          obj = self.new(item)
           obj.new_record = false
           return obj
         else

data/lib/dynamoid/indexes.rb

@@ -1,5 +1,3 @@
-require 'digest/sha2'
-
 # encoding: utf-8
 module Dynamoid #:nodoc:
 
@@ -16,30 +14,23 @@ module Dynamoid #:nodoc:
     module ClassMethods
       def index(name, options = {})
         name = Array(name).collect(&:to_s).sort.collect(&:to_sym)
-        raise Dynamoid::Errors::InvalidField, 'A key specified for an index is not a field' unless name.all?{|n| self.fields.include?(n)}
+        raise Dynamoid::Errors::InvalidField, 'A key specified for an index is not a field' unless name.all?{|n| self.attributes.include?(n)}
         self.indexes << name
         create_indexes
       end
       
       def create_indexes
         self.indexes.each do |index|
-          self.create_table(index_table_name(index), index_key_name(index)) unless self.table_exists?(index_table_name(index))
+          self.create_table(index_table_name(index), :id) unless self.table_exists?(index_table_name(index))
         end
       end
       
       def index_table_name(index)
-        "#{Dynamoid::Config.namespace}_index_#{index_key_name(index)}"
-      end
-      
-      def index_key_name(index)
-        "#{self.to_s.downcase}_#{index.collect(&:to_s).collect(&:pluralize).join('_and_')}"
+        "#{Dynamoid::Config.namespace}_index_#{self.to_s.downcase}_#{index.collect(&:to_s).collect(&:pluralize).join('_and_')}"
       end
       
       def key_for_index(index, values = [])
-        values = values.collect(&:to_s).sort
-        Digest::SHA2.new.tap do |sha|
-          index.each_with_index {|i, index| sha << values[index] if values[index]}
-        end.to_s
+        values = values.collect(&:to_s).sort.join('.')
       end
     end
     
@@ -49,17 +40,19 @@ module Dynamoid #:nodoc:
     
     def save_indexes
       self.class.indexes.each do |index|
-        existing = Dynamoid::Adapter.get_item(self.class.index_table_name(index), self.key_for_index(index))
+        next if self.key_for_index(index).blank?
+        existing = Dynamoid::Adapter.read(self.class.index_table_name(index), self.key_for_index(index))
         ids = existing ? existing[:ids] : Set.new
-        Dynamoid::Adapter.put_item(self.class.index_table_name(index), {self.class.index_key_name(index).to_sym => self.key_for_index(index), :ids => ids.merge([self.id])})
+        Dynamoid::Adapter.write(self.class.index_table_name(index), {:id => self.key_for_index(index), :ids => ids.merge([self.id])})
       end
     end
     
     def delete_indexes
       self.class.indexes.each do |index|
-        existing = Dynamoid::Adapter.get_item(self.class.index_table_name(index), self.key_for_index(index))
+        next if self.key_for_index(index).blank?
+        existing = Dynamoid::Adapter.read(self.class.index_table_name(index), self.key_for_index(index))
         next unless existing && existing[:ids]
-        Dynamoid::Adapter.put_item(self.class.index_table_name(index), {self.class.index_key_name(index).to_sym => self.key_for_index(index), :ids => existing[:ids] - [self.id]})
+        Dynamoid::Adapter.write(self.class.index_table_name(index), {:id => self.key_for_index(index), :ids => existing[:ids] - [self.id]})
       end
     end
   end

data/lib/dynamoid/persistence.rb

@@ -7,42 +7,118 @@ module Dynamoid #:nodoc:
   module Persistence
     extend ActiveSupport::Concern
     
+    attr_accessor :new_record
+    alias :new_record? :new_record
+    
+    module ClassMethods
+      def table_name
+        "#{Dynamoid::Config.namespace}_#{self.to_s.downcase.pluralize}"
+      end
+      
+      def create_table(table_name, id = :id)
+        Dynamoid::Adapter.tables << table_name if Dynamoid::Adapter.create_table(table_name, id.to_sym)
+      end
+      
+      def table_exists?(table_name)
+        Dynamoid::Adapter.tables.include?(table_name)
+      end
+      
+      def undump(incoming = {})
+        incoming.symbolize_keys!
+        Hash.new.tap do |hash|
+          self.attributes.each do |attribute, options|
+            value = incoming[attribute]
+            next if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+            case options[:type]
+            when :string
+              hash[attribute] = value.to_s
+            when :integer
+              hash[attribute] = value.to_i
+            when :float
+              hash[attribute] = value.to_f
+            when :set, :array
+              if value.is_a?(Set) || value.is_a?(Array)
+                hash[attribute] = value
+              else
+                hash[attribute] = Set[value]
+              end
+            when :datetime
+              hash[attribute] = Time.at(value).to_datetime
+            end
+          end
+        end
+      end
+      
+    end
+    
     included do
       self.create_table(self.table_name) unless self.table_exists?(self.table_name)
     end
     
+    def persisted?
+      !new_record?
+    end
+    
     def save
-      run_callbacks(:save) do
-        self.id = SecureRandom.uuid if self.id.nil? || self.id.blank?
-        Dynamoid::Adapter.put_item(self.class.table_name, self.attributes)
-        save_indexes
+      if self.new_record?
+        run_callbacks(:create) do
+          run_callbacks(:save) do
+            persist
+          end
+        end
+      else
+        run_callbacks(:save) do
+          persist
+        end
       end
+      self
     end
     
     def destroy
       run_callbacks(:destroy) do
         self.delete
       end
+      self
     end
     
     def delete
       delete_indexes
-      Dynamoid::Adapter.delete_item(self.class.table_name, self.id)
+      Dynamoid::Adapter.delete(self.class.table_name, self.id)
     end
     
-    module ClassMethods
-      def table_name
-        "#{Dynamoid::Config.namespace}_#{self.to_s.downcase.pluralize}"
-      end
-      
-      def create_table(table_name, id = :id)
-        Dynamoid::Adapter.create_table(table_name, id.to_sym)
-      end
-      
-      def table_exists?(table_name)
-        Dynamoid::Adapter.list_tables.include?(table_name)
+    def dump
+      Hash.new.tap do |hash|
+        self.class.attributes.each do |attribute, options|
+          value = self.read_attribute(attribute)
+          next if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+          case options[:type]
+          when :string
+            hash[attribute] = value.to_s
+          when :integer
+            hash[attribute] = value.to_i
+          when :float
+            hash[attribute] = value.to_f
+          when :set, :array
+            if value.is_a?(Set) || value.is_a?(Array)
+              hash[attribute] = value
+            else
+              hash[attribute] = Set[value]
+            end
+          when :datetime
+            hash[attribute] = value.to_time.to_f
+          end
+        end
       end
     end
+    
+    private
+    
+    def persist
+      self.id = SecureRandom.uuid if self.id.nil? || self.id.blank?
+      Dynamoid::Adapter.write(self.class.table_name, self.dump)
+      save_indexes
+    end
+        
   end
   
 end

data/spec/app/models/magazine.rb

@@ -1,6 +1,8 @@
 class Magazine
   include Dynamoid::Document
   
+  field :title
+  
   has_many :subscriptions
   has_one :sponsor
 end

data/spec/app/models/subscription.rb

@@ -1,6 +1,8 @@
 class Subscription
   include Dynamoid::Document
   
+  field :length, :integer
+  
   belongs_to :magazine
   has_and_belongs_to_many :users
 end

data/spec/dynamoid/adapter_spec.rb

@@ -2,6 +2,10 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe "Dynamoid::Adapter" do
   
+  before(:all) do
+    Dynamoid::Adapter.create_table('dynamoid_tests_TestTable', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable')
+  end
+  
   it 'extends itself automatically' do
     lambda {Dynamoid::Adapter.list_tables}.should_not raise_error
   end
@@ -9,5 +13,77 @@ describe "Dynamoid::Adapter" do
   it 'raises nomethod if we try a method that is not on the child' do
     lambda {Dynamoid::Adapter.foobar}.should raise_error
   end
+  
+  context 'without partioning' do
+    before(:all) do
+      @previous_value = Dynamoid::Config.partitioning
+      Dynamoid::Config.partitioning = false
+    end
+    
+    after(:all) do
+      Dynamoid::Config.partitioning = @previous_value
+    end
+    
+    it 'writes through the adapter' do
+      Dynamoid::Adapter.expects(:put_item).with('dynamoid_tests_TestTable', {:id => '123'}).returns(true)
+
+      Dynamoid::Adapter.write('dynamoid_tests_TestTable', {:id => '123'})
+    end
+
+    it 'reads through the adapter for one ID' do
+      Dynamoid::Adapter.expects(:get_item).with('dynamoid_tests_TestTable', '123').returns(true)
+
+      Dynamoid::Adapter.read('dynamoid_tests_TestTable', '123')
+    end
+
+    it 'reads through the adapter for many IDs' do
+      Dynamoid::Adapter.expects(:batch_get_item).with({'dynamoid_tests_TestTable' => ['1', '2']}).returns(true)
+
+      Dynamoid::Adapter.read('dynamoid_tests_TestTable', ['1', '2'])
+    end
+  end
+  
+  context 'with partitioning' do
+    before(:all) do
+      @previous_value = Dynamoid::Config.partitioning
+      Dynamoid::Config.partitioning = true
+    end
+    
+    after(:all) do
+      Dynamoid::Config.partitioning = @previous_value
+    end
+    
+    it 'writes through the adapter' do
+      Random.expects(:rand).with(Dynamoid::Config.partition_size).once.returns(0)
+      Dynamoid::Adapter.write('dynamoid_tests_TestTable', {:id => 'testid'})
+    
+      Dynamoid::Adapter.get_item('dynamoid_tests_TestTable', 'testid.0')[:id].should == 'testid.0'
+      Dynamoid::Adapter.get_item('dynamoid_tests_TestTable', 'testid.0')[:updated_at].should_not be_nil
+    end
+  
+    it 'reads through the adapter for one ID' do
+      Dynamoid::Adapter.expects(:batch_get_item).with('dynamoid_tests_TestTable' => (0...Dynamoid::Config.partition_size).collect{|n| "123.#{n}"}).returns({})
+    
+      Dynamoid::Adapter.read('dynamoid_tests_TestTable', '123')
+    end
+  
+    it 'reads through the adapter for many IDs' do
+      Dynamoid::Adapter.expects(:batch_get_item).with('dynamoid_tests_TestTable' => (0...Dynamoid::Config.partition_size).collect{|n| "1.#{n}"} + (0...Dynamoid::Config.partition_size).collect{|n| "2.#{n}"}).returns({})
+    
+      Dynamoid::Adapter.read('dynamoid_tests_TestTable', ['1', '2'])
+    end
+  
+    it 'returns an ID with all partitions' do
+      Dynamoid::Adapter.id_with_partitions('1').should =~ (0...Dynamoid::Config.partition_size).collect{|n| "1.#{n}"}
+    end
+  
+    it 'returns a result for one partitioned element' 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}]
+    end
+    
+  end
 
 end

data/spec/dynamoid/associations/association_spec.rb

@@ -78,5 +78,27 @@ describe "Dynamoid::Associations::Association" do
     @magazine.subscriptions = nil
     @magazine.subscriptions.size.should == 0
   end
+  
+  it 'uses where inside an association and returns a result' do
+    @included_subscription = @magazine.subscriptions.create(:length => 10)
+    @unincldued_subscription = @magazine.subscriptions.create(:length => 8)
+    
+    @magazine.subscriptions.where(:length => 10).all.should == [@included_subscription]
+  end
+  
+  it 'uses where inside an association and returns an empty set' do
+    @included_subscription = @magazine.subscriptions.create(:length => 10)
+    @unincldued_subscription = @magazine.subscriptions.create(:length => 8)
+    
+    @magazine.subscriptions.where(:length => 6).all.should be_empty
+  end
+  
+  it 'includes enumerable' do
+    @subscription1 = @magazine.subscriptions.create
+    @subscription2 = @magazine.subscriptions.create
+    @subscription3 = @magazine.subscriptions.create
+    
+    @magazine.subscriptions.collect(&:id).should =~ [@subscription1.id, @subscription2.id, @subscription3.id]
+  end
 
 end

data/spec/dynamoid/associations/belongs_to_spec.rb

@@ -23,6 +23,14 @@ describe "Dynamoid::Associations::BelongsTo" do
       @magazine.subscriptions.size.should == 1
       @magazine.subscriptions.should include @subscription
     end
+    
+    it 'behaves like the object it is trying to be' do
+      @magazine = @subscription.magazine.create
+
+      @subscription.magazine.update_attribute(:title, 'Test Title')
+
+      Magazine.first.title.should == 'Test Title'
+    end
   end
   
   context 'has one' do

data/spec/dynamoid/criteria_spec.rb

@@ -27,5 +27,8 @@ describe "Dynamoid::Criteria" do
     Magazine.all.should == []
   end
   
+  it 'passes each to all members' do
+    User.each{|u| u.id.should == @user1.id || @user2.id}
+  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, :city => nil}
+    @address.attributes.should == {:id=>nil, :created_at=>nil, :updated_at=>nil, :city=>nil}
   end
   
   it 'initializes a new document with attributes' do
@@ -14,7 +14,7 @@ describe "Dynamoid::Document" do
     
     @address.new_record.should be_true
     
-    @address.attributes.should == {:id => nil, :city => 'Chicago'}
+    @address.attributes.should == {:id=>nil, :created_at=>nil, :updated_at=>nil, :city=>"Chicago"}
   end
   
   it 'creates a new document' do
@@ -45,4 +45,13 @@ describe "Dynamoid::Document" do
     @address.errors.should be_empty
     @address.errors.full_messages.should be_empty
   end
+  
+  it 'reloads itself and sees persisted changes' do
+    @address = Address.create
+    
+    Address.first.update_attributes(:city => 'Chicago')
+    
+    @address.city.should be_nil
+    @address.reload.city.should == 'Chicago'
+  end
 end

data/spec/dynamoid/fields_spec.rb

@@ -23,4 +23,61 @@ describe "Dynamoid::Fields" do
     @address.city?.should be_true
   end
   
+  it 'automatically declares id' do
+    lambda {@address.id}.should_not raise_error
+  end
+  
+  it 'automatically declares and fills in created_at and updated_at' do
+    @address.save
+    
+    @address = @address.reload
+    @address.created_at.should_not be_nil
+    @address.created_at.class.should == DateTime
+    @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
+      @original_id = @address.id
+    end
+
+    it 'should write an attribute correctly' do
+      @address.write_attribute(:city, 'Chicago')
+    end
+  
+    it 'should write an attribute with an alias' do
+      @address[:city] = 'Chicago'
+    end
+  
+    it 'should read a written attribute' do
+      @address.write_attribute(:city, 'Chicago')
+      @address.read_attribute(:city).should == 'Chicago'
+    end
+  
+    it 'should read a written attribute with the alias' do
+      @address.write_attribute(:city, 'Chicago')
+      @address[:city].should == 'Chicago'
+    end
+  
+    it 'should update all attributes' do
+      @address.expects(:save).once.returns(true)
+      @address.update_attributes(:city => 'Chicago')
+      @address[:city].should == 'Chicago'
+      @address.id.should == @original_id
+    end
+  
+    it 'should update one attribute' do
+      @address.expects(:save).once.returns(true)
+      @address.update_attribute(:city, 'Chicago')
+      @address[:city].should == 'Chicago'
+      @address.id.should == @original_id
+    end
+  
+    it 'returns all attributes' do
+      Address.attributes.should == {:id=>{:type=>:string}, :created_at=>{:type=>:datetime}, :updated_at=>{:type=>:datetime}, :city=>{:type=>:string}}
+    end
+  end
+  
 end