ninja-model 0.8.1 → 0.9.0

data/.gitignore

@@ -5,7 +5,7 @@
 tmp/**/*
 doc/*
 .DS_Store
-db/*.sqlite3
+*.sqlite3
 doc/api
 doc/app
 doc/plugins

data/Gemfile

@@ -4,4 +4,5 @@ gemspec
 group :test, :development do
   gem 'yard'
   gem 'simplecov', :require => false
+  gem 'factory_girl'
 end

data/Rakefile

@@ -8,6 +8,12 @@ end
 require 'rspec/core/rake_task'
 require 'yard'
 
+#task :prepare_db do
+#  db_root = File.join(File.expand_path('../', __FILE__), 'spec', 'db')
+#  db_file = File.join(db_root, 'test.sqlite3')
+#  sh "rm #{db_file}" if File.exists?(db_file)
+#  sh %Q{sqlite3 "#{db_file}" "create table a (a integer); drop table a;"}
+#end
 
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.verbose = false

data/lib/ninja_model.rb

@@ -1,7 +1,10 @@
 require 'active_model'
+require 'active_record'
 require 'active_support/core_ext'
 
 module NinjaModel
+  extend ActiveSupport::Autoload
+
   class NinjaModelError < StandardError; end
 
   class << self
@@ -12,10 +15,10 @@ module NinjaModel
     end
 
     def ninja_model?(symbol)
-      klass = symbol.to_s.camelize
-      klass = klass.singularize
-      klass = klass.constantize
-      klass.ancestors.include?(NinjaModel::Base)
+      #klass = symbol.to_s.camelize
+      #klass = klass.singularize
+      #klass = symbol.constantize
+      symbol.ancestors.include?(NinjaModel::Base)
     end
 
     def configuration
@@ -23,12 +26,25 @@ module NinjaModel
     end
   end
 
-  class Base
+  autoload :Attribute
+  autoload :AttributeMethods
+  autoload :Associations
+  autoload :Adapters
+  autoload :Base
+  autoload :Callbacks
+  autoload :Identity
+  autoload :Persistence
+  autoload :Predicate
+  autoload :Reflection
+  autoload :Relation
+  autoload :Validation
+
+  ActiveSupport.on_load(:active_record) do
+    require 'ninja_model/rails_ext/active_record'
+    include ActiveRecord::NinjaModelExtensions::ReflectionExt
   end
 end
 
-require 'ninja_model/base'
-require 'ninja_model/core_ext/symbol'
 if defined?(Rails)
   require 'ninja_model/railtie'
 end

data/lib/ninja_model/adapters.rb

@@ -1,47 +1,52 @@
-require 'ninja_model/adapters/abstract_adapter'
-require 'ninja_model/adapters/adapter_manager'
-require 'ninja_model/adapters/adapter_pool'
-require 'ninja_model/adapters/adapter_specification'
-
 module NinjaModel
+  class AdapterNotSpecified < StandardError; end
+  class InvalidAdapter < StandardError; end
+  class InvalidSpecification < StandardError; end
 
   module Adapters
-    class AdapterNotSpecified < StandardError; end
-    class InvalidAdapter < StandardError; end
-    class InvalidSpecification < StandardError; end
-  end
+    extend ActiveSupport::Concern
 
-  class Base
-    class_attribute :adapter_manager
-    self.adapter_manager = NinjaModel::Adapters::AdapterManager.new
+    autoload :AbstractAdapter, 'ninja_model/adapters/abstract_adapter'
+    autoload :AdapterManager, 'ninja_model/adapters/adapter_manager'
+    autoload :AdapterPool, 'ninja_model/adapters/adapter_pool'
+    autoload :AdapterSpecification, 'ninja_model/adapters/adapter_specification'
+
+    included do
+      class_attribute :adapter_manager
+      self.adapter_manager = NinjaModel::Adapters::AdapterManager.new
+    end
 
     def adapter
       self.class.retrieve_adapter
     end
 
-    class << self
+    module ClassMethods
       def register_adapter(name, klass)
-        Adapters::AdapterManager.register_adapter_class(name, klass)
+        if klass.ancestors.include?(NinjaModel::Adapters::AbstractAdapter)
+          Adapters::AdapterManager.register_adapter_class(name, klass)
+        else
+          raise InvalidAdapter, "Invalid adapter: #{klass}"
+        end
       end
 
       def set_adapter(spec = nil)
         case spec
         when nil
-          raise Adapters::AdapterNotSpecified unless defined?(Rails.env)
+          raise AdapterNotSpecified unless defined?(Rails.env)
           set_adapter(Rails.env)
-        when Adapters::AdapterSpecification
-          self.adapter_manager.create_adapter(name, spec)
         when Symbol, String
           if config = NinjaModel.configuration.specs[spec.to_s]
             set_adapter(config)
           else
-            raise Adapters::InvalidSpecification, "#{spec} is not configured"
+            raise InvalidSpecification, "#{spec} is not configured"
           end
+        when Adapters::AdapterSpecification
+          self.adapter_manager.create_adapter(name, spec)
         else
           spec = spec.symbolize_keys
-          raise Adapters::AdapterNotSpecified, "configuration does not specify adapter" unless spec.key?(:adapter)
+          raise AdapterNotSpecified, "configuration does not specify adapter: #{spec}" unless spec.key?(:adapter)
           adapter_name = spec[:adapter]
-          raise Adapters::InvalidAdapter, "configuration does not specify adapter" unless Adapters::AdapterManager.registered?(adapter_name)
+          raise InvalidAdapter, "configuration does not specify adapter" unless Adapters::AdapterManager.registered?(adapter_name)
           shutdown_adapter
           set_adapter(Adapters::AdapterSpecification.new(spec, adapter_name))
         end

data/lib/ninja_model/adapters/adapter_manager.rb

@@ -1,8 +1,10 @@
 module NinjaModel
   module Adapters
     class AdapterManager
+
       class_attribute :registered
       self.registered = {}
+
       class << self
         def registered?(name)
           registered.key?(name.to_sym)

data/lib/ninja_model/adapters/adapter_pool.rb

@@ -1,5 +1,7 @@
 module NinjaModel
+
   class ConnectionTimeoutError < NinjaModelError; end
+
   module Adapters
     class AdapterPool
       attr_reader :spec, :instances

data/lib/ninja_model/associations.rb

@@ -1,125 +1,87 @@
 module NinjaModel
+  module Associations
+    extend ActiveSupport::Concern
 
-  class Base
-    class << self
-      def has_one(association_id, options = {})
-        reflection = create_has_one_reflection(association_id, options)
-        association_accessor_methods(reflection, Associations::HasOneAssociation)
-        # TODO: Implement the build/create association methods
-        #association_constructor_method(:build, reflection, HasOneAssociation)
-        #association_constructor_method(:create, reflection, HasOneAssociation)
-        #configure_dependency_for_has_one(reflection)
-      end
-
-      def belongs_to(association_id, options = {})
-        reflection = create_belongs_to_reflection(association_id, options)
-        association_accessor_methods(reflection, Associations::BelongsToAssociation)
-        # TODO: Implement the build/create association methods
-        #association_constructor_method(:build, reflection, BelongsToAssociation)
-        #association_constructor_method(:create, reflection, BelongsToAssociation)
-      end
-
-      def has_many(association_id, options = {})
-        reflection = create_has_many_reflection(association_id, options)
-        collection_accessor_methods(reflection, Associations::HasManyAssociation)
-      end
-
-      private
+    autoload :Association, 'ninja_model/associations/association'
+    autoload :AssociationProxy, 'ninja_model/associations/association_proxy'
+    autoload :AssociationScope, 'ninja_model/associations/association_scope'
+    autoload :BelongsToAssociation, 'ninja_model/associations/belongs_to_association'
+    autoload :CollectionAssociation, 'ninja_model/associations/collection_association'
+    autoload :CollectionProxy, 'ninja_model/associations/collection_proxy'
+    autoload :HasOneAssociation, 'ninja_model/associations/has_one_association'
+    autoload :HasManyAssociation, 'ninja_model/associations/has_many_association'
+    autoload :SingularAssociation, 'ninja_model/associations/singular_association'
+
+    module Builder
+      autoload :Association, 'ninja_model/associations/builder/association'
+      autoload :SingularAssociation, 'ninja_model/associations/builder/singular_association'
+      autoload :CollectionAssociation, 'ninja_model/associations/builder/collection_association'
+      autoload :HasMany, 'ninja_model/associations/builder/has_many'
+      autoload :BelongsTo, 'ninja_model/associations/builder/belongs_to'
+      autoload :HasOne, 'ninja_model/associations/builder/has_one'
+    end
 
-      def create_has_one_reflection(association, options = {})
-        create_reflection(:has_one, association, options, self)
-      end
+    attr_reader :association_cache
 
-      def create_has_many_reflection(association, options = {})
-        create_reflection(:has_many, association, options, self)
-      end
+    def association(name)
+      association = association_instance_get(name)
 
-      def create_belongs_to_reflection(association, options = {})
-        create_reflection(:belongs_to, association, options, self)
+      if association.nil?
+        reflection = self.class.reflect_on_association(name)
+        association = reflection.association_class.new(self, reflection)
+        association_instance_set(name, association)
       end
+      association
+    end
 
-      def association_accessor_methods(reflection, association_proxy_class)
-        redefine_method(reflection.name) do |*params|
-          association = association_instance_get(reflection.name)
-
-          if association.nil?
-            association = association_proxy_class.new(self, reflection)
-            retval = association.reload
-            if retval.nil? and association_proxy_class == Associations::BelongsToAssociation
-              association_instance_set(reflection.name, nil)
-              return nil
-            end
-            association_instance_set(reflection.name, association)
-          end
-          association.target.nil? ? nil : association
-        end
+    private
 
-        redefine_method("loaded_#{reflection.name}?") do
-          association = association_instance_get(reflection.name)
-          association && association.loaded?
-        end
-
-        redefine_method("#{reflection.name}=") do |new_value|
-          association = association_instance_get(reflection.name)
-          if association.nil? || association.target != new_value
-            association = association_proxy_class.new(self, reflection)
-          end
+    def association_instance_get(name)
+      @association_cache[name.to_sym]
+    end
 
-          association.replace(new_value)
-          association_instance_set(reflection.name, new_value.nil? ? nil : association)
-        end
+    def association_instance_set(name, association)
+      @association_cache[name.to_sym] = association
+    end
 
-        redefine_method("set_#{reflection.name}_target") do |target|
-          return if target.nil? and association_proxy_class == Associations::BelongsToAssociation
-          association = association_proxy_class.new(self, reflection)
-          association.target = target
-          association_instance_set(reflection.name, association)
+    module ClassMethods
+      def add_autosave_association_callbacks(reflection)
+      end
+      def has_one(name, options = {})
+        klass = compute_klass(name, :has_one, options)
+        if NinjaModel.ninja_model?(klass)
+          Builder::HasOne.build(self, name, options)
+        else
+          ActiveRecord::Associations::Builder::HasOne.build(self, name, options)
         end
       end
 
-      def collection_accessor_methods(reflection, association_proxy_class, writer = true)
-        collection_reader_method(reflection, association_proxy_class)
-
-        if writer
-          redefine_method("#{reflection.name}=") do |new_value|
-            association = send(reflection.name)
-            association.replace(new_value)
-            association
-          end
+      def belongs_to(name, options = {}, &extension)
+        klass = compute_klass(name, :belongs_to, options)
+        if NinjaModel.ninja_model?(klass)
+          Builder::BelongsTo.build(self, name, options)
+        else
+          ActiveRecord::Associations::Builder::BelongsTo.build(self, name, options)
         end
       end
 
-      def collection_reader_method(reflection, association_proxy_class)
-        redefine_method(reflection.name) do |*params|
-          association = association_instance_get(reflection.name)
-
-          if association.nil?
-            association = association_proxy_class.new(self, reflection)
-          end
-          association_instance_set(reflection.name, association)
-          association
+      def has_many(name, options = {}, &extension)
+        klass = compute_klass(name, :has_many, options)
+        if NinjaModel.ninja_model?(klass)
+          Builder::HasMany.build(self, name, options)
+        else
+          ActiveRecord::Associations::Builder::HasMany.build(self, name, options)
         end
       end
-    end
-  end
-
-  module Associations
 
-    autoload :AssociationProxy, 'ninja_model/associations/association_proxy'
-    autoload :HasOneAssociation, 'ninja_model/associations/has_one_association'
-    autoload :HasManyAssociation, 'ninja_model/associations/has_many_association'
-    autoload :BelongsToAssociation, 'ninja_model/associations/belongs_to_association'
+      private
 
-    def association_instance_get(name)
-      ivar = "@#{name}"
-      if instance_variable_defined?(ivar)
-        association = instance_variable_get(ivar)
-        association if association.respond_to?(:loaded?)
+      def compute_klass(name, macro, options)
+        klass = options[:class_name] || name
+        klass = klass.to_s.camelize
+        klass = klass.singularize if macro.eql?(:has_many)
+        klass = compute_type(klass)
       end
     end
-
-    def association_instance_set(name, association)
-      instance_variable_set("@#{name}", association)
-    end
   end
 end

data/lib/ninja_model/associations/association.rb

@@ -0,0 +1,146 @@
+module NinjaModel
+  module Associations
+    class Association
+
+      attr_reader :owner, :target, :reflection
+
+      delegate :options, :to => :reflection
+
+      def initialize(owner, reflection)
+        @target = nil
+        @owner, @reflection = owner, reflection
+
+        reset
+      end
+
+      def reset
+        @loaded = false
+        @target = nil
+      end
+
+      def reload
+        reset
+        reset_scope
+        load_target
+        self unless target.nil?
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def loaded!
+        @loaded = true
+      end
+
+      def stale_target?
+        false
+      end
+
+      def target=(target)
+        @target = target
+        loaded!
+      end
+
+      def scoped
+        target_scope.merge(association_scope)
+      end
+
+      def target_scope
+        klass.scoped
+      end
+
+      def association_scope
+        if klass
+          @association_scope ||= AssociationScope.new(self).scope
+        end
+      end
+
+      def reset_scope
+        @association_scope = nil
+      end
+
+      def set_inverse_instance(record)
+        if record && invertible_for?(record)
+          inverse = record.association(inverse_reflection_for(record).name)
+          inverse.target = owner
+        end
+      end
+
+      def klass
+        reflection.klass
+      end
+
+      def target_scope
+        klass.scoped
+      end
+
+      def load_target
+        if find_target?
+          @target ||= find_target
+        end
+        loaded! unless loaded?
+        target
+      rescue NinjaModel::RecordNotFound
+        reset
+      end
+
+      private
+
+      def find_target?
+        !loaded? && (!owner.new_record? || foreign_key_present?) && klass
+      end
+
+      def build_record(attributes, options)
+        record = reflection.build_association(attributes, options) do |r|
+          attrs = create_scope.except(*r.changed)
+          r.assign_attributes(
+            create_scope.except(*r.changed)
+          )
+        end
+      end
+
+      def creation_attributes
+        attributes = {}
+        if options[:through]
+          raise NotImplementedError, "NinjaModel does not support through associations yet."
+        else
+          if reflection.macro.in?([:has_one, :has_many])
+            attributes[reflection.foreign_key] = owner[reflection.ninja_model_primary_key]
+            if reflection.options[:as]
+              attributes[reflection.type] = owner.class.base_class.name
+            end
+          end
+          attributes
+        end
+      end
+
+      def set_owner_attributes(record)
+        creation_attributes.each { |key, value| record[key] = value }
+      end
+
+      def foreign_key_present?
+        false
+      end
+
+      def raise_on_type_mismatch(record)
+        unless record.is_a?(reflection.klass) || record.is_a?(reflection.class_name.constantize)
+          message = "#{reflection.class_name}(##{reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
+          raise ActiveRecord::AssociationTypeMismatch, message
+        end
+      end
+
+      def inverse_reflection_for(record)
+        reflection.inverse_of
+      end
+
+      def invertible_for?(record)
+        inverse_reflection_for(record)
+      end
+
+      def association_class
+        @reflection.klass
+      end
+    end
+  end
+end