dynamoid 0.2.0 → 0.3.0

data/lib/dynamoid/persistence.rb

@@ -1,9 +1,10 @@
 require 'securerandom'
 
 # encoding: utf-8
-module Dynamoid #:nodoc:
+module Dynamoid
 
-  # This module saves things!
+  # Persistence is responsible for dumping objects to and marshalling objects from the datastore. It tries to reserialize 
+  # values to be of the same type as when they were passed in, based on the fields in the class.
   module Persistence
     extend ActiveSupport::Concern
     
@@ -11,59 +12,94 @@ module Dynamoid #:nodoc:
     alias :new_record? :new_record
     
     module ClassMethods
+      
+      # Returns the name of the table the class is for.
+      #
+      # @since 0.2.0
       def table_name
         "#{Dynamoid::Config.namespace}_#{self.to_s.downcase.pluralize}"
       end
       
+      # Creates a table for a given table name, hash key, and range key.
+      #
+      # @since 0.2.0
       def create_table(table_name, id = :id, options = {})
         Dynamoid::Adapter.tables << table_name if Dynamoid::Adapter.create_table(table_name, id.to_sym, options)
       end
-      
+
+      # Does a table with this name exist?
+      #
+      # @since 0.2.0      
       def table_exists?(table_name)
         Dynamoid::Adapter.tables.include?(table_name)
       end
       
-      def undump(incoming = {})
-        incoming.symbolize_keys!
+      # 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
+      def undump(incoming = nil)
+        (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
-              if value.is_a?(Date) || value.is_a?(DateTime) || value.is_a?(Time)
-                hash[attribute] = value
-              else
-                hash[attribute] = Time.at(value).to_datetime
-              end
-            end
+            hash[attribute] = undump_field(incoming[attribute], options[:type])
           end
         end
       end
-      
+
+      # Undump a value for a given type. Given a string, it'll determine (based on the type provided) whether to turn it into a 
+      # string, integer, float, set, array, datetime, or serialized return value.
+      #
+      # @since 0.2.0
+      def undump_field(value, type)
+        return if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+
+        case type
+        when :string
+          value.to_s
+        when :integer
+          value.to_i
+        when :float
+          value.to_f
+        when :set, :array
+          if value.is_a?(Set) || value.is_a?(Array)
+            value
+          else
+            Set[value]
+          end
+        when :datetime
+          if value.is_a?(Date) || value.is_a?(DateTime) || value.is_a?(Time)
+            value
+          else
+            Time.at(value).to_datetime
+          end
+        when :serialized
+          if value.is_a?(String)
+            YAML.load(value)
+          else
+            value
+          end
+        end
+      end
+
     end
     
+    # Create the table if it doesn't exist already upon loading the class.
     included do
       self.create_table(self.table_name) unless self.table_exists?(self.table_name)
     end
     
+    # Is this object persisted in the datastore? Required for some ActiveModel integration stuff.
+    #
+    # @since 0.2.0
     def persisted?
       !new_record?
     end
     
-    def save
+    # Run the callbacks and then persist this object in the datastore.
+    #
+    # @since 0.2.0
+    def save(options = {})
+      @previously_changed = changes
       if self.new_record?
         run_callbacks(:create) do
           run_callbacks(:save) do
@@ -77,52 +113,76 @@ module Dynamoid #:nodoc:
       end
       self
     end
-    
+
+    # Delete this object, but only after running callbacks for it.
+    #
+    # @since 0.2.0
     def destroy
       run_callbacks(:destroy) do
         self.delete
       end
       self
     end
-    
+
+    # Delete this object from the datastore and all indexes.
+    #
+    # @since 0.2.0
     def delete
       delete_indexes
       Dynamoid::Adapter.delete(self.class.table_name, self.id)
     end
     
+    # Dump this object's attributes into hash form, fit to be persisted into the datastore.
+    #
+    # @since 0.2.0
     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
+          hash[attribute] = dump_field(self.read_attribute(attribute), options[:type])
         end
       end
     end
     
     private
-    
+
+    # Determine how to dump this field. Given a value, it'll determine how to turn it into a value that can be 
+    # persisted into the datastore.
+    #
+    # @since 0.2.0
+    def dump_field(value, type)
+      return if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+
+      case type
+      when :string
+        value.to_s
+      when :integer
+        value.to_i
+      when :float
+        value.to_f
+      when :set, :array
+        if value.is_a?(Set) || value.is_a?(Array)
+          value
+        else
+          Set[value]
+        end
+      when :datetime
+        value.to_time.to_f
+      when :serialized
+        value.to_yaml
+      end
+    end
+
+    # Persist the object into the datastore. Assign it an id first if it doesn't have one; then afterwards, 
+    # save its indexes.
+    #
+    # @since 0.2.0
     def persist
       self.id = SecureRandom.uuid if self.id.nil? || self.id.blank?
       Dynamoid::Adapter.write(self.class.table_name, self.dump)
       save_indexes
+      @new_record = false
     end
         
   end
   
-end
+end

data/lib/dynamoid/validations.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+module Dynamoid
+  
+  # Provide ActiveModel validations to Dynamoid documents.
+  module Validations
+    extend ActiveSupport::Concern
+
+    include ActiveModel::Validations
+    include ActiveModel::Validations::Callbacks
+
+    # Override save to provide validation support.
+    #
+    # @since 0.2.0
+    def save(options = {})
+      options.reverse_merge!(:validate => true)
+      return false if options[:validate] and (not valid?)
+      super
+    end
+
+    # Is this object valid?
+    #
+    # @since 0.2.0
+    def valid?(context = nil)
+      context ||= (new_record? ? :create : :update)
+      super(context)
+    end
+
+    # Raise an error unless this object is valid.
+    #
+    # @since 0.2.0
+    def save!
+      raise Dynamoid::Errors::DocumentNotValid.new(self) unless valid?
+      save(:validate => false)
+    end
+  end
+end

data/spec/app/models/address.rb

@@ -2,4 +2,5 @@ class Address
   include Dynamoid::Document
   
   field :city
-end
+  field :options, :serialized
+end

data/spec/app/models/camel_case.rb

@@ -0,0 +1,11 @@
+class CamelCase
+  include Dynamoid::Document
+
+  field :color
+
+  belongs_to :magazine
+  has_many :users
+  has_one :sponsor
+  has_and_belongs_to_many :subscriptions
+
+end

data/spec/app/models/magazine.rb

@@ -4,5 +4,8 @@ class Magazine
   field :title
   
   has_many :subscriptions
+  has_many :camel_cases
   has_one :sponsor
-end
+
+  belongs_to :owner, :class_name => 'User', :inverse_of => :books
+end

data/spec/app/models/sponsor.rb

@@ -3,4 +3,6 @@ class Sponsor
   
   belongs_to :magazine
   has_many :subscriptions
-end
+
+  belongs_to :camel_case
+end

data/spec/app/models/subscription.rb

@@ -5,4 +5,8 @@ class Subscription
   
   belongs_to :magazine
   has_and_belongs_to_many :users
-end
+
+  belongs_to :customer, :class_name => 'User', :inverse_of => :monthly
+
+  has_and_belongs_to_many :camel_cases
+end

data/spec/app/models/user.rb

@@ -14,4 +14,13 @@ class User
   index :created_at, :range => true
   
   has_and_belongs_to_many :subscriptions
-end
+
+  has_many :books, :class_name => 'Magazine', :inverse_of => :owner
+  has_one :monthly, :class_name => 'Subscription', :inverse_of => :customer
+
+  has_and_belongs_to_many :followers, :class_name => 'User', :inverse_of => :following
+  has_and_belongs_to_many :following, :class_name => 'User', :inverse_of => :followers
+
+  belongs_to :camel_case
+
+end

data/spec/dynamoid/associations/association_spec.rb

@@ -33,7 +33,7 @@ describe "Dynamoid::Associations::Association" do
     @magazine.subscriptions.size.should == 1
     @magazine.subscriptions.should include @subscription
   end
-  
+
   it 'returns the number of items in the association' do
     @magazine.subscriptions.create
     
@@ -101,4 +101,70 @@ describe "Dynamoid::Associations::Association" do
     @magazine.subscriptions.collect(&:id).should =~ [@subscription1.id, @subscription2.id, @subscription3.id]
   end
 
+  it 'works for camel-cased associations' do
+    @magazine.camel_cases.create.class.should == CamelCase
+  end
+
+  it 'destroys associations' do
+    @subscription = Subscription.new
+    @magazine.subscriptions.expects(:records).returns([@subscription])
+    @subscription.expects(:destroy)
+
+    @magazine.subscriptions.destroy_all
+  end
+
+  it 'deletes associations' do
+    @subscription = Subscription.new
+    @magazine.subscriptions.expects(:records).returns([@subscription])
+    @subscription.expects(:delete)
+
+    @magazine.subscriptions.delete_all
+  end
+
+  it 'returns the first and last record when they exist' do
+    @subscription1 = @magazine.subscriptions.create
+    @subscription2 = @magazine.subscriptions.create
+    @subscription3 = @magazine.subscriptions.create
+
+    @magazine.subscriptions.instance_eval { [first, last] }.should == [@subscription1, @subscription3]
+  end
+  
+  it 'replaces existing associations when using the setter' do
+    @subscription1 = @magazine.subscriptions.create
+    @subscription2 = @magazine.subscriptions.create
+    @subscription3 = Subscription.create
+    
+    @subscription1.reload.magazine_ids.should_not be_nil
+    @subscription2.reload.magazine_ids.should_not be_nil
+
+    @magazine.subscriptions = @subscription3
+    @magazine.subscriptions_ids.should == Set[@subscription3.id]
+    
+    @subscription1.reload.magazine_ids.should be_nil
+    @subscription2.reload.magazine_ids.should be_nil
+    @subscription3.reload.magazine_ids.should == Set[@magazine.id]
+  end
+  
+  it 'destroys all objects and removes them from the association' do
+    @subscription1 = @magazine.subscriptions.create
+    @subscription2 = @magazine.subscriptions.create
+    @subscription3 = @magazine.subscriptions.create
+
+    @magazine.subscriptions.destroy_all
+    
+    @magazine.subscriptions.should be_empty
+    Subscription.all.should be_empty
+  end
+  
+  it 'deletes all objects and removes them from the association' do
+    @subscription1 = @magazine.subscriptions.create
+    @subscription2 = @magazine.subscriptions.create
+    @subscription3 = @magazine.subscriptions.create
+
+    @magazine.subscriptions.delete_all
+    
+    @magazine.subscriptions.should be_empty
+    Subscription.all.should be_empty
+  end
+
 end

data/spec/dynamoid/associations/belongs_to_spec.rb

@@ -5,11 +5,17 @@ describe "Dynamoid::Associations::BelongsTo" do
   context 'has many' do
     before do
       @subscription = Subscription.create
+      @camel_case = CamelCase.create
     end
   
-    it 'determins nil if it has no associated record' do
+    it 'determines nil if it has no associated record' do
       @subscription.magazine.should be_nil
     end
+
+    it 'determines target association correctly' do
+      @camel_case.magazine.send(:target_association).should == :camel_cases
+    end
+
   
     it 'delegates equality to its source record' do
       @magazine = @subscription.magazine.create
@@ -22,6 +28,11 @@ describe "Dynamoid::Associations::BelongsTo" do
     
       @magazine.subscriptions.size.should == 1
       @magazine.subscriptions.should include @subscription
+
+      @magazine = Magazine.create
+      @user = @magazine.owner.create
+      @user.books.size.should == 1
+      @user.books.should include @magazine
     end
     
     it 'behaves like the object it is trying to be' do
@@ -36,6 +47,7 @@ describe "Dynamoid::Associations::BelongsTo" do
   context 'has one' do
     before do
       @sponsor = Sponsor.create
+      @subscription = Subscription.create
     end
     
     it 'determins nil if it has no associated record' do
@@ -53,6 +65,9 @@ describe "Dynamoid::Associations::BelongsTo" do
       
       @magazine.sponsor.size.should == 1
       @magazine.sponsor.should == @sponsor
+
+      @user = @subscription.customer.create
+      @user.monthly.should == @subscription
     end
   end
 end