ninja-model 0.8.1 → 0.9.0

data/lib/ninja_model/associations/collection_proxy.rb

@@ -0,0 +1,45 @@
+module NinjaModel
+  module Associations
+    class CollectionProxy
+
+      delegate :order, :limit, :where, :to => :scoped
+
+      delegate :target, :load_target, :loaded?, :scoped, :to => :@association
+
+      delegate :select, :find, :first, :last, :build, :create, :create,
+        :count, :size, :length, :empty?, :any?, :to => :@association
+
+      def initialize(association)
+        @association = association
+      end
+
+      def proxy_association
+        @association
+      end
+
+      def respond_to?(name, include_private = false)
+        super ||
+          (load_target && target.respond_to?(name, include_private)) ||
+          proxy_association.klass.respond_to?(name, include_private)
+      end
+
+      def method_missing(method, *args, &block)
+        if target.respond_to?(method) || (!proxy_association.klass.respond_to?(method) && Class.respond_to?(method))
+          if load_target
+            if target.respond_to?(method)
+              target.send(method, *args, &block)
+            else
+              begin
+                super
+              rescue NoMethodError => e
+                raise e, e.message.sub(/ for #<.*$/, "via proxy for #{target}")
+              end
+            end
+          end
+        else
+          scoped.send(method, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/ninja_model/associations/has_many_association.rb

@@ -1,48 +1,24 @@
 module NinjaModel
   module Associations
-    class HasManyAssociation
-      def initialize(owner, reflection)
-        @owner, @reflection = owner, reflection
-        @relation = apply_default_scope(reflection.klass.scoped)
-      end
-
-      delegate :each, :collect, :map, :to_a, :size, :blank?, :empty?, :to => :relation
-
-      def method_missing(method, *args)
-        if @relation.respond_to?(method)
-          @relation.send(method, *args)
-        elsif @relation.klass.respond_to?(method)
-          apply_default_scope(@relation.klass.scoped).send(method, *args)
-        else
-          super
-        end
-      end
-
-      def relation
-        @relation
-      end
-
-      def inspect
-        @relation.to_a.inspect
-      end
-
-      def replace(other_array)
-        @current = other_array
-      end
-
-      def blank?
-        @relation.blank?
-      end
-
-      def to_ary
-        @relation.to_a
-      end
-
-      private
-
-      def apply_default_scope(scoping)
-        scoping.where(@reflection.primary_key_name.to_sym.eq(@owner.id))
-      end
+    class HasManyAssociation < CollectionAssociation
+
+      #def insert_record(record, validate = true, raise = false)
+      #  set_owner_attributes(record)
+
+      #  if raise
+      #    record.save!(:validate => validate)
+      #  else
+      #    record.save(:validate => validate)
+      #  end
+      #end
+
+      #def association_scope
+      #  scope = super
+      #  puts "primary_key: #{reflection.primary_key}"
+      #  puts "foreign_key: #{reflection.foreign_key}"
+      #  scope = scope.where(reflection.foreign_key => owner.send(reflection.primary_key))
+      #  scope
+      #end
     end
   end
 end

data/lib/ninja_model/associations/has_one_association.rb

@@ -1,18 +1,64 @@
 module NinjaModel
   module Associations
-    class HasOneAssociation < AssociationProxy
+    class HasOneAssociation < SingularAssociation
+
+      def replace(record, save = true)
+        raise_on_type_mismatch(record) if record
+        load_target
+
+        if target && target != record
+          remove_target!(options[:dependent]) unless target.destroyed?
+        end
+
+        if record
+          set_owner_attributes(record)
+          set_inverse_instance(record)
+
+          if owner.persisted? && save && !record.save
+            nullify_owner_attributes(record)
+            set_owner_attributes(target) if target
+            raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
+          end
+        end
+
+        self.target = record
 
-      def create(attrs = {}, replace_existing = true)
-        new_record
+      end
+
+      def delete(method = options[:dependent])
+        if load_target
+          case method
+          when :delete
+            target.delete
+          when :destroy
+            target.destroy
+          when :nullify
+            target.update_attribute(reflection.foreign_key, nil)
+          end
+        end
       end
 
       private
 
-      def find_target
-        @reflection.klass.scoped.where(@reflection.primary_key_name => @owner.send(:id)).first
+      def set_new_record(record)
+        replace(record, false)
+      end
+
+      def remove_target!(method)
+        if method.in?([:delete, :destroy])
+          target.send(method)
+        else
+          nullify_owner_attributes(target)
+
+          if target.persisted? && owner.persisted? && !target.save
+            set_owner_attributes(target)
+            raise RecordNotSaved, "Failed to remove the existing associated #{reflection.name}.  The record failed to save when after its foreign key was set to nil."
+          end
+        end
       end
 
-      def new_record(replace_existing)
+      def nullify_owner_attributes(record)
+        record[reflection.foreign_key] = nil
       end
     end
   end

data/lib/ninja_model/associations/singular_association.rb

@@ -0,0 +1,61 @@
+module NinjaModel
+  module Associations
+    class SingularAssociation < Association
+      def reader(force_reload = false)
+        if force_reload
+          klass.uncached { reload }
+        elsif !loaded? || stale_target?
+          reload
+        end
+
+        target
+      end
+
+      def writer(record)
+        replace(record)
+      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 build(attributes = {}, options = {})
+        record = build_record(attributes, options)
+        yield(record) if block_given?
+        set_new_record(record)
+        record
+      end
+
+      private
+
+      def create_scope
+        scoped.scope_for_create.stringify_keys.except(klass.primary_key)
+      end
+
+      def find_target
+        scoped.first.tap { |record| set_inverse_instance(record) }
+      end
+
+      def replace(record)
+        raise NotImplementedError, "Subclasses must implement a replace(record) method"
+      end
+
+      def set_new_record(record)
+        replace(record)
+      end
+
+      def create_record(attributes, options, raise_error = false)
+        record = build_record(attributes, options)
+        yield(record) if block_given?
+        saved = record.save
+        set_new_record(record)
+        raise RecordInvalid.new(record) if !saved && raise_error
+        record
+      end
+    end
+  end
+end

data/lib/ninja_model/attribute.rb

@@ -130,8 +130,11 @@ module NinjaModel
       end
 
       def fallback_string_to_date(string)
-        ::Date.strptime(string, I18n.translate('date.formats.default'))
-        #new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
+        begin
+          ::Date.strptime(string, I18n.translate('date.formats.default'))
+        rescue ArgumentError
+          nil
+        end
       end
 
       def fallback_string_to_time(string)

data/lib/ninja_model/attribute_methods.rb

@@ -1,15 +1,35 @@
 module NinjaModel
-  class Base
-    class UnknownAttributeError < NinjaModelError; end
-    include ActiveModel::AttributeMethods
-    include ActiveModel::Dirty
 
-    #class_attribute :model_attributes
-    #self.model_attributes = []
-    attribute_method_suffix('', '=', '_before_type_cast')
+  class UnknownAttributeError < NinjaModelError; end
+  class AttributeAssignmentError < NinjaModelError
+    attr_reader :exception, :attribute
+    attr_reader :mymessage
+    def initialize(message, exception, attribute)
+      @exception = exception
+      @attribute = attribute
+      @message = message
+      @mymessage = message
+    end
+  end
+  class MultiparameterAssignmentErrors < NinjaModelError
+    attr_reader :errors
+    def initialize(errors)
+      @errors = errors
+    end
+  end
 
-    class << self
+  module AttributeMethods
+    extend ActiveSupport::Concern
 
+    included do
+      include ActiveModel::AttributeMethods
+      include ActiveModel::Dirty
+      class_attribute :model_attributes
+      self.model_attributes = []
+      attribute_method_suffix('', '=', '_before_type_cast')
+    end
+
+    module ClassMethods
       def attribute(name, data_type, *args)
         name = name.to_s
         opts = args.extract_options!
@@ -17,14 +37,8 @@ module NinjaModel
         self.primary_key = name if primary.eql?(true)
         default = args.first unless args.blank?
         new_attr = Attribute.new(name, data_type, opts)
-        self.model_attributes << new_attr
-        define_attribute_methods(true)
-      end
-
-      def define_attribute_methods(force = false)
-        return unless self.model_attributes
-        undefine_attribute_methods if force
-        super(self.model_attributes.map { |attr| attr.name })
+        self.model_attributes = model_attributes + [new_attr]
+        define_attribute_method name
       end
 
       def columns
@@ -43,25 +57,6 @@ module NinjaModel
 
       alias :column_names :attribute_names
     end
-  end
-
-  module AttributeMethods
-    class AttributeAssignmentError < NinjaModelError
-      attr_reader :exception, :attribute
-      attr_reader :mymessage
-      def initialize(message, exception, attribute)
-        @exception = exception
-        @attribute = attribute
-        @message = message
-        @mymessage = message
-      end
-    end
-    class MultiparameterAssignmentErrors < NinjaModelError
-      attr_reader :errors
-      def initialize(errors)
-        @errors = errors
-      end
-    end
 
     def attributes_from_model_attributes
       self.class.model_attributes.inject({}) do |result, attr|
@@ -106,17 +101,17 @@ module NinjaModel
         if k.include?('(')
           multi_parameter_attributes << [k, v]
         else
-          respond_to?("#{k}=".to_sym) ? send("#{k}=".to_sym, v) : raise(NinjaModel::Base::UnknownAttributeError, "unknown attribute: #{k}")
+          respond_to?("#{k}=".to_sym) ? send("#{k}=".to_sym, v) : raise(NinjaModel::UnknownAttributeError, "unknown attribute: #{k}")
         end
       end
 
       assign_multiparameter_attributes(multi_parameter_attributes)
     end
 
-    def attribute_method?(name)
-      name = name.to_s
-      self.class.model_attributes_hash.key?(name)
-    end
+    #def attribute_method?(name)
+    #  name = name.to_s
+    #  self.class.model_attributes_hash.key?(name)
+    #end
 
     private
 

data/lib/ninja_model/base.rb

@@ -1,14 +1,4 @@
-require 'ninja_model/attribute_methods'
-require 'ninja_model/associations'
-require 'ninja_model/adapters'
-require 'ninja_model/callbacks'
-require 'ninja_model/identity'
-require 'ninja_model/persistence'
-require 'ninja_model/predicate'
-require 'ninja_model/reflection'
-require 'ninja_model/relation'
-require 'ninja_model/validation'
-require 'ninja_model/attribute'
+require 'ninja_model/core_ext/symbol'
 require 'active_record/named_scope'
 require 'active_record/aggregations'
 
@@ -25,29 +15,19 @@ module NinjaModel
     extend ActiveModel::Translation
     extend ActiveModel::Naming
     include ActiveModel::Observing
-    include ActiveModel::Dirty
     include ActiveRecord::Aggregations
     include ActiveRecord::NamedScope
     include ActiveModel::Serializers::JSON
     include ActiveModel::Serializers::Xml
 
     define_model_callbacks :initialize, :find, :touch, :only => :after
+    class_attribute :pluralize_table_names, :instance_writer => false
+    self.pluralize_table_names = true
+
+    class_attribute :default_scopes
+    self.default_scopes = []
 
     class << self
-      def inherited(subclass)
-        subclass.class_attribute :model_attributes
-        if self.respond_to?(:model_attributes)
-          subclass.model_attributes = self.model_attributes.dup
-        else
-          subclass.model_attributes = []
-        end
-        subclass.class_attribute :default_scoping
-        if self.respond_to?(:default_scoping)
-          subclass.default_scoping = self.default_scoping.dup
-        else
-          subclass.default_scoping = []
-        end
-      end
 
       delegate :find, :first, :last, :all, :exists?, :to => :scoped
       delegate :where, :order, :limit, :to => :scoped
@@ -66,12 +46,12 @@ module NinjaModel
 
       def scoped_methods
         key = "#{self}_scoped_methods".to_sym
-        Thread.current[key] = Thread.current[key].presence || self.default_scoping.dup
+        Thread.current[key] = Thread.current[key].presence || self.default_scopes.dup
       end
 
-      def default_scope(options = {})
-        reset_scoped_methods
-        self.default_scoping << build_finder_relation(options, default_scoping.pop)
+      def default_scope(scope = {})
+        scope = Proc.new if block_given?
+        self.default_scopes = default_scopes + [scope]
       end
 
       def current_scope
@@ -87,7 +67,6 @@ module NinjaModel
         Thread.current["#{self}_scoped_methods".to_sym] = nil
       end
 
-      private
 
       def build_finder_relation(options = {}, scope = nil)
         relation = options.is_a?(Hash) ? unscoped.apply_finder_options(options) : options
@@ -121,15 +100,27 @@ module NinjaModel
       end
     end
 
+    def assign_attributes(new_attributes, options = {})
+      return unless new_attributes
+
+      attributes = new_attributes.stringify_keys
+
+      attributes.each do |k, v|
+        if respond_to?("#{k}=")
+          send("#{k}=", v)
+        else
+          raise(StandardError, "unknown attribute: #{k}")
+        end
+      end
+    end
+
     def attributes
-      attrs = {}
-      self.class.attribute_names.each { |name|
-        attrs[name] = read_attribute(name)
+      self.class.attribute_names.inject({}) { |h, v|
+        h[v] = read_attribute(v); h
       }
-      attrs
     end
 
-    def initialize(attributes = nil)
+    def initialize(attributes = nil, options = {})
       @attributes = attributes_from_model_attributes
       @association_cache = {}
       @aggregation_cache = {}
@@ -141,9 +132,8 @@ module NinjaModel
 
       self.attributes = attributes unless attributes.nil?
 
-      result = yield self if block_given?
-      _run_initialize_callbacks
-      result
+      yield self if block_given?
+      run_callbacks :initialize
     end
 
     def instantiate(record)
@@ -175,3 +165,5 @@ module NinjaModel
     end
   end
 end
+
+ActiveSupport.run_load_hooks(:ninja_model, NinjaModel::Base)