ninja-model 0.4.2 → 0.5.1

data/.gitignore

@@ -0,0 +1,19 @@
+*~
+*.cache
+*.log
+*.pid
+tmp/**/*
+doc/*
+.DS_Store
+db/*.sqlite3
+doc/api
+doc/app
+doc/plugins
+doc/*.dot
+coverage/*
+*.sw?
+vendor/plugins/ns_web
+Gemfile.lock
+.bundle
+*.gem
+.rspec

data/Rakefile

@@ -1,12 +1,9 @@
 require 'bundler'
-Bundler.setup
 Bundler::GemHelper.install_tasks
 
 require 'rake'
 require 'rake/rdoctask'
 require 'rspec/core/rake_task'
-require 'cucumber'
-require 'cucumber/rake/task'
 
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.verbose = false
@@ -32,7 +29,3 @@ namespace :spec do
     t.rcov_opts << %w{--exclude gems\/,spec\/}
   end
 end
-
-Cucumber::Rake::Task.new(:features) do |t|
-  t.cucumber_opts = "features --format progress"
-end

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { 'rspec2' }

data/lib/ninja_model.rb

@@ -1,29 +1,8 @@
-require 'active_support'
-require 'active_support/core_ext/hash/indifferent_access'
+require 'active_model'
+require 'active_support/core_ext'
 
 module NinjaModel
-  extend ActiveSupport::Autoload
-
-  autoload :Base
-  autoload :Adapters
-  autoload :Associations
-  autoload :Attributes
-  autoload :Callbacks
-  autoload :Configuration
-  autoload :Identity
-  autoload :Persistence
-  autoload :Predicate
-  autoload :Reflection
-  autoload :Relation
-  autoload :Scoping
-  autoload :Validation
-
-  autoload_under 'relation' do
-    autoload :QueryMethods
-    autoload :FinderMethods
-    autoload :SpawnMethods
-  end
-
+  class NinjaModelError < StandardError; end
 
   class << self
     attr_accessor :logger
@@ -31,8 +10,25 @@ module NinjaModel
     def set_logger(logger)
       ::NinjaModel.logger = logger
     end
+
+    def ninja_model?(symbol)
+      klass = symbol.to_s.camelize
+      klass = klass.singularize
+      klass = klass.constantize
+      klass.ancestors.include?(NinjaModel::Base)
+    end
+
+    def configuration
+      Rails.application.config.ninja_model
+    end
+  end
+
+  class Base
   end
 end
 
-require 'ninja_model/railtie'
-require 'ninja_model/errors'
+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,18 +1,14 @@
-require 'active_support'
+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
 
   module Adapters
-    extend ActiveSupport::Concern
-    extend ActiveSupport::Autoload
-
-    autoload :AdapterSpecification
-    autoload :AdapterManager
-    autoload :AdapterPool
-    autoload :AbstractAdapter
-
-    class << self
-    end
+    class AdapterNotSpecified < StandardError; end
+    class InvalidAdapter < StandardError; end
+    class InvalidSpecification < StandardError; end
   end
 
   class Base
@@ -20,47 +16,41 @@ module NinjaModel
     self.adapter_manager = NinjaModel::Adapters::AdapterManager.new
 
     def adapter
-      self.class.adapter
+      self.class.retrieve_adapter
     end
 
-    def self.set_adapter(spec = nil)
-      case spec
-      when nil
-        raise AdapterNotSpecified unless defined?(Rails.env)
-        set_adapter(Rails.env)
-      when AdapterSpecification
-        self.adapter_manager.create_adapter(name, spec)
-      when Symbol, String
-        if config = NinjaModel.configuration.specs[spec.to_s]
-          set_adapter(config)
-        else
-          raise AdapterNotSpecified, "#{spec} is not configured"
-        end
-      else
-        spec = spec.symbolize_keys
-        unless spec.key?(:adapter) then raise AdapterNotSpecified, "configuration does not specify adapter" end
-        begin
-          require File.join(NinjaModel.configuration.adapter_path, "#{spec[:adapter]}_adapter")
-        rescue LoadError => e
-          raise "Please install (or create) the #{spec[:adapter]} adapter.  Search path is #{NinjaModel.configuration.adapter_path}"
-        end
-        adapter_method = "#{spec[:adapter]}_adapter"
-        if !respond_to?(adapter_method)
-          raise AdapterNotFound, "ninja configuration specifies nonexistent #{spec[:adapter]} adapter"
-        end
-        shutdown_adapter
-        set_adapter(AdapterSpecification.new(spec, adapter_method))
+    class << self
+      def register_adapter(name, klass)
+        Adapters::AdapterManager.register_adapter_class(name, klass)
       end
-    end
 
-    class << self
-      def adapter
-        retrieve_adapter
+      def set_adapter(spec = nil)
+        case spec
+        when nil
+          raise Adapters::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"
+          end
+        else
+          spec = spec.symbolize_keys
+          raise Adapters::AdapterNotSpecified, "configuration does not specify adapter" unless spec.key?(:adapter)
+          adapter_name = spec[:adapter]
+          raise Adapters::InvalidAdapter, "configuration does not specify adapter" unless Adapters::AdapterManager.registered?(adapter_name)
+          shutdown_adapter
+          set_adapter(Adapters::AdapterSpecification.new(spec, adapter_name))
+        end
       end
 
       def retrieve_adapter
         adapter_manager.retrieve_adapter(self)
       end
+      alias :adapter :retrieve_adapter
 
       def shutdown_adapter(klass = self)
         adapter_manager.remove_adapter(klass)

data/lib/ninja_model/adapters/abstract_adapter.rb

@@ -1,14 +1,10 @@
 module NinjaModel
   module Adapters
     class AbstractAdapter
-      class << self
-        def instance
-          @instance ||= new
-        end
-      end
+      attr_reader :config
 
       def initialize(config, logger = nil)
-        @active = nil
+        @active = false
         @config, @logger = config, logger
       end
 
@@ -54,10 +50,6 @@ module NinjaModel
       def destroy(model)
         false
       end
-
-      def raw_connection
-        @connection
-      end
     end
   end
 end

data/lib/ninja_model/adapters/adapter_manager.rb

@@ -1,10 +1,23 @@
 module NinjaModel
   module Adapters
     class AdapterManager
+      class_attribute :registered
+      self.registered = {}
+      class << self
+        def registered?(name)
+          registered.key?(name.to_sym)
+        end
+
+        def register_adapter_class(name, klass)
+          registered[name.to_sym] = klass
+        end
+      end
+
       attr_reader :adapter_pools
 
       def initialize(pools = {})
         @adapter_pools = pools
+        @registered = {}
       end
 
       def create_adapter(name, spec)
@@ -13,13 +26,7 @@ module NinjaModel
 
       def release_active_adapters!
         @adapter_pools.each_value do |pool|
-          pool.release_adapter
-        end
-      end
-
-      def release_reloadable_adapters!
-        @adapter_pools.each_value do |pool|
-          pool.shutdown_reloadable_adapters!
+          pool.release_instance
         end
       end
 
@@ -31,7 +38,7 @@ module NinjaModel
 
       def retrieve_adapter(klass)
         pool = retrieve_adapter_pool(klass)
-        (pool && pool.instance) or raise StandardError
+        (pool && pool.instance) or raise StandardError, "Pool is empty or instance is null"
       end
 
       def remove_adapter(klass)
@@ -58,8 +65,8 @@ module NinjaModel
       def call(env)
         @app.call(env)
       ensure
-        unless env.key?('rake.test')
-          NinjaModel::Base.clear_active_instances!
+        unless env.key?('rack.test')
+          NinjaModel::Base.adapter_manager.release_active_adapters!
         end
       end
     end

data/lib/ninja_model/adapters/adapter_pool.rb

@@ -1,4 +1,5 @@
 module NinjaModel
+  class ConnectionTimeoutError < NinjaModelError; end
   module Adapters
     class AdapterPool
       attr_reader :spec, :instances
@@ -13,6 +14,10 @@ module NinjaModel
         @timeout = 3
       end
 
+      def connected?
+        !@instances.empty?
+      end
+
       def instance
         NinjaModel.logger.debug("instance called for #{current_instance_id}")
         @assigned_instances[current_instance_id] ||= checkout
@@ -31,8 +36,15 @@ module NinjaModel
         release_instance(instance_id) if fresh_instance
       end
 
-      def connected?
-        !@instances.empty?
+      def shutdown!
+        @assigned_instances.each do |name,conn|
+          checkin conn
+        end
+        @assigned_instances = {}
+        @instances.each do |inst|
+          inst.disconnect!
+        end
+        @instances = []
       end
 
       private
@@ -86,7 +98,7 @@ module NinjaModel
       end
 
       def new_instance
-        NinjaModel::Base.send(spec.adapter_method, spec.config)
+        AdapterManager.registered[spec.name.to_sym].new(spec.config)
       end
 
       def current_instance_id
@@ -110,19 +122,5 @@ module NinjaModel
         inst
       end
     end
-
-    class AdapterManagement
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        @app.call(env)
-      ensure
-        unless env.key?('rask.test')
-          NinjaModel::Base.clear_active_instances!
-        end
-      end
-    end
   end
 end

data/lib/ninja_model/adapters/adapter_specification.rb

@@ -1,10 +1,10 @@
 module NinjaModel
   module Adapters
     class AdapterSpecification
-      attr_accessor :config, :adapter_method
+      attr_reader :config, :name
 
-      def initialize(config, adapter_method)
-        @config, @adapter_method = config, adapter_method
+      def initialize(config, name)
+        @config, @name = config, name
       end
     end
   end

data/lib/ninja_model/associations.rb

@@ -1,107 +1,27 @@
-require 'active_support/concern'
-require 'ninja_model/associations/active_record_proxy'
-require 'ninja_model/associations/ninja_model_proxy'
-
-module ActiveRecord
-  module Associations
-    module ClassMethods
-      alias :has_one_without_ninja_model :has_one
-      def has_one(association_id, options = {})
-        if ninja_model?(:has_one, 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
-
-      def ninja_proxy
-        read_inheritable_attribute(:ninja_proxy) || write_inheritable_attribute(:ninja_proxy, NinjaModel::Associations::NinjaModelProxy.new(self))
-      end
-
-      private
-
-      def ninja_model?(macro, association)
-        klass = association.to_s.camelize
-        klass = klass.singularize unless [:has_one, :belongs_to].include?(macro)
-        klass = klass.constantize
-        klass.ancestors.include?(NinjaModel::Base)
-      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
-
-  module Reflection
-    module ClassMethods
-      alias :reflect_on_association_without_ninja_model :reflect_on_association
-      def reflect_on_association(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
-    end
-  end
-end
-
 module NinjaModel
-  module Associations
-    extend ActiveSupport::Concern
-
-    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'
 
-
-    module ClassMethods
+  class Base
+    class << self
       def has_one(association_id, options = {})
-        if ninja_model?(:has_one, options[:class_name] || association_id)
-          reflection = create_has_one_reflection(association_id, options)
-          association_accessor_methods(reflection, HasOneAssociation)
-          #association_constructor_method(:build, reflection, HasOneAssociation)
-          #association_constructor_method(:create, reflection, HasOneAssociation)
-          #configure_dependency_for_has_one(reflection)
-        else
-          #puts "Setting up has_one proxy for #{association_id}"
-          proxy.handle_association(:has_one, association_id, options)
-        end
+        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 = {})
-        if ninja_model?(:belongs_to, options[:class_name] || association_id)
-          reflection = create_belongs_to_reflection(association_id, options)
-          association_accessor_methods(reflection, BelongsToAssociation)
-          #association_constructor_method(:build, reflection, BelongsToAssociation)
-          #association_constructor_method(:create, reflection, BelongsToAssociation)
-        else
-          proxy.handle_association(:belongs_to, association_id, options)
-        end
+        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 = {})
-        if ninja_model?(:has_many, association_id)
-          reflection = create_has_many_reflection(association_id, options)
-          collection_accessor_methods(reflection, HasManyAssociation)
-          #collection_accessor_methods(reflection, HasManyAssociation)
-        else
-          proxy.handle_association(:has_many, association_id, options)
-        end
-      end
-
-      def proxy
-        read_inheritable_attribute(:proxy) || write_inheritable_attribute(:proxy, ActiveRecordProxy.new(self))
+        reflection = create_has_many_reflection(association_id, options)
+        collection_accessor_methods(reflection, Associations::HasManyAssociation)
       end
 
       private
@@ -112,7 +32,6 @@ module NinjaModel
 
       def create_has_many_reflection(association, options = {})
         create_reflection(:has_many, association, options, self)
-        #options[:extend] = create_extension_modules(association, extension
       end
 
       def create_belongs_to_reflection(association, options = {})
@@ -126,7 +45,7 @@ module NinjaModel
           if association.nil?
             association = association_proxy_class.new(self, reflection)
             retval = association.reload
-            if retval.nil? and association_proxy_class == BelongsToAssociation
+            if retval.nil? and association_proxy_class == Associations::BelongsToAssociation
               association_instance_set(reflection.name, nil)
               return nil
             end
@@ -151,7 +70,7 @@ module NinjaModel
         end
 
         redefine_method("set_#{reflection.name}_target") do |target|
-          return if target.nil? and association_proxy_class == BelongsToAssociation
+          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)
@@ -174,6 +93,14 @@ module NinjaModel
         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'
 
     def association_instance_get(name)
       ivar = "@#{name}"
@@ -186,13 +113,5 @@ module NinjaModel
     def association_instance_set(name, association)
       instance_variable_set("@#{name}", association)
     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
 end