ninja-model 0.4.2 → 0.5.1

data/lib/ninja_model/identity.rb

@@ -1,16 +1,11 @@
-require 'active_support'
-
 module NinjaModel
-  module Identity
-    extend ActiveSupport::Concern
-    include ActiveModel::AttributeMethods
-
-    included do
-      class_inheritable_accessor :primary_key
-      self.primary_key = :id
-      undef_method(:id) if method_defined?(:id)
-    end
+  class Base
+    class_inheritable_accessor :primary_key
+    self.primary_key = :id
+    undef_method(:id) if method_defined?(:id)
+  end
 
+  module Identity
     def to_param
       send(self.class.primary_key).to_s if persisted?
     end

data/lib/ninja_model/persistence.rb

@@ -1,34 +1,15 @@
-require 'active_support'
-
 module NinjaModel
-  module Persistence
-    extend ActiveSupport::Concern
-    include ActiveModel::AttributeMethods
-
-    module ClassMethods
-      def get(rel)
-      end
-
-      def persist_with(adapter)
-
-      end
-    end
+  class Base
+    define_model_callbacks :save, :create, :update, :destroy
+  end
 
-    included do
-      class_inheritable_accessor :persistence_adapter
-    end
+  module Persistence
 
     def save(*)
       run_callbacks :save do
-        create_or_update
-      end
-    end
-
-    def create_or_update
-      if new_record?
-        create
-      else
-        update
+        result = new_record? ? create : update
+        changed_attributes.clear if result
+        result
       end
     end
 
@@ -42,7 +23,9 @@ module NinjaModel
     end
 
     def update
-      self.class.adapter.update(self)
+      run_callbacks :update do
+        self.class.adapter.update(self)
+      end
     end
 
     def new_record?
@@ -58,10 +41,12 @@ module NinjaModel
     end
 
     def destroy
-      if self.class.adapter.destroy(self)
-        @destroyed = true
+      run_callbacks :destroy do
+        if self.class.adapter.destroy(self)
+          @destroyed = true
+        end
+        @destroyed
       end
-      @destroyed
     end
 
     def reload

data/lib/ninja_model/predicate.rb

@@ -3,11 +3,11 @@ module NinjaModel
 
     PREDICATES = [:eq, :ne, :gt, :gte, :lt, :lte, :in]
 
-    attr_reader :attribute, :method, :value
+    attr_reader :attribute, :meth, :value
 
-    def initialize(attribute, method, *args)
+    def initialize(attribute, meth, *args)
       @attribute = attribute
-      @method = method
+      @meth = meth
       @valued = !args.blank?
       @value = args.blank? ? nil : args.first
     end
@@ -22,7 +22,7 @@ module NinjaModel
     end
 
     def test(suspect)
-      case method
+      case meth
       when :eq
         suspect.eql?(value)
       when :ne

data/lib/ninja_model/rails_ext/active_record.rb

@@ -0,0 +1,187 @@
+require 'active_record'
+
+module ActiveRecord
+  class Base
+    class << self
+      def has_one_with_ninja_model(association_id, options = {})
+        if NinjaModel.ninja_model?(options[:class_name] || association_id)
+          ninja_proxy.handle_association(:has_one, association_id, options)
+        else
+          has_one_without_ninja_model(association_id, options)
+        end
+      end
+      alias_method_chain :has_one, :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)
+        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
+        end
+      end
+    end
+  end
+end
+
+module NinjaModel
+
+  class Base
+    class << self
+      def has_one_with_active_record(association_id, options = {})
+        if ninja_model?(:has_one, options[:class_name] || association_id)
+          has_one_without_active_record(association_id, options)
+        else
+          proxy.handle_association(:has_one, association_id, options)
+        end
+      end
+
+      alias_method_chain :has_one, :active_record
+
+      def belongs_to_with_active_record(association_id, options = {})
+        if ninja_model?(:belongs_to, options[:class_name] || association_id)
+          belongs_to_without_active_record(association_id, options)
+        else
+          proxy.handle_association(:belongs_to, association_id, options)
+        end
+      end
+
+      alias_method_chain :belongs_to, :active_record
+
+      def has_many_with_active_record(association_id, options = {})
+        if ninja_model?(:has_many, association_id)
+          has_many_without_active_record(association_id, options)
+        else
+          proxy.handle_association(:has_many, association_id, options)
+        end
+      end
+
+      alias_method_chain :has_many, :active_record
+
+      def proxy
+        read_inheritable_attribute(:proxy) || write_inheritable_attribute(:proxy, Associations::ActiveRecordProxy.new(self))
+      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
+      def initialize(ninja_model)
+        @klass = ninja_model
+        @klass.class_eval do
+          def proxy
+            @proxy ||= begin
+              self.class.proxy.instance(self)
+            end
+            @proxy.attributes = self.attributes.delete_if { |k,v| k.eql?('id') }
+            @proxy
+          end
+        end
+
+        @proxy_klass = ninja_model.parent.const_set("#{@klass.model_name}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
+        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.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.delete_if { |k,v| k.eql?('id') }
+            @ninja_proxy
+          end
+        end
+
+        @proxy_klass = active_record.parent.const_set("#{@klass.model_name}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.underscore}_id".to_sym
+      end
+    end
+  end
+  
+end

data/lib/ninja_model/railtie.rb

@@ -1,27 +1,33 @@
-require 'ninja_model'
-require 'rails/all'
-
 module NinjaModel
   class Railtie < Rails::Railtie
 
-    config.ninja_model = NinjaModel::Configuration.create
+    config.ninja_model = ActiveSupport::OrderedOptions.new
 
-    #config.generators.orm :ninja_model, :migration => false
+    config.app_middleware.insert_after "::ActionDispatch::Callbacks",
+      "NinjaModel::Adapters::AdapterManagement"
 
     initializer 'ninja_model.logger' do |app|
       NinjaModel::set_logger(Rails.logger)
     end
 
-    config.after_initialize do |app|
-      config_path = File.join(Rails.root, app.config.ninja_model.config_file_path)
+    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)
         require 'erb'
         require 'yaml'
         app.config.ninja_model.specs = YAML::load(ERB.new(IO.read(config_path)).result)
-        NinjaModel::Base.set_adapter
       else
         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,13 +1,10 @@
 module NinjaModel
-  module Reflection
-    extend ActiveSupport::Concern
-
-    module ClassMethods
+  class Base
+    class << self
       def create_reflection(macro, name, options, ninja_model)
         case macro
         when :has_many, :belongs_to, :has_one
-          reflection = AssociationReflection.new(macro, name, options, ninja_model)
-        when :composed_of
+          reflection = Reflection::AssociationReflection.new(macro, name, options, ninja_model)
         end
         write_inheritable_hash :reflections, name => reflection
         reflection
@@ -25,9 +22,12 @@ module NinjaModel
       end
 
       def reflect_on_association(association)
-        reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
+        reflections[association].is_a?(Reflection::AssociationReflection) ? reflections[association] : nil
       end
     end
+  end
+
+  module Reflection
 
     class MacroReflection
       def initialize(macro, name, options, ninja_model)
@@ -77,13 +77,6 @@ module NinjaModel
         @association_foreign_key ||= @options[:association_foreign_key] || class_name.foreign_key
       end
 
-      def check_validity!
-        check_validity_of_inverse!
-      end
-
-      def check_validity_of_inverse!
-      end
-
       def collection?
         @collection
       end

data/lib/ninja_model/relation.rb

@@ -1,4 +1,6 @@
-require 'active_support/core_ext/object/blank'
+require 'ninja_model/relation/query_methods'
+require 'ninja_model/relation/finder_methods'
+require 'ninja_model/relation/spawn_methods'
 
 module NinjaModel
   class Relation
@@ -58,13 +60,13 @@ module NinjaModel
       size.zero?
     end
 
-    protected
-
     alias :inspect! :inspect
     def inspect
       to_a.inspect
     end
 
+    protected
+
     def method_missing(method, *args, &block)
       if Array.method_defined?(method)
         to_a.send(method, *args, &block)

data/lib/ninja_model/relation/finder_methods.rb

@@ -1,18 +1,14 @@
 module NinjaModel
+  class RecordNotFound < NinjaModelError; end
   module FinderMethods
     def first(*args)
       if args.any?
+        apply_finder_options(args.first).limit(1).to_a.first
       else
         find_first
       end
     end
 
-    def last(*args)
-      if args.any?
-      else
-      end
-    end
-
     def all(*args)
       args.any? ? apply_finder_options(args.first).to_a : to_a
     end
@@ -24,7 +20,7 @@ module NinjaModel
         apply_finder_options(options).find(*args)
       else
         case args.first
-        when :first, :last, :all
+        when :first, :all
           send(args.first)
         else
           find_with_ids(*args)
@@ -53,7 +49,7 @@ module NinjaModel
         result = find_one(ids.first)
         expects_array ? [result] : result
       else
-        find_some(ids)
+        raise NotImplementedError, "Finding by multiple id's is not implemented"
       end
     end