ninja-model 0.8.1 → 0.9.0

data/lib/ninja_model/relation.rb

@@ -10,13 +10,13 @@ module NinjaModel
 
     attr_reader :klass, :loaded
 
-    attr_accessor :ordering, :predicates, :limit_value, :offset_value
+    attr_accessor :ordering, :predicates, :limit_value, :offset_value, :readonly_value
     attr_accessor :default_scoped
     alias :default_scoped? :default_scoped
 
     alias :loaded? :loaded
 
-    SINGLE_VALUE_ATTRS = [:limit, :offset]
+    SINGLE_VALUE_ATTRS = [:limit, :offset, :readonly]
     MULTI_VALUE_ATTRS = [:ordering, :predicates]
 
     def initialize(klass)

data/lib/ninja_model/relation/query_methods.rb

@@ -22,6 +22,22 @@ module NinjaModel
       relation
     end
 
+    def readonly(value)
+      relation = clone
+      relation.readonly_value = value
+      relation
+    end
+
+    def extending(*modules)
+      modules << Module.new(&Proc.new) if block_given?
+
+      return self if modules.empty?
+
+      relation = clone
+      relation.send(:apply_modules, modules.flatten)
+      relation
+    end
+
     private
 
     def build_predicates(opts, other = [])

data/lib/ninja_model/version.rb

@@ -1,3 +1,3 @@
 module NinjaModel
- VERSION = "0.8.1"
+ VERSION = "0.9.0"
 end

data/ninja-model.gemspec

@@ -23,9 +23,10 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'rspec',     	'~> 2.8.0'
   s.add_development_dependency 'mocha',     	'~> 0.10.0'
-  s.add_development_dependency 'nokogiri', 		'~> 1.5.0'
   s.add_development_dependency 'guard-rspec',	'~> 0.5.10'
   s.add_development_dependency 'libnotify',		'~> 0.6.0'
   s.add_development_dependency 'yard',          '~> 0.7.4'
   s.add_development_dependency 'redcarpet',     '~> 2.0.0'
+  s.add_development_dependency 'sqlite3',       '~> 1.3.5'
+  s.add_development_dependency 'factory_girl',  '~> 2.5.0'
 end

data/spec/db/schema.rb

@@ -0,0 +1,15 @@
+ActiveRecord::Schema.define do
+  create_table :users, :force => true do |t|
+    t.string :username
+  end
+
+  create_table :tags, :force => true do |t|
+    t.integer :post_id
+    t.string :name
+  end
+
+  create_table :email_addresses, :force => true do |t|
+    t.integer :bio_id
+    t.string :email
+  end
+end

data/spec/lib/ninja_model/adapters/adapter_manager_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe NinjaModel::Adapters::AdapterManager do
+  #class DummyAdapter < NinjaModel::Adapters::AbstractAdapter; end
+  #class TestModel < NinjaModel::Base; end
+  #class ChildModel < TestModel; end
+
+  let(:manager) { NinjaModel::Adapters::AdapterManager.new }
+  subject { manager }
+  #before {
+  #  @manager = NinjaModel::Adapters::AdapterManager.new
+  #  @manager.class.register_adapter_class(:dummy, DummyAdapter)
+  #}
+  #subject { @manager }
+
+  it 'should remember registered adapters' do
+    subject.class.stubs(:registered).returns({:dummy => nil})
+    subject.class.registered?(:dummy).should be_true
+  end
+
+  #describe 'creating an adapter' do
+  #  before { @manager.create_adapter('TestModel', NinjaModel::Adapters::AdapterSpecification.new({}, :dummy)) }
+  #  it 'should add the adapter to the pool' do
+  #    @manager.retrieve_adapter_pool(TestModel).spec.name.should eql(:dummy)
+  #  end
+  #  it 'should return the adapter for descendent classes' do
+  #    @manager.retrieve_adapter_pool(ChildModel).spec.name.should eql(:dummy)
+  #  end
+  #end
+
+  #describe 'removing an adapter' do
+  #  before {
+  #    @spec = NinjaModel::Adapters::AdapterSpecification.new({:foo => 'bar'}, :dummy)
+  #    @manager.create_adapter('TestModel', @spec)
+  #  }
+  #  it 'should remove the adapter from the pool' do
+  #    @manager.remove_adapter(TestModel)
+  #    @manager.retrieve_adapter_pool(TestModel).should be_nil
+  #  end
+  #  it 'should cause retrieve_adapter to raise an error' do
+  #    @manager.remove_adapter(TestModel)
+  #    lambda { @manager.retrieve_adapter(TestModel) }.should raise_error(StandardError)
+  #  end
+  #  it 'should return the spec that created it' do
+  #    @manager.remove_adapter(TestModel).should eql({:foo => 'bar'})
+  #  end
+  #end
+
+  #describe 'release_active_adapters!' do
+  #  before {
+  #    @spec = NinjaModel::Adapters::AdapterSpecification.new({:foo => 'bar'}, :dummy)
+  #    @manager.create_adapter('TestModel', @spec)
+  #  }
+  #  it 'should call release_instance on all pools' do
+  #    @pool = @manager.adapter_pools['TestModel']
+  #    @pool.expects(:release_instance)
+  #    @manager.release_active_adapters!
+  #  end
+  #end
+
+  #describe 'release_all_adapters!' do
+  #  before {
+  #    @spec = NinjaModel::Adapters::AdapterSpecification.new({:foo => 'bar'}, :dummy)
+  #    @manager.create_adapter('TestModel', @spec)
+  #  }
+  #  it 'should call shutdown! on all pools' do
+  #    @pool = @manager.adapter_pools['TestModel']
+  #    @pool.expects(:shutdown!)
+  #    @manager.release_all_adapters!
+  #  end
+  #end
+end

data/spec/lib/ninja_model/adapters/adapter_pool_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+
+describe NinjaModel::Adapters::AdapterPool do
+  #class DummyAdapter < NinjaModel::Adapters::AbstractAdapter; end
+  #before {
+  #  @spec = NinjaModel::Adapters::AdapterSpecification.new({}, :dummy)
+  #  NinjaModel::Base.register_adapter(:dummy, DummyAdapter)
+  #  @pool = NinjaModel::Adapters::AdapterPool.new(@spec)
+  #}
+  #subject { @pool }
+  #its(:spec) { should eql(@spec) }
+  #its(:instances) { should be_empty }
+  #its(:connected?) { should be_false }
+  #its(:current_instance_id) { should eql(Thread.current.object_id) }
+
+  #describe 'obtaining an adapter instance' do
+  #  it 'should store the instance for a given thread' do
+  #    subject.instance
+  #    subject.expects(:checkout).never
+  #    subject.instance
+  #  end
+  #end
+
+  #describe 'releasing an adapter instance' do
+  #  it 'should call checkout when obtaining another instance' do
+  #    subject.expects(:checkout).twice
+  #    subject.instance
+  #    subject.release_instance
+  #    subject.instance
+  #  end
+  #end
+
+  #describe 'with_instance' do
+  #  it 'should yield an instance' do
+  #    @inst = nil
+  #    subject.with_instance do |inst|
+  #      @inst = inst
+  #    end
+  #    @inst.should be_kind_of(DummyAdapter)
+  #  end
+  #  it 'should release the instance when complete' do
+  #    subject.expects(:release_instance).with(subject.send :current_instance_id)
+  #    subject.with_instance do |inst|
+  #    end
+  #  end
+  #end
+
+  #describe 'shutdown!' do
+  #  it 'should checkin all assigned instances' do
+  #    @inst = subject.instance
+  #    subject.expects(:checkin).with(@inst)
+  #    subject.shutdown!
+  #  end
+  #  it 'should call disconnect on all instances' do
+  #    @inst = subject.instance
+  #    @inst.expects(:disconnect!)
+  #    subject.shutdown!
+  #  end
+  #end
+
+  #describe 'clear_stale_cached_instances!' do
+  #  let(:thread) { mock('Thread') }
+  #  before { Thread.stubs(:list).returns([thread]) }
+  #  it 'should reap any instances for dead threads' do
+  #    thread.stubs(:alive?).returns(false)
+  #    inst = subject.instance
+  #    subject.instance_variable_set("@assigned_instances".to_sym, {thread.object_id => inst})
+  #    subject.expects(:checkin).with(inst)
+  #    subject.send :clear_stale_cached_instances!
+  #  end
+  #  it 'should not reap instances for live threads' do
+  #    thread.stubs(:alive?).returns(true)
+  #    inst = subject.instance
+  #    subject.instance_variable_set("@assigned_instances".to_sym, {thread.object_id => inst})
+  #    subject.expects(:checkin).with(inst).never
+  #    subject.send :clear_stale_cached_instances!
+  #  end
+  #end
+
+  #describe 'checkout' do
+  #  subject { NinjaModel::Adapters::AdapterPool.new(@spec) }
+  #  context 'with no current instances' do
+  #    it 'should checkout a new instance' do
+  #      subject.expects(:checkout_new_instance).returns('foo')
+  #      subject.send(:checkout)
+  #    end
+  #    it 'should store the instance' do
+  #      subject.send(:checkout)
+  #      subject.instances.count.should eql(1)
+  #    end
+  #  end
+
+  #  context 'with 1 existing instance' do
+  #    context 'that is already assigned' do
+  #      it 'should checkout a new instance' do
+  #        threads = []
+  #        subject.expects(:new_instance).twice.returns(NinjaModel::Adapters::AdapterManager.registered[subject.spec.name].new(subject.spec.config))
+  #        2.times do |idx|
+  #          threads << Thread.new do
+  #            subject.send(:checkout)
+  #          end
+  #        end
+  #        threads.each { |t| t.join }
+  #      end
+  #    end
+  #    context 'that is not assigned' do
+  #      it 'should checkout the existing instance' do
+  #        subject.expects(:checkout_existing_instance).returns('existing')
+  #        subject.instance
+  #        subject.release_instance
+  #        subject.instances.count.should eql(1)
+  #        subject.send(:checkout)
+  #      end
+  #    end
+  #  end
+
+  #  context 'with the maximum number of instances' do
+  #    context 'with an available instance' do
+  #      it 'should successfully check out an instance' do
+  #        subject.instance
+  #        threads = []
+  #        4.times do |idx|
+  #          threads << Thread.new do
+  #            subject.instance
+  #          end
+  #        end
+  #        threads.each { |t| t.join }
+  #        subject.release_instance
+  #        subject.send(:checkout).should_not be_nil
+  #      end
+  #    end
+
+  #    context 'with no available instances' do
+  #      it 'should raise a ConnectionTimeoutError' do
+  #        threads = []
+  #        5.times do |idx|
+  #          threads << Thread.new do
+  #            subject.instance
+  #          end
+  #        end
+  #        threads.each { |t| t.join }
+  #        subject.stubs(:clear_stale_cached_instances!)
+  #        lambda { subject.instance }.should raise_error(NinjaModel::ConnectionTimeoutError)
+  #      end
+  #    end
+
+  #    context 'with instances that can be reaped' do
+  #      it 'should return an existing instance' do
+  #        threads = []
+  #        5.times do |idx|
+  #          threads << Thread.new do
+  #            subject.instance
+  #          end
+  #        end
+  #        threads.each { |t| t.join }
+  #        subject.expects(:checkout_existing_instance).returns('foo')
+  #        subject.instance
+  #      end
+  #    end
+  #  end
+
+  #end
+#  before(:each) do
+#    @spec = mock('AdapterSpecification') do
+#      stubs(:adapter_method).returns(:dummy_adapter)
+#      stubs(:config)
+#    end
+#
+#    @adapter = mock('AbstractAdapter') do
+#      stubs(:verify!)
+#    end
+#
+#    @pool = NinjaModel::Adapters::AdapterPool.new(@spec)
+#    @thread = mock('thread') do
+#      stubs('object_id').returns(123)
+#    end
+#    Thread.stubs(:current).returns(@thread)
+#    NinjaModel::Base.stubs(:dummy_adapter).returns(@adapter)
+#  end
+#
+#  it 'should properly respond to connected?' do
+#    @pool.connected?.should be_false
+#    @pool.instance
+#    @pool.connected?.should be_true
+#  end
+#
+#  it 'should initialize from an AdapterSpecification' do
+#    spec = mock('AdapterSpecification')
+#    NinjaModel::Adapters::AdapterPool.new(spec).spec.should eql(spec)
+#  end
+#
+#  it 'should return a valid instance_id' do
+#    (@pool.send :current_instance_id).should eql(@thread.object_id)
+#  end
+#
+#  describe 'when creating an instance' do
+#    it 'should create a valid instance' do
+#      (@pool.send :new_instance).should eql(@adapter)
+#    end
+#
+#    it 'should store the instance' do
+#      @pool.stubs(:new_instance).returns(@adapter)
+#      @pool.instance
+#      @pool.instances.should include(@adapter)
+#    end
+#
+#    it 'should assign the instance to the current_thread' do
+#      @pool.stubs(:new_instance).returns(@adapter)
+#      @pool.instance
+#      @pool.stubs(:checkout).returns("new_instance")
+#      @pool.instance.should_not eql("new_instance")
+#      @pool.instance.should eql(@adapter)
+#    end
+#
+#    it 'should reuse an unallocated instance' do
+#      @pool.stubs(:current_instance_id).returns(123)
+#      inst = @pool.instance
+#      @pool.release_instance(123)
+#      @pool.instance.should eql(inst)
+#    end
+#  end
+#
+#  it 'should properly allocate/deallocate instances' do
+#    @pool.stubs(:current_instance_id).returns(123)
+#    @pool.expects(:checkout).returns(@adapter)
+#    @pool.expects(:checkin)
+#    @pool.with_instance do |instance|
+#    end
+#  end
+end

data/spec/lib/ninja_model/adapters_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe NinjaModel::Adapters do
+  let(:klass) { Class.new(NinjaModel::Base) }
+  #class SmarterAdapter < NinjaModel::Adapters::AbstractAdapter; end
+  #before {
+  #  NinjaModel::Base.register_adapter(:dummy, DummyAdapter::Adapter)
+  #  NinjaModel::Base.register_adapter(:smarter, SmarterAdapter)
+  #}
+  subject { klass }
+  it { should respond_to(:register_adapter) }
+  it { should respond_to(:set_adapter) }
+
+  describe 'adapter' do
+    subject { klass.new }
+    it 'should call retrieve_adapter' do
+      klass.expects(:retrieve_adapter)
+      subject.adapter
+    end
+  end
+
+  describe 'register_adapter' do
+    context 'with an invalid adapter' do
+      it 'should raise an InvalidAdapter exception' do
+        lambda { subject.register_adapter(:dummy, Class.new) }.should raise_error(NinjaModel::InvalidAdapter)
+      end
+    end
+
+    context 'with a valid adapter' do
+      let(:adapter) { Class.new(NinjaModel::Adapters::AbstractAdapter) }
+      it 'should register with the adapter manager' do
+        subject.adapter_manager.class.expects(:register_adapter_class).with(:dummy, adapter)
+        subject.register_adapter(:dummy, adapter)
+      end
+    end
+  end
+
+  describe 'set_adapter' do
+    let(:spec) { {'development' => {:adapter => :dummy } } }
+    let(:configuration) { stub(:specs => spec) }
+    let!(:adapter_spec) { NinjaModel::Adapters::AdapterSpecification.new(spec['development'], :dummy) }
+    before {
+      NinjaModel.stubs(:configuration).returns(configuration)
+      NinjaModel::Adapters::AdapterManager.stubs(:registered?).with(:dummy).returns(true)
+      NinjaModel::Adapters::AdapterSpecification.stubs(:new).with(spec['development'], :dummy).returns(adapter_spec)
+    }
+    subject { klass }
+    context 'when nil is passed' do
+      context 'when rails is unavailable' do
+        it 'should raise AdapterNotSpecified' do
+          lambda { subject.set_adapter }.should raise_error(NinjaModel::AdapterNotSpecified)
+        end
+        context 'when Rails is available' do
+          it 'should recurse with the Rails environment' do
+            rails = Object.const_set('Rails', Class.new(Object))
+            rails.stubs(:env).returns('development')
+            subject.adapter_manager.expects(:create_adapter).with(subject.name, adapter_spec)
+            subject.set_adapter
+            Object.send(:remove_const, :Rails)
+          end
+        end
+      end
+    end
+
+    context 'when a string is passed' do
+      it 'should successfully set an adapter' do
+        subject.adapter_manager.expects(:create_adapter).with(subject.name, adapter_spec)
+        subject.set_adapter('development')
+      end
+
+      context 'and the string is invalid' do
+        it 'should raise InvalidSpecification' do
+          lambda { subject.set_adapter('foobar') }.should raise_error(NinjaModel::InvalidSpecification)
+        end
+      end
+    end
+
+    context 'when a symbol is passed' do
+      it 'should successfully set an adapter' do
+        subject.adapter_manager.expects(:create_adapter).with(subject.name, adapter_spec)
+        subject.set_adapter(:development)
+      end
+
+      context 'and the symbol is invalid' do
+        it 'should raise InvalidSpecification' do
+          lambda { subject.set_adapter(:foobar) }.should raise_error(NinjaModel::InvalidSpecification)
+        end
+      end
+    end
+
+    context 'when a spec is passed' do
+      it 'should successfully set an adapter' do
+        subject.adapter_manager.expects(:create_adapter).with(subject.name, adapter_spec)
+        subject.set_adapter(spec['development'])
+
+      end
+    end
+
+    context 'when a specification is passed' do
+      it 'should successfully set an adapter' do
+        subject.adapter_manager.expects(:create_adapter).with(subject.name, adapter_spec)
+        subject.set_adapter(adapter_spec)
+      end
+    end
+  end
+
+  describe 'retrieve_adapter' do
+    it 'should call retrieve_adapter on the manager' do
+      klass.adapter_manager.expects(:retrieve_adapter).with(klass)
+      klass.retrieve_adapter
+    end
+  end
+
+  describe 'shutdown_adapter' do
+    it 'should call remove_adapter on the manager' do
+      klass.adapter_manager.expects(:remove_adapter).with(klass)
+      klass.shutdown_adapter
+    end
+  end
+end