ninja-model 0.8.1 → 0.9.0

data/lib/ninja_model/associations/association_scope.rb

@@ -0,0 +1,39 @@
+module NinjaModel
+  module Associations
+    class AssociationScope
+
+      attr_reader :association
+
+      delegate :klass, :owner, :reflection, :to => :association
+      delegate :chain, :conditions, :options, :ninja_model, :active_record, :to => :reflection
+
+      def initialize(association)
+        @association = association
+      end
+
+      def scope
+        scope = klass.unscoped
+        scope = scope.extending(*Array.wrap(options[:extend]))
+        scope = scope.apply_finder_options(
+          options.slice(
+            :order, :limit, :joins, :group, :having, :offset
+          )
+        )
+
+        add_constraints(scope)
+      end
+
+      def add_constraints(scope)
+        if reflection.source_macro == :belongs_to
+          key = reflection.association_primary_key
+          foreign_key = reflection.foreign_key
+        else
+          key = reflection.foreign_key
+          foreign_key = reflection.active_record_primary_key
+        end
+
+        scope = scope.where(key => owner[foreign_key])
+      end
+    end
+  end
+end

data/lib/ninja_model/associations/belongs_to_association.rb

@@ -1,38 +1,50 @@
 module NinjaModel
   module Associations
-    class BelongsToAssociation < AssociationProxy
-      def initialize(owner, reflection)
-        @owner, @reflection = owner, reflection
-      end
+    class BelongsToAssociation < SingularAssociation
 
       def replace(record)
-        if record.nil?
-          @target = @owner[@reflection.primary_key_name] = nil
-        else
-          @target = (AssociationProxy === record ? record.target : record)
-          @owner[@reflection.primary_key_name] = record_id(record) if record.persisted?
-          @updated = true
-        end
-        loaded
-        record
+        raise_on_type_mismatch(record) if record
+
+        replace_keys(record)
+
+        @updated = true if record
+
+        self.target = record
+      end
+
+      def updated?
+        @updated
       end
 
       private
 
-      def find_target
-        if @reflection.options[:primary_key]
-          @reflection.klass.scoped.where( @reflection.options[:primary_key] => @owner.send(@reflection.primary_key_name)).first
+      def find_target?
+        !loaded? && foreign_key_present? && klass
+      end
+
+      def different_target?(record)
+        record.nil? && owner[reflection.foreign_key] ||
+          record && record.id != owner[reflection.foreign_key]
+      end
+
+      def replace_keys(record)
+        if record
+          owner[reflection.foreign_key] = record[reflection.association_primary_key(record.class)]
         else
-          @reflection.klass.scoped.where( :id => @owner.send(@reflection.primary_key_name)).first
+          owner[reflection.foreign_key] = nil
         end
       end
 
-      def record_id(record)
-        record.send(@reflection.options[:primary_key] || :id)
+      def foreign_key_present?
+        owner[reflection.foreign_key]
       end
 
-      def foreign_key_present
-        !@owner[@reflection.primary_key_name].nil?
+      def target_id
+        if options[:primary_key]
+          owner.send(reflection.name).try(:id)
+        else
+          owner[reflection.foreign_key]
+        end
       end
     end
   end

data/lib/ninja_model/associations/builder/association.rb

@@ -0,0 +1,57 @@
+module NinjaModel
+  module Associations
+    module Builder
+      class Association
+        class_attribute :valid_options
+
+        self.valid_options = [:class_name, :foreign_key, :select, :conditions, :extend]
+
+        class_attribute :macro
+
+        attr_reader :model, :name, :options, :reflection
+
+        def self.build(model, name, options)
+          new(model, name, options).build
+        end
+
+        def initialize(model, name, options)
+          @model, @name, @options = model, name, options
+        end
+
+        def build
+          validate_options
+          reflection = model.create_reflection(self.class.macro, name, options, model)
+          define_accessors
+          reflection
+        end
+
+        private
+
+        def validate_options
+          options.assert_valid_keys(self.class.valid_options)
+        end
+
+        def define_accessors
+          define_readers
+          define_writers
+        end
+
+        def define_readers
+          name = self.name
+
+          model.redefine_method(name) do |*params|
+            association(name).reader(*params)
+          end
+        end
+
+        def define_writers
+          name = self.name
+
+          model.redefine_method("#{name}=") do |value|
+            association(name).writer(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ninja_model/associations/builder/belongs_to.rb

@@ -0,0 +1,33 @@
+module NinjaModel
+  module Associations
+    module Builder
+      class BelongsTo < SingularAssociation
+        self.macro = :belongs_to
+
+        def build
+          reflection = super
+          configure_dependency
+          reflection
+        end
+
+        private
+
+        def configure_dependency
+          if options[:dependent]
+            unless options[:dependenc].in?([:destroy, :delete])
+              raise ArgumentError, "The :dependent option expects either :destroy or delete (#{options[:dependent].inspect})"
+            end
+
+            method_name = "belongs_to_dependent_#{options[:dependent]}_for_#{name}"
+            model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
+              def #{method_name}
+                association = #{name}
+                association.#{options[:dependent]} if association
+              end
+            eoruby
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ninja_model/associations/builder/collection_association.rb

@@ -0,0 +1,60 @@
+module NinjaModel
+  module Associations
+    module Builder
+      class CollectionAssociation < Association
+        CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
+
+        self.valid_options += [
+          :order, :group, :limit, :offset, :before_add, :after_add,
+          :before_remove, :after_remove
+        ]
+
+        def self.build(model, name, options, &extension)
+          new(model, name, options, &extension).build
+        end
+
+        def initialize(model, name, options, &extension)
+          super(model, name, options)
+        end
+
+        def build
+          reflection = super
+          CALLBACKS.each { |callback_name| define_callback(callback_name) }
+          reflection
+        end
+
+        def writable?
+          true
+        end
+
+        private
+
+        def define_callback(callback_name)
+          full_callback_name = "#{callback_name}_for_#{name}"
+
+          model.class_attribute full_callback_name.to_sym unless model.method_defined?(full_callback_name)
+
+          model.send("#{full_callback_name}=", Array.wrap(options[callback_name.to_sym]))
+        end
+
+        def define_readers
+          super
+
+          name = self.name
+          model.redefine_method("#{name.to_s.singularize}_ids") do
+            association(name).ids_reader
+          end
+        end
+
+        def define_writers
+          super
+
+          name = self.name
+          model.redefine_method("#{name.to_s.singularize}_ids=") do |ids|
+            association(name).ids_writer(ids)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ninja_model/associations/builder/has_many.rb

@@ -0,0 +1,11 @@
+module NinjaModel
+  module Associations
+    module Builder
+      class HasMany < CollectionAssociation
+        self.macro = :has_many
+
+        self.valid_options += [:primary_key]
+      end
+    end
+  end
+end

data/lib/ninja_model/associations/builder/has_one.rb

@@ -0,0 +1,20 @@
+module NinjaModel
+  module Associations
+    module Builder
+      class HasOne < SingularAssociation
+        self.macro = :has_one
+
+        def constructable?
+          true
+        end
+
+        private
+
+        def validate_options
+          valid_options = self.class.valid_options
+          options.assert_valid_keys(valid_options)
+        end
+      end
+    end
+  end
+end

data/lib/ninja_model/associations/builder/singular_association.rb

@@ -0,0 +1,49 @@
+module NinjaModel
+  module Associations
+    module Builder
+      class SingularAssociation < Association
+        self.valid_options += [:dependent, :primary_key]
+
+        def constructable?
+          true
+        end
+
+        def define_accessors
+          super
+          define_constructors if constructable?
+        end
+
+        private
+
+        def define_readers
+          super
+          name = self.name
+
+          model.redefine_method("#{name}_loaded?") do
+            ActiveSupport::Deprecation.warn(
+              "Calling obj.#{name}_loaded? is deprecated.  Please use " \
+              "obj.association(:#{name}).loaded? instead."
+            )
+            association(name).loaded?
+          end
+        end
+
+        def define_constructors
+          name = self.name
+
+          model.redefine_method("build_#{name}") do |*params, &block|
+            association(name).build(*params, &block)
+          end
+
+          model.redefine_method("create_#{name}") do |*params, &block|
+            association(name).create(*params, &block)
+          end
+
+          model.redefine_method("create_#{name}!") do |*params, &block|
+            association(name).create!(*params, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ninja_model/associations/collection_association.rb

@@ -0,0 +1,103 @@
+module NinjaModel
+  module Associations
+    class CollectionAssociation < Association
+      attr_reader :proxy
+      delegate :select, :find, :first, :last, :count, :size, :length,
+        :empty?, :any?, :to => :scoped
+
+      def initialize(owner, reflection)
+        super
+        @proxy = CollectionProxy.new(self)
+      end
+
+      def reader(force_reload = false)
+        if force_reload
+          klass.uncached { reload }
+        end
+        proxy
+      end
+
+      def reset
+        @loaded = false
+        @target = []
+      end
+
+      #def find(*args)
+      #  if block_given?
+      #    load_target.find(*args) { |*block_args| yield(*block_args) }
+      #  else
+      #    scoped.find(*args)
+      #  end
+      #end
+
+      def first(*args)
+        first_or_last(:first, *args)
+      end
+
+      def last(*args)
+        first_or_last(:last, *args)
+      end
+
+      def build(attributes = {}, options = {}, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| build(attr, options, &block) }
+        else
+          add_to_target(build_record(attributes, options)) do |record|
+            yield(record) if block_given?
+          end
+        end
+      end
+
+      #def create(attributes = {}, options = {}, &block)
+      #  create_record(attributes, options, &block)
+      #end
+
+      #def create!(attributes = {}, options = {}, &block)
+      #  create_record(attributes, options, true, &block)
+      #end
+
+      def add_to_target(record)
+        yield(record) if block_given?
+        @target << record
+        record
+      end
+
+      private
+
+      def find_target
+        puts "find_target for #{self}"
+        scoped.all
+      end
+
+      #def create_record(attributes, options, raise = false, &block)
+      #  unless owner.persisted?
+      #    raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
+      #  end
+
+      #  if attributes.is_a?(Array)
+      #    attributes.collect { |attr| create_record(attr, options, raise, &block) }
+      #  else
+      #    add_to_target(build_record(attributes, options)) do |record|
+      #      yield(record) if block_given?
+      #      insert_record(record, true, raise)
+      #    end
+      #  end
+      #end
+
+      #def insert_record(record, validate = true, raise = false)
+      #  raise NotImplementedError
+      #end
+
+      def create_scope
+        scoped.scope_for_create.stringify_keys
+      end
+
+      def first_or_last(type, *args)
+        args.shift if args.first.is_a?(Hash) && args.first.empty?
+
+        collection = scoped.all
+        collection.send(type, *args)
+      end
+    end
+  end
+end