humanoid 1.2.7

data/lib/humanoid/associations/has_many_related.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Associations #:nodoc:
+    class HasManyRelated #:nodoc:
+      include Proxy
+
+      # Appends the object to the +Array+, setting its parent in
+      # the process.
+      def <<(*objects)
+        objects.flatten.each do |object|
+          object.send("#{@foreign_key}=", @parent.id)
+          @target << object
+          object.save unless @parent.new_record?
+        end
+      end
+
+      # Builds a new Document and adds it to the association collection. The
+      # document created will be of the same class as the others in the
+      # association, and the attributes will be passed into the constructor.
+      #
+      # Returns the newly created object.
+      def build(attributes = {})
+        name = @parent.class.to_s.underscore
+        object = @klass.instantiate(attributes.merge(name => @parent))
+        @target << object
+        object
+      end
+
+      # Delegates to <<
+      def concat(*objects)
+        self << objects
+      end
+
+      # Creates a new Document and adds it to the association collection. The
+      # document created will be of the same class as the others in the
+      # association, and the attributes will be passed into the constructor and
+      # the new object will then be saved.
+      #
+      # Returns the newly created object.
+      def create(attributes)
+        object = build(attributes)
+        object.save
+        object
+      end
+
+      # Finds a document in this association.
+      # If an id is passed, will return the document for that id.
+      def find(*args)
+        args[1][:conditions].merge!(@foreign_key.to_sym => @parent.id) if args.size > 1
+        @klass.find(*args)
+      end
+
+      # Initializing a related association only requires looking up the objects
+      # by their ids.
+      #
+      # Options:
+      #
+      # document: The +Document+ that contains the relationship.
+      # options: The association +Options+.
+      def initialize(document, options, target = nil)
+        @parent, @klass = document, options.klass
+        @foreign_key = document.class.to_s.foreign_key
+        @target = target || @klass.all(:conditions => { @foreign_key => document.id })
+        extends(options)
+      end
+
+      # Delegates to <<
+      def push(*objects)
+        self << objects
+      end
+
+      class << self
+        # Preferred method for creating the new +HasManyRelated+ association.
+        #
+        # Options:
+        #
+        # document: The +Document+ that contains the relationship.
+        # options: The association +Options+.
+        def instantiate(document, options, target = nil)
+          new(document, options, target)
+        end
+
+        # Returns the macro used to create the association.
+        def macro
+          :has_many_related
+        end
+
+        # Perform an update of the relationship of the parent and child. This
+        # will assimilate the child +Document+ into the parent's object graph.
+        #
+        # Options:
+        #
+        # related: The related object
+        # parent: The parent +Document+ to update.
+        # options: The association +Options+
+        #
+        # Example:
+        #
+        # <tt>RelatesToOne.update(game, person, options)</tt>
+        def update(target, document, options)
+          name = document.class.to_s.underscore
+          target.each { |child| child.send("#{name}=", document) }
+          instantiate(document, options, target)
+        end
+      end
+
+    end
+  end
+end

data/lib/humanoid/associations/has_one.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Associations #:nodoc:
+    class HasOne #:nodoc:
+      include Proxy
+
+      # Build a new object for the association.
+      def build(attrs = {}, type = nil)
+        @target = attrs.assimilate(@parent, @options, type); self
+      end
+
+      # Creates the new association by finding the attributes in
+      # the parent document with its name, and instantiating a
+      # new document for it.
+      #
+      # All method calls on this object will then be delegated
+      # to the internal document itself.
+      #
+      # Options:
+      #
+      # document: The parent +Document+
+      # attributes: The attributes of the target object.
+      # options: The association options.
+      #
+      # Returns:
+      #
+      # A new +HashOne+ association proxy.
+      def initialize(document, attrs, options)
+        @parent, @options  = document, options
+        @target = attrs.assimilate(@parent, @options, attrs.klass)
+        extends(options)
+      end
+
+      # Used for setting the association via a nested attributes setter on the
+      # parent +Document+. Called when using accepts_nested_attributes_for.
+      #
+      # Options:
+      #
+      # attributes: The attributes for the new association
+      #
+      # Returns:
+      #
+      # A new target document.
+      def nested_build(attributes)
+        build(attributes)
+      end
+
+      class << self
+        # Preferred method of instantiating a new +HasOne+, since nil values
+        # will be handled properly.
+        #
+        # Options:
+        #
+        # document: The parent +Document+
+        # options: The association options.
+        #
+        # Returns:
+        #
+        # A new +HasOne+ association proxy.
+        def instantiate(document, options)
+          attributes = document.raw_attributes[options.name]
+          return nil if attributes.blank?
+          new(document, attributes, options)
+        end
+
+        # Returns the macro used to create the association.
+        def macro
+          :has_one
+        end
+
+        # Perform an update of the relationship of the parent and child. This
+        # will assimilate the child +Document+ into the parent's object graph.
+        #
+        # Options:
+        #
+        # child: The child +Document+ or +Hash+.
+        # parent: The parent +Document+ to update.
+        # options: The association +Options+
+        #
+        # Example:
+        #
+        # <tt>HasOne.update({:first_name => "Hank"}, person, options)</tt>
+        #
+        # Returns:
+        #
+        # A new +HasOne+ association proxy.
+        def update(child, parent, options)
+          child.assimilate(parent, options)
+          instantiate(parent, options)
+        end
+      end
+
+    end
+  end
+end

data/lib/humanoid/associations/has_one_related.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Associations #:nodoc:
+    class HasOneRelated #:nodoc:
+      include Proxy
+
+      delegate :nil?, :to => :target
+
+      # Builds a new Document and sets it as the association.
+      #
+      # Returns the newly created object.
+      def build(attributes = {})
+        @target = @klass.instantiate(attributes)
+        name = @parent.class.to_s.underscore
+        @target.send("#{name}=", @parent)
+        @target
+      end
+
+      # Builds a new Document and sets it as the association, then saves the
+      # newly created document.
+      #
+      # Returns the newly created object.
+      def create(attributes)
+        build(attributes); @target.save; @target
+      end
+
+      # Initializing a related association only requires looking up the objects
+      # by their ids.
+      #
+      # Options:
+      #
+      # document: The +Document+ that contains the relationship.
+      # options: The association +Options+.
+      def initialize(document, options, target = nil)
+        @parent, @klass = document, options.klass
+        @foreign_key = document.class.to_s.foreign_key
+        @target = target || @klass.first(:conditions => { @foreign_key => @parent.id })
+        extends(options)
+      end
+
+      class << self
+        # Preferred method for creating the new +RelatesToMany+ association.
+        #
+        # Options:
+        #
+        # document: The +Document+ that contains the relationship.
+        # options: The association +Options+.
+        def instantiate(document, options, target = nil)
+          new(document, options, target)
+        end
+
+        # Returns the macro used to create the association.
+        def macro
+          :has_one_related
+        end
+
+        # Perform an update of the relationship of the parent and child. This
+        # will assimilate the child +Document+ into the parent's object graph.
+        #
+        # Options:
+        #
+        # related: The related object to update.
+        # document: The parent +Document+.
+        # options: The association +Options+
+        #
+        # Example:
+        #
+        # <tt>HasOneToRelated.update(game, person, options)</tt>
+        def update(target, document, options)
+          if target
+            name = document.class.to_s.underscore
+            target.send("#{name}=", document)
+            return instantiate(document, options, target)
+          end
+          target
+        end
+      end
+
+    end
+  end
+end

data/lib/humanoid/associations/options.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Associations #:nodoc:
+    class Options #:nodoc:
+
+      # Create the new +Options+ object, which provides convenience methods for
+      # accessing values out of an options +Hash+.
+      def initialize(attributes = {})
+        @attributes = attributes
+      end
+
+      # Returns the extension if it exists, nil if not.
+      def extension
+        @attributes[:extend]
+      end
+
+      # Returns true is the options have extensions.
+      def extension?
+        !extension.nil?
+      end
+
+      # Return the foreign key based off the association name.
+      def foreign_key
+        name.to_s.foreign_key
+      end
+
+      # Returns the name of the inverse_of association
+      def inverse_of
+        @attributes[:inverse_of]
+      end
+
+      # Return a +Class+ for the options. If a class_name was provided, then the
+      # constantized class_name will be returned. If not, a constant based on the
+      # association name will be returned.
+      def klass
+        class_name = @attributes[:class_name]
+        class_name ? class_name.constantize : name.to_s.classify.constantize
+      end
+
+      # Returns the association name of the options.
+      def name
+        @attributes[:name].to_s
+      end
+
+      # Returns the parent foreign key association name.
+      def parent_key
+        @attributes[:parent_key]
+      end
+
+      # Returns whether or not this association is polymorphic.
+      def polymorphic
+        @attributes[:polymorphic] == true
+      end
+
+    end
+  end
+end

data/lib/humanoid/associations/proxy.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+module Humanoid #:nodoc
+  module Associations #:nodoc
+    module Proxy #:nodoc
+      def self.included(base)
+        base.class_eval do
+          instance_methods.each do |method|
+            undef_method(method) unless method =~ /(^__|^nil\?$|^send$|^object_id$|^extend$)/
+          end
+          include InstanceMethods
+        end
+      end
+      module InstanceMethods #:nodoc:
+        attr_reader \
+          :options,
+          :target
+
+        # Default behavior of method missing should be to delegate all calls
+        # to the target of the proxy. This can be overridden in special cases.
+        def method_missing(name, *args, &block)
+          @target.send(name, *args, &block)
+        end
+
+        # If anonymous extensions are added this will take care of them.
+        def extends(options)
+          extend Module.new(&options.extension) if options.extension?
+        end
+      end
+    end
+  end
+end

data/lib/humanoid/attributes.rb

@@ -0,0 +1,184 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Attributes
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
+        extend ClassMethods
+      end
+    end
+    module InstanceMethods
+      # Get the id associated with this object. This will pull the _id value out
+      # of the attributes +Hash+.
+      def id
+        @attributes["_id"]
+      end
+
+      # Set the id of the +Document+ to a new one.
+      def id=(new_id)
+        @attributes["_id"] = new_id
+      end
+
+      alias :_id :id
+      alias :_id= :id=
+
+      # Used for allowing accessor methods for dynamic attributes.
+      def method_missing(name, *args)
+        attr = name.to_s
+        return super unless @attributes.has_key?(attr.reader)
+        if attr.writer?
+          # "args.size > 1" allows to simulate 1.8 behavior of "*args"
+          @attributes[attr.reader] = (args.size > 1) ? args : args.first
+        else
+          @attributes[attr.reader]
+        end
+      end
+
+      # Process the provided attributes casting them to their proper values if a
+      # field exists for them on the +Document+. This will be limited to only the
+      # attributes provided in the suppied +Hash+ so that no extra nil values get
+      # put into the document's attributes.
+      def process(attrs = nil)
+        (attrs || {}).each_pair do |key, value|
+          if set_allowed?(key)
+            @attributes[key.to_s] = value
+          else
+            send("#{key}=", value) if value
+          end
+        end
+      end
+
+      # Read a value from the +Document+ attributes. If the value does not exist
+      # it will return nil.
+      #
+      # Options:
+      #
+      # name: The name of the attribute to get.
+      #
+      # Example:
+      #
+      # <tt>person.read_attribute(:title)</tt>
+      def read_attribute(name)
+        access = name.to_s
+        fields[access].get(@attributes[access])
+      end
+
+      # Remove a value from the +Document+ attributes. If the value does not exist
+      # it will fail gracefully.
+      #
+      # Options:
+      #
+      # name: The name of the attribute to remove.
+      #
+      # Example:
+      #
+      # <tt>person.remove_attribute(:title)</tt>
+      def remove_attribute(name)
+        @attributes.delete(name.to_s)
+      end
+
+      # Returns the object type. This corresponds to the name of the class that
+      # this +Document+ is, which is used in determining the class to
+      # instantiate in various cases.
+      def _type
+        @attributes["_type"]
+      end
+
+      # Set the type of the +Document+. This should be the name of the class.
+      def _type=(new_type)
+        @attributes["_type"] = new_type
+      end
+
+      # Write a single attribute to the +Document+ attribute +Hash+. This will
+      # also fire the before and after update callbacks, and perform any
+      # necessary typecasting.
+      #
+      # Options:
+      #
+      # name: The name of the attribute to update.
+      # value: The value to set for the attribute.
+      #
+      # Example:
+      #
+      # <tt>person.write_attribute(:title, "Mr.")</tt>
+      #
+      # This will also cause the observing +Document+ to notify it's parent if
+      # there is any.
+      def write_attribute(name, value)
+        access = name.to_s
+        @attributes[access] = fields[access].set(value)
+        notify unless id.blank?
+      end
+
+      # Writes the supplied attributes +Hash+ to the +Document+. This will only
+      # overwrite existing attributes if they are present in the new +Hash+, all
+      # others will be preserved.
+      #
+      # Options:
+      #
+      # attrs: The +Hash+ of new attributes to set on the +Document+
+      #
+      # Example:
+      #
+      # <tt>person.write_attributes(:title => "Mr.")</tt>
+      #
+      # This will also cause the observing +Document+ to notify it's parent if
+      # there is any.
+      def write_attributes(attrs = nil)
+        process(attrs || {})
+        identify if id.blank?
+        notify
+      end
+      alias :attributes= write_attributes
+
+      protected
+      # Return true is dynamic field setting is enabled.
+      def set_allowed?(key)
+        Humanoid.allow_dynamic_fields && !respond_to?("#{key}=")
+      end
+
+      # Used when supplying a :reject_if block as an option to
+      # accepts_nested_attributes_for
+      def reject(attributes, options)
+        rejector = options[:reject_if]
+        if rejector
+          attributes.delete_if do |key, value|
+            rejector.call(value)
+          end
+        end
+      end
+
+    end
+
+    module ClassMethods
+      # Defines attribute setters for the associations specified by the names.
+      # This will work for a has one or has many association.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Humanoid::Document
+      #     has_one :name
+      #     has_many :addresses
+      #
+      #     accepts_nested_attributes_for :name, :addresses
+      #   end
+      def accepts_nested_attributes_for(*args)
+        associations = args.flatten
+        options = associations.last.is_a?(Hash) ? associations.pop : {}
+        associations.each do |name|
+          define_method("#{name}_attributes=") do |attrs|
+            reject(attrs, options)
+            association = send(name)
+            if association
+              update(association, true)
+              association.nested_build(attrs)
+            else
+              send("build_#{name}", attrs)
+            end
+          end
+        end
+      end
+    end
+  end
+end