ninja-model 0.8.1 → 0.9.0

data/lib/ninja_model/identity.rb

@@ -1,11 +1,13 @@
 module NinjaModel
-  class Base
-    class_attribute :primary_key
-    self.primary_key = :id
-    undef_method(:id) if method_defined?(:id)
-  end
-
   module Identity
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :primary_key
+      self.primary_key = :id
+      undef_method(:id) if method_defined?(:id)
+    end
+
     def to_model
       self
     end

data/lib/ninja_model/rails_ext/active_record.rb

@@ -1,58 +1,42 @@
-require 'active_record'
-
 module ActiveRecord
-  class Base
-    class << self
-      def has_one_with_ninja_model(association_id, options = {})
-        klass = options[:class_name] || association_id
-        klass = klass.to_s.camelize
-        klass = klass.singularize
-        klass = compute_type(klass)
-        if NinjaModel.ninja_model?(klass)
-          ninja_proxy.handle_association(:has_one, association_id, options.merge({:class_name => klass.name}))
-        else
-          has_one_without_ninja_model(association_id, options)
-        end
-      end
-      alias_method_chain :has_one, :ninja_model
-
-      def has_many_with_ninja_model(association_id, options = {})
-        klass = options[:class_name] || association_id
-        klass = klass.to_s.camelize
-        klass = klass.singularize
-        klass = compute_type(klass)
-        if NinjaModel.ninja_model?(klass)
-          ninja_proxy.handle_association(:has_many, association_id, options.merge({:class_name => klass.name}))
-        else
-          has_many_without_ninja_model(association_id, options)
+  module NinjaModelExtensions
+    module ReflectionExt
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def create_reflection(macro, name, options, active_record)
+          klass = options[:class_name] || name
+          klass = klass.to_s.camelize
+          klass = klass.singularize if macro.in?([:has_many])
+          klass = compute_type(klass)
+          if NinjaModel.ninja_model?(klass)
+            case macro
+            when :has_many, :belongs_to, :has_one
+              reflection = NinjaModel::Reflection::AssociationReflection.new(macro, name, options, active_record)
+            else
+              raise NotImplementedError, "NinjaModel does not currently support #{macro} associations."
+            end
+            self.reflections = self.reflections.merge(name => reflection)
+            reflection
+          else
+            super
+          end
         end
-      end
-      alias_method_chain :has_many, :ninja_model
 
-      def reflect_on_association_with_ninja_model(association)
-        if read_inheritable_attribute(:ninja_proxy) && ninja_proxy.proxy_klass.reflections.include?(association)
-          ninja_proxy.proxy_klass.reflect_on_association(association)
-        else
-          reflect_on_association_without_ninja_model(association)
+        def reflect_on_aggregation(aggregation)
+          if reflections[aggregation].is_a?(NinjaModel::Reflection::AggregateReflection)
+            reflections[aggregation]
+          else
+            super
+          end
         end
-      end
-
-      alias_method_chain :reflect_on_association, :ninja_model
 
-      def ninja_proxy
-        read_inheritable_attribute(:ninja_proxy) || write_inheritable_attribute(:ninja_proxy, NinjaModel::Associations::NinjaModelProxy.new(self))
-      end
-
-    end
-
-    def method_missing(method, *args)
-      begin
-        super
-      rescue NoMethodError => ex
-        if self.class.read_inheritable_attribute(:ninja_proxy) && ninja_proxy.respond_to?(method)
-          ninja_proxy.send(method, *args)
-        else
-          raise ex
+        def reflect_on_association(association)
+          if reflections[association].is_a?(NinjaModel::Reflection::AssociationReflection)
+            reflections[association]
+          else
+            super
+          end
         end
       end
     end
@@ -60,191 +44,51 @@ module ActiveRecord
 end
 
 module NinjaModel
-
-  class Base
-    class << self
-      def has_one_with_active_record(association_id, options = {})
-        klass = options[:class_name] || association_id
-        klass = klass.to_s.camelize
-        klass = compute_type(klass)
-        if NinjaModel.ninja_model?(klass)
-          has_one_without_active_record(association_id, options.merge(:class_name => klass.name.underscore))
-        else
-          reflection = proxy.handle_association(:has_one, association_id, options)
-          write_inheritable_hash :reflections, association_id => reflection
-          reflection
-        end
-      end
-
-      alias_method_chain :has_one, :active_record
-
-      def belongs_to_with_active_record(association_id, options = {})
-        klass = options[:class_name] || association_id
-        klass = klass.to_s.camelize
-        klass = compute_type(klass)
-        if NinjaModel.ninja_model?(klass)
-          belongs_to_without_active_record(association_id, options.merge(:class_name => klass.name.underscore))
-        else
-          reflection = proxy.handle_association(:belongs_to, association_id, options)
-          write_inheritable_hash :reflections, association_id => reflection
-          reflection
-        end
-      end
-
-      alias_method_chain :belongs_to, :active_record
-
-      def has_many_with_active_record(association_id, options = {})
-        klass = options[:class_name] || association_id
-        klass = klass.to_s.camelize.singularize
-        klass = compute_type(klass)
-        if NinjaModel.ninja_model?(klass)
-          has_many_without_active_record(association_id, options.merge(:class_name => klass.name.underscore))
-        else
-          reflection = proxy.handle_association(:has_many, association_id, options)
-          write_inheritable_hash :reflections, association_id => reflection
-          reflection
-        end
-      end
-
-      alias_method_chain :has_many, :active_record
-
-      def reflect_on_association_with_active_record(association_id)
-        if read_inheritable_attribute(:proxy) && proxy.proxy_klass.reflections.include?(association_id)
-          proxy.proxy_klass.reflect_on_association(association_id)
-        else
-          reflect_on_association_without_active_record(association_id)
-        end
-      end
-
-      alias_method_chain :reflect_on_association, :active_record
-
-      def proxy
-        read_inheritable_attribute(:proxy) || write_inheritable_attribute(:proxy, Associations::ActiveRecordProxy.new(self))
-      end
-    end
-
-    def respond_to?(sym)
-      if self.class.read_inheritable_attribute(:proxy) && proxy.respond_to?(sym)
-        true
-      else
-        super
-      end
-    end
-
-    def method_missing(method, *args)
-      if self.class.read_inheritable_attribute(:proxy) && proxy.respond_to?(method)
-        proxy.send(method, *args)
-      else
-        super
-      end
-    end
-  end
-
-  module Associations
-    class ActiveRecordProxy
-      attr_reader :proxy_klass
-      def initialize(ninja_model)
-        @klass = ninja_model
-        @klass.class_eval do
-          def proxy
-            @proxy ||= begin
-              self.class.proxy.instance(self)
+  module ActiveRecordExtensions
+    module ReflectionExt
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def create_reflection(macro, name, options, ninja_model)
+          klass = options[:class_name] || name
+          klass = klass.to_s.camelize
+          klass = klass.singularize if macro.in?([:has_many])
+          klass = compute_type(klass)
+          if NinjaModel.ninja_model?(klass)
+            super
+          else
+            case macro
+            when :has_many, :belongs_to, :has_one
+              reflection = ActiveRecord::Reflection::AssociationReflection.new(macro, name, options, ninja_model)
+            when :composed_of
+              reflection = ActiveRecord::Reflection::AggregateReflection.new(macro, name, options, ninja_model)
+            else
+              raise NotImplementedError, "NinjaModel does not currently support #{macro} associations."
             end
-            @proxy.attributes = self.attributes.delete_if { |k,v| k.eql?('id') }
-            @proxy.id = self.id if self.attributes.key?(:id)
-            @proxy
+            self.reflections = self.reflections.merge(name => reflection)
           end
         end
 
-        @proxy_klass = ninja_model.parent.const_set("#{@klass.model_name.gsub(/[^a-zA-Z]/, '')}Proxy", Class.new(ActiveRecord::Base))
-        @proxy_klass.class_eval do
-          cattr_accessor :columns
-          self.columns = []
-          def self.column(name, sql_type = nil, default = nil)
-            self.columns << ActiveRecord::ConnectionAdapters::Column.new(name, nil, sql_type.to_s, default)
-          end
-
-          def self.columns_hash
-            h = {}
-            self.columns.each do |c|
-              h[c.name] = c
-            end
-            h
-          end
-          def self.column_defaults
-            self.columns_hash
+        def reflect_on_aggregation(aggregation)
+          if reflections[aggregation].is_a?(ActiveRecord::Reflection::AggregateReflection)
+            reflections[aggregation]
+          else
+            super
           end
         end
 
-        @klass.model_attributes.each do |attr|
-          @proxy_klass.send :column, attr.name, attr.type, attr.default
-        end
-      end
-
-      def instance(obj)
-        proxy = @proxy_klass.new
-        proxy.send :init_with, {'attributes' => obj.attributes}
-        proxy
-      end
-
-      def handle_association(macro, association_id, options)
-        unless macro.eql?(:belongs_to)
-          options = {:foreign_key => derive_foreign_key}.merge(options)
-        end
-
-        @proxy = nil
-        @proxy_klass.send macro, association_id, options
-      end
-
-      private
-
-      def derive_foreign_key
-        "#{@klass.name.demodulize.underscore}_id".to_sym
-      end
-    end
-
-    class NinjaModelProxy
-      attr_reader :proxy_klass
-      def initialize(active_record)
-        @klass = active_record
-        @klass.class_eval do
-          def ninja_proxy
-            @ninja_proxy ||= begin
-              self.class.ninja_proxy.instance(self)
-            end
-            @ninja_proxy.attributes = self.attributes
-            @ninja_proxy
+        def reflect_on_association(association)
+          if reflections[association].is_a?(ActiveRecord::Reflection::AssociationReflection)
+            reflections[association]
+          else
+            super
           end
         end
-
-        @proxy_klass = active_record.parent.const_set("#{@klass.model_name.demodulize}Proxy", Class.new(NinjaModel::Base))
-
-        @klass.columns_hash.each_pair do |k,v|
-          @proxy_klass.send :attribute, k, v.type, v.default, @proxy_klass
-        end
-      end
-
-      def instance(obj)
-        proxy = @proxy_klass.new
-        proxy.send :instantiate, {'attributes' => obj.attributes}
-        proxy
-      end
-
-      def handle_association(macro, association_id, options)
-        unless macro.eql?(:belongs_to)
-          options = {:foreign_key => derive_foreign_key}.merge(options)
-        end
-
-        @proxy = nil
-        @proxy_klass.send macro, association_id, options
-      end
-
-      private
-
-      def derive_foreign_key
-        "#{@klass.name.demodulize.underscore}_id".to_sym
       end
     end
   end
-  
+end
+
+ActiveSupport.on_load(:ninja_model) do
+  include NinjaModel::ActiveRecordExtensions::ReflectionExt
 end

data/lib/ninja_model/railtie.rb

@@ -12,12 +12,6 @@ module NinjaModel
       end
     end
 
-    initializer 'ninja_model_extend_active_record' do |app|
-      ActiveSupport.on_load(:active_record) do
-        require 'ninja_model/rails_ext/active_record'
-      end
-    end
-
     initializer 'ninja_model_load_specs' do |app|
       config_path = File.join(app.paths['config'].to_a.first, "ninja_model.yml")
       if File.exists?(config_path)
@@ -28,8 +22,5 @@ module NinjaModel
         NinjaModel.logger.warn "[ninja-model] *WARNING* Unable to find configuration file at #{config_path}"
       end
     end
-
-    config.after_initialize do |app|
-    end
   end
 end

data/lib/ninja_model/reflection.rb

@@ -1,12 +1,24 @@
 module NinjaModel
-  class Base
-    class << self
+  module Reflection
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :reflections
+      self.reflections = {}
+    end
+
+    module ClassMethods
       def create_reflection(macro, name, options, ninja_model)
         case macro
         when :has_many, :belongs_to, :has_one
           reflection = Reflection::AssociationReflection.new(macro, name, options, ninja_model)
+        when :composed_of
+          reflection = AggregateReflection.new(macro, name, options, ninja_model)
+        else
+          raise NotImplementedError, "NinjaModel does not currently support #{macro} associations."
         end
-        write_inheritable_hash :reflections, name => reflection
+        
+        self.reflections = self.reflections.merge(name => reflection)
         reflection
       end
 
@@ -14,13 +26,14 @@ module NinjaModel
         read_inheritable_attribute(:reflections) || write_inheritable_attribute(:reflections, {})
       end
 
+      def reflect_on_aggregation(aggregation)
+        reflections[aggregation].is_a?(AggregateReflection) ? reflections[aggregation] : nil
+      end
+
       def reflect_on_association(association)
         reflections[association].is_a?(Reflection::AssociationReflection) ? reflections[association] : nil
       end
     end
-  end
-
-  module Reflection
 
     class MacroReflection
       def initialize(macro, name, options, ninja_model)
@@ -28,9 +41,11 @@ module NinjaModel
       end
 
       attr_reader :ninja_model, :name, :macro, :options
+      alias :active_record :ninja_model
+      alias :source_macro :macro
 
       def klass
-        @klass ||= class_name.camelize.constantize
+        @klass ||= class_name.constantize
       end
 
       def class_name
@@ -44,33 +59,86 @@ module NinjaModel
       end
     end
 
+    class AggregateReflection < MacroReflection
+    end
+
     class AssociationReflection < MacroReflection
+      attr_accessor :original_build_association_called # :nodoc
+
+      def klass
+        @klass ||= ninja_model.send(:compute_type, class_name)
+      end
+
       def initialize(macro, name, options, ninja_model)
         super
-        @collection = [:has_many].include?(macro)
+        @collection = macro.in?([:has_many])
+      end
+
+      def build_association(*options, &block)
+        @original_build_association_called
+        klass.new(*options, &block)
       end
 
-      def build_association(*options)
-        klass.new(*options)
+      def table_name
+        raise NotImplementedError, "table_name is not implemented in NinjaModel"
       end
 
-      def create_association(*options)
-        klass.create(*options)
+      def quoted_table_name
+        raise NotImplementedError, "quoted_table_name is not implemented in NinjaModel"
       end
 
-      def create_association!(*options)
-        klass.create!(*options)
+      def foreign_key
+        @foreign_key ||= options[:foreign_key] || derive_foreign_key
       end
 
       def primary_key_name
-        @primary_key_name ||= options[:foreign_key] || derive_primary_key_name
-        @primary_key_name
+        foreign_key
+      end
+      deprecate :primary_key_name => :foreign_key
+
+      def foreign_type
+        @foreign_type ||= options[:foreign_type] || "#{name}_type"
+      end
+
+      def type
+        @type ||= options[:as] && "#{options[:as]}_type"
+      end
+
+      def primary_key_column
+        @primary_key_column ||= klass.columns.find { |c| c.name == klass.primary_key }
       end
 
       def association_foreign_key
         @association_foreign_key ||= @options[:association_foreign_key] || class_name.foreign_key
       end
 
+      def association_primary_key(klass = nil)
+        options[:primary_key] || primary_key(klass || self.klass)
+      end
+
+      def ninja_model_primary_key
+        @ninja_model_primary_key ||= options[:primary_key] || primary_key(ninja_model)
+      end
+      alias :active_record_primary_key :ninja_model_primary_key
+
+      def chain
+        [self]
+      end
+
+      def conditions
+        [[options[:conditions]].compact]
+      end
+
+      def has_inverse?
+        @options[:inverse_of]
+      end
+
+      def inverse_of
+        if has_inverse?
+          @inverse_of ||= klass.reflect_on_association(options[:inverse_of])
+        end
+      end
+
       def collection?
         @collection
       end
@@ -79,27 +147,42 @@ module NinjaModel
         !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || macro == :has_many)
       end
 
-      private
-
       def belongs_to?
         macro == :belongs_to
       end
 
+      def association_class
+        case macro
+        when :belongs_to
+          Associations::BelongsToAssociation
+        when :has_many
+          Associations::HasManyAssociation
+        when :has_one
+          Associations::HasOneAssociation
+        end
+      end
+
+      private
+
       def derive_class_name
         class_name = name.to_s.camelize
         class_name = class_name.singularize if collection?
         class_name
       end
 
-      def derive_primary_key_name
+      def derive_foreign_key
         if belongs_to?
           "#{name}_id"
         elsif options[:as]
           "#{options[:as]}_id"
         else
-          ninja_model.name.demodulize.foreign_key
+          ninja_model.name.foreign_key
         end
       end
+
+      def primary_key(klass)
+        klass.primary_key || raise(StandardError, "Unknown primary key for #{klass}")
+      end
     end
   end
 end