dynamoid-edge 1.1.0

data/lib/dynamoid/associations/association.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  # The base association module which all associations include. Every association has two very important components: the source and
+  # the target. The source is the object which is calling the association information. It always has the target_ids inside of an attribute on itself.
+  # The target is the object which is referencing by this association.
+  module Associations
+    module Association
+      attr_accessor :name, :options, :source, :loaded
+
+      # Create a new association.
+      #
+      # @param [Class] source the source record of the association; that is, the record that you already have
+      # @param [Symbol] name the name of the association
+      # @param [Hash] options optional parameters for the association
+      # @option options [Class] :class the target class of the association; that is, the class to which the association objects belong
+      # @option options [Symbol] :class_name the name of the target class of the association; only this or Class is necessary
+      # @option options [Symbol] :inverse_of the name of the association on the target class
+      #
+      # @return [Dynamoid::Association] the actual association instance itself
+      #
+      # @since 0.2.0
+      def initialize(source, name, options)
+        @name = name
+        @options = options
+        @source = source
+        @loaded = false
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def find_target
+      end
+
+      def target
+        unless loaded?
+          @target = find_target
+          @loaded = true
+        end
+
+        @target
+      end
+
+      def reset
+        @target = nil
+        @loaded = false
+      end
+
+      private
+
+      # The target class name, either inferred through the association's name or specified in options.
+      #
+      # @since 0.2.0
+      def target_class_name
+        options[:class_name] || name.to_s.classify
+      end
+
+      # The target class, either inferred through the association's name or specified in options.
+      #
+      # @since 0.2.0
+      def target_class
+        options[:class] || target_class_name.constantize
+      end
+
+      # The target attribute: that is, the attribute on each object of the association that should reference the source.
+      #
+      # @since 0.2.0
+      def target_attribute
+        "#{target_association}_ids".to_sym if target_association
+      end
+
+      # The ids in the target association.
+      #
+      # @since 0.2.0
+      def target_ids
+        target.send(target_attribute) || Set.new
+      end
+
+      # The ids in the target association.
+      #
+      # @since 0.2.0
+      def source_class
+        source.class
+      end
+
+      # The source's association attribute: the name of the association with _ids afterwards, like "users_ids".
+      #
+      # @since 0.2.0
+      def source_attribute
+        "#{name}_ids".to_sym
+      end
+
+      # The ids in the source association.
+      #
+      # @since 0.2.0
+      def source_ids
+        source.send(source_attribute) || Set.new
+      end
+
+    end
+  end
+
+end

data/lib/dynamoid/associations/belongs_to.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  # The belongs_to association. For belongs_to, we reference only a single target instead of multiple records; that target is the 
+  # object to which the association object is associated.
+  module Associations
+    class BelongsTo
+      include SingleAssociation
+
+      private
+
+      # Find the target association, either has_many or has_one. Uses either options[:inverse_of] or the source class name and default parsing to
+      # return the most likely name for the target association.
+      #
+      # @since 0.2.0
+      def target_association
+        has_many_key_name = options[:inverse_of] || source.class.to_s.underscore.pluralize.to_sym
+        has_one_key_name = options[:inverse_of] || source.class.to_s.underscore.to_sym
+        if !target_class.associations[has_many_key_name].nil?
+          return has_many_key_name if target_class.associations[has_many_key_name][:type] == :has_many
+        end
+
+        if !target_class.associations[has_one_key_name].nil?
+          return has_one_key_name if target_class.associations[has_one_key_name][:type] == :has_one
+        end
+      end
+      
+      # Associate a source object to this association.
+      #
+      # @since 0.2.0
+      def associate_target(object)
+        object.update_attribute(target_attribute, target_ids.merge(Array(source.id)))
+      end
+
+      # Disassociate a source object from this association.
+      #
+      # @since 0.2.0      
+      def disassociate_target(object)
+        source.update_attribute(source_attribute, target_ids - Array(source.id))
+      end
+    end
+  end
+  
+end

data/lib/dynamoid/associations/has_and_belongs_to_many.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  # The has and belongs to many association.
+  module Associations
+    class HasAndBelongsToMany
+      include ManyAssociation
+
+      private
+
+      # Find the target association, always another :has_and_belongs_to_many association. Uses either options[:inverse_of] or the source class name
+      # and default parsing to return the most likely name for the target association.
+      #
+      # @since 0.2.0
+      def target_association
+        key_name = options[:inverse_of] || source.class.to_s.pluralize.underscore.to_sym
+        guess = target_class.associations[key_name]
+        return nil if guess.nil? || guess[:type] != :has_and_belongs_to_many
+        key_name
+      end
+
+      # Associate a source object to this association.
+      #
+      # @since 0.2.0
+      def associate_target(object)
+        ids = object.send(target_attribute) || Set.new
+        object.update_attribute(target_attribute, ids.merge(Array(source.id)))
+      end
+
+      # Disassociate a source object from this association.
+      #
+      # @since 0.2.0
+      def disassociate_target(object)
+        ids = object.send(target_attribute) || Set.new
+        object.update_attribute(target_attribute, ids - Array(source.id))
+      end
+    end
+  end
+
+end

data/lib/dynamoid/associations/has_many.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  # The has_many association.
+  module Associations
+    class HasMany
+      include ManyAssociation
+
+      private
+
+      # Find the target association, always a :belongs_to association. Uses either options[:inverse_of] or the source class name 
+      # and default parsing to return the most likely name for the target association.
+      #
+      # @since 0.2.0
+      def target_association
+        key_name = options[:inverse_of] || source.class.to_s.singularize.underscore.to_sym
+        guess = target_class.associations[key_name]
+        return nil if guess.nil? || guess[:type] != :belongs_to
+        key_name
+      end
+
+      # Associate a source object to this association.
+      #
+      # @since 0.2.0                  
+      def associate_target(object)
+        object.update_attribute(target_attribute, Set[source.id])
+      end
+      
+      # Disassociate a source object from this association.
+      #
+      # @since 0.2.0      
+      def disassociate_target(object)
+        object.update_attribute(target_attribute, nil)
+      end
+      
+    end
+  end
+  
+end

data/lib/dynamoid/associations/has_one.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  # The HasOne association.
+  module Associations
+    class HasOne
+      include Association
+      include SingleAssociation
+
+      private
+
+      # Find the target association, always a :belongs_to association. Uses either options[:inverse_of] or the source class name
+      # and default parsing to return the most likely name for the target association.
+      #
+      # @since 0.2.0
+      def target_association
+        key_name = options[:inverse_of] || source.class.to_s.singularize.underscore.to_sym
+        guess = target_class.associations[key_name]
+        return nil if guess.nil? || guess[:type] != :belongs_to
+        key_name
+      end
+
+      # Associate a source object to this association.
+      #
+      # @since 0.2.0
+      def associate_target(object)
+        object.update_attribute(target_attribute, Set[source.id])
+      end
+
+      # Disassociate a source object from this association.
+      #
+      # @since 0.2.0
+      def disassociate_target(object)
+        source.update_attribute(source_attribute, nil)
+      end
+    end
+  end
+
+end

data/lib/dynamoid/associations/many_association.rb

@@ -0,0 +1,191 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  module Associations
+    module ManyAssociation
+      include Association
+
+      attr_accessor :query
+
+      def initialize(*args)
+        @query = {}
+        super
+      end
+
+      include Enumerable
+      # Delegate methods to the records the association represents.
+      delegate :first, :last, :empty?, :size, :class, :to => :records
+
+      # The records associated to the source.
+      #
+      # @return the association records; depending on which association this is, either a single instance or an array
+      #
+      # @since 0.2.0
+      def find_target
+        Array(target_class.find(source_ids.to_a))
+      end
+
+      def records
+        if query.empty?
+          target
+        else
+          results_with_query(target)
+        end
+      end
+
+      # Alias convenience methods for the associations.
+      alias :all :records
+      alias :count :size
+      alias :nil? :empty?
+
+      # Delegate include? to the records.
+      def include?(object)
+        records.include?(object)
+      end
+
+      # Deletes an object or array of objects from the association. This removes their records from the association field on the source,
+      # and attempts to remove the source from the target association if it is detected to exist.
+      #
+      # @param [Dynamoid::Document] object the object (or array of objects) to remove from the association
+      #
+      # @return [Dynamoid::Document] the deleted object
+      #
+      # @since 0.2.0
+      def delete(object)
+        source.update_attribute(source_attribute, source_ids - Array(object).collect(&:id))
+        Array(object).each {|o| self.send(:disassociate_target, o)} if target_association
+        object
+      end
+
+
+      # Add an object or array of objects to an association. This preserves the current records in the association (if any)
+      # and adds the object to the target association if it is detected to exist.
+      #
+      # @param [Dynamoid::Document] object the object (or array of objects) to add to the association
+      #
+      # @return [Dynamoid::Document] the added object
+      #
+      # @since 0.2.0
+      def <<(object)
+        source.update_attribute(source_attribute, source_ids.merge(Array(object).collect(&:id)))
+        Array(object).each {|o| self.send(:associate_target, o)} if target_association
+        object
+      end
+
+      # Replace an association with object or array of objects. This removes all of the existing associated records and replaces them with
+      # the passed object(s), and associates the target association if it is detected to exist.
+      #
+      # @param [Dynamoid::Document] object the object (or array of objects) to add to the association
+      #
+      # @return [Dynamoid::Document] the added object
+      #
+      # @since 0.2.0
+      def setter(object)
+        target.each {|o| delete(o)}
+        self << (object)
+        object
+      end
+
+      # Create a new instance of the target class and add it directly to the association. If the create fails an exception will be raised.
+      #
+      # @param [Hash] attribute hash for the new object
+      #
+      # @return [Dynamoid::Document] the newly-created object
+      #
+      # @since 0.2.0
+      def create!(attributes = {})
+        self << target_class.create!(attributes)
+      end
+
+      # Create a new instance of the target class and add it directly to the association.
+      #
+      # @param [Hash] attribute hash for the new object
+      #
+      # @return [Dynamoid::Document] the newly-created object
+      #
+      # @since 0.2.0
+      def create(attributes = {})
+        self << target_class.create(attributes)
+      end
+
+      # Create a new instance of the target class and add it directly to the association. If the create fails an exception will be raised.
+      #
+      # @param [Hash] attribute hash for the new object
+      #
+      # @return [Dynamoid::Document] the newly-created object
+      #
+      # @since 0.2.0
+      def each(&block)
+        records.each(&block)
+      end
+
+      # Destroys all members of the association and removes them from the association.
+      #
+      # @since 0.2.0
+      def destroy_all
+        objs = target
+        source.update_attribute(source_attribute, nil)
+        objs.each(&:destroy)
+      end
+
+      # Deletes all members of the association and removes them from the association.
+      #
+      # @since 0.2.0
+      def delete_all
+        objs = target
+        source.update_attribute(source_attribute, nil)
+        objs.each(&:delete)
+      end
+
+      # Naive association filtering.
+      #
+      # @param [Hash] A hash of attributes; each must match every returned object's attribute exactly.
+      #
+      # @return [Dynamoid::Association] the association this method was called on (for chaining purposes)
+      #
+      # @since 0.2.0
+      def where(args)
+        args.each {|k, v| query[k] = v}
+        self
+      end
+
+      # Is this array equal to the association's records?
+      #
+      # @return [Boolean] true/false
+      #
+      # @since 0.2.0
+      def ==(other)
+        records == Array(other)
+      end
+
+      # Delegate methods we don't find directly to the records array.
+      #
+      # @since 0.2.0
+      def method_missing(method, *args)
+        if records.respond_to?(method)
+          records.send(method, *args)
+        else
+          super
+        end
+      end
+
+      private
+
+      # If a query exists, filter all existing results based on that query.
+      #
+      # @param [Array] results the raw results for the association
+      #
+      # @return [Array] the filtered results for the query
+      #
+      # @since 0.2.0
+      def results_with_query(results)
+        results.find_all do |result|
+          query.all? do |attribute, value|
+            result.send(attribute) == value
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/dynamoid/associations/single_association.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  module Associations
+    module SingleAssociation
+      include Association
+
+      delegate :class, :to => :target
+
+      def setter(object)
+        delete
+        source.update_attribute(source_attribute, Set[object.id])
+        self.send(:associate_target, object) if target_association
+        object
+      end
+
+      def delete
+        source.update_attribute(source_attribute, nil)
+        self.send(:disassociate_target, target) if target && target_association
+        target
+      end
+
+      def create!(attributes = {})
+        setter(target_class.create!(attributes))
+      end
+
+      def create(attributes = {})
+        setter(target_class.create!(attributes))
+      end
+
+
+      # Is this object equal to the association's target?
+      #
+      # @return [Boolean] true/false
+      #
+      # @since 0.2.0
+      def ==(other)
+        target == other
+      end
+
+      # Delegate methods we don't find directly to the target.
+      #
+      # @since 0.2.0
+      def method_missing(method, *args)
+        if target.respond_to?(method)
+          target.send(method, *args)
+        else
+          super
+        end
+      end
+
+      def nil?
+        target.nil?
+      end
+
+      private
+
+      # Find the target of the has_one association.
+      #
+      # @return [Dynamoid::Document] the found target (or nil if nothing)
+      #
+      # @since 0.2.0
+      def find_target
+        return if source_ids.empty?
+        target_class.find(source_ids.first)
+      end
+    end
+  end
+end

data/lib/dynamoid/associations.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+require 'dynamoid/associations/association'
+require 'dynamoid/associations/single_association'
+require 'dynamoid/associations/many_association'
+require 'dynamoid/associations/has_many'
+require 'dynamoid/associations/belongs_to'
+require 'dynamoid/associations/has_one'
+require 'dynamoid/associations/has_and_belongs_to_many'
+
+module Dynamoid
+
+  # Connects models together through the magic of associations. We enjoy four different kinds of associations presently:
+  #   * belongs_to
+  #   * has_and_belongs_to_many
+  #   * has_many
+  #   * has_one
+  module Associations
+    extend ActiveSupport::Concern
+    
+    # Create the association tracking attribute and initialize it to an empty hash.
+    included do
+      class_attribute :associations
+      
+      self.associations = {}
+    end
+
+    module ClassMethods
+      
+      # create a has_many association for this document.
+      #
+      # @param [Symbol] name the name of the association
+      # @param [Hash] options options to pass to the association constructor
+      # @option options [Class] :class the target class of the has_many association; that is, the belongs_to class
+      # @option options [Symbol] :class_name the name of the target class of the association; that is, the name of the belongs_to class
+      # @option options [Symbol] :inverse_of the name of the association on the target class; that is, if the class has a belongs_to association, the name of that association
+      #
+      # @since 0.2.0
+      def has_many(name, options = {})
+        association(:has_many, name, options)
+      end
+      
+      # create a has_one association for this document.
+      #
+      # @param [Symbol] name the name of the association
+      # @param [Hash] options options to pass to the association constructor
+      # @option options [Class] :class the target class of the has_one association; that is, the belongs_to class
+      # @option options [Symbol] :class_name the name of the target class of the association; that is, the name of the belongs_to class
+      # @option options [Symbol] :inverse_of the name of the association on the target class; that is, if the class has a belongs_to association, the name of that association
+      #
+      # @since 0.2.0
+      def has_one(name, options = {})
+        association(:has_one, name, options)
+      end
+      
+      # create a belongs_to association for this document.
+      #
+      # @param [Symbol] name the name of the association
+      # @param [Hash] options options to pass to the association constructor
+      # @option options [Class] :class the target class of the has_one association; that is, the has_many or has_one class
+      # @option options [Symbol] :class_name the name of the target class of the association; that is, the name of the has_many or has_one class
+      # @option options [Symbol] :inverse_of the name of the association on the target class; that is, if the class has a has_many or has_one association, the name of that association
+      #
+      # @since 0.2.0
+      def belongs_to(name, options = {})
+        association(:belongs_to, name, options)
+      end
+      
+      # create a has_and_belongs_to_many association for this document.
+      #
+      # @param [Symbol] name the name of the association
+      # @param [Hash] options options to pass to the association constructor
+      # @option options [Class] :class the target class of the has_and_belongs_to_many association; that is, the belongs_to class
+      # @option options [Symbol] :class_name the name of the target class of the association; that is, the name of the belongs_to class
+      # @option options [Symbol] :inverse_of the name of the association on the target class; that is, if the class has a belongs_to association, the name of that association
+      #
+      # @since 0.2.0
+      def has_and_belongs_to_many(name, options = {})
+        association(:has_and_belongs_to_many, name, options)
+      end
+      
+      private
+
+      # create getters and setters for an association.
+      #
+      # @param [Symbol] symbol the type (:has_one, :has_many, :has_and_belongs_to_many, :belongs_to) of the association
+      # @param [Symbol] name the name of the association
+      # @param [Hash] options options to pass to the association constructor; see above for all valid options
+      #
+      # @since 0.2.0      
+      def association(type, name, options = {})
+        field "#{name}_ids".to_sym, :set
+        self.associations[name] = options.merge(:type => type)
+        define_method(name) do
+          @associations[:"#{name}_ids"] ||= Dynamoid::Associations.const_get(type.to_s.camelcase).new(self, name, options)
+        end
+        define_method("#{name}=".to_sym) do |objects|
+          @associations[:"#{name}_ids"] ||= Dynamoid::Associations.const_get(type.to_s.camelcase).new(self, name, options)
+          @associations[:"#{name}_ids"].setter(objects)
+        end
+      end
+    end
+
+
+  end
+  
+end

data/lib/dynamoid/components.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module Dynamoid
+
+  # All modules that a Document is composed of are defined in this
+  # module, to keep the document class from getting too cluttered.
+  module Components
+    extend ActiveSupport::Concern
+
+    included do
+      extend ActiveModel::Translation
+      extend ActiveModel::Callbacks
+
+      define_model_callbacks :create, :save, :destroy, :initialize, :update
+
+      before_create :set_created_at
+      before_save :set_updated_at
+      after_initialize :set_type
+    end
+
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Conversion
+    include ActiveModel::MassAssignmentSecurity if defined?(ActiveModel::MassAssignmentSecurity)
+    include ActiveModel::Naming
+    include ActiveModel::Observing if defined?(ActiveModel::Observing)
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include Dynamoid::Fields
+    include Dynamoid::Indexes
+    include Dynamoid::Persistence
+    include Dynamoid::Finders
+    include Dynamoid::Associations
+    include Dynamoid::Criteria
+    include Dynamoid::Validations
+    include Dynamoid::IdentityMap
+    include Dynamoid::Dirty
+  end
+end