praxis-mapper 3.4.0 → 4.0

data/lib/praxis-mapper/query/base.rb

@@ -192,7 +192,7 @@ module Praxis::Mapper
       end
 
       def to_records(rows)
-         rows.collect do |row|
+        rows.collect do |row|
           m = model.new(row)
           m._query = self
           m

data/lib/praxis-mapper/query/sequel.rb

@@ -92,6 +92,17 @@ module Praxis::Mapper
         end
       end
 
+      def to_records(rows)
+        if model < ::Sequel::Model
+          rows.collect do |row|
+            m = model.call(row)
+            m._query = self
+            m
+          end
+        else
+          super
+        end
+      end
 
     end
 

data/lib/praxis-mapper/sequel_compat.rb

@@ -0,0 +1,99 @@
+require 'active_support/concern'
+
+module Praxis::Mapper
+  module SequelCompat
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :_resource
+      attr_accessor :_query
+      attr_accessor :identity_map
+
+      @repository_name = :default
+    end
+
+    module ClassMethods
+
+      def identities
+        [primary_key]
+      end
+
+      def finalized?
+        true
+      end
+
+      def associations
+        orig = self.association_reflections.clone
+
+        orig.each do |k,v|
+          v[:model] = v.associated_class
+          if v.respond_to?(:primary_key)
+            v[:primary_key] = v.primary_key
+          else
+            # FIXME: figure out exactly what to do here. 
+            # not super critical, as we can't track these associations
+            # directly, but it would be nice to traverse these
+            # properly.
+            v[:primary_key] = :unsupported
+          end
+        end
+        orig
+      end
+
+      def repository_name(name=nil)
+        return @repository_name if name.nil?
+
+        @repository_name = name
+      end
+
+    end
+
+
+    def _load_associated_objects(opts, dynamic_opts=OPTS)
+      return super if self.identity_map.nil?
+      target = opts.associated_class
+      key = opts[:key]
+
+      case opts[:type]
+      when :many_to_one
+        val = if key.kind_of?(Array)
+          @values.values_at(*key)
+        else
+          @values[key]
+        end
+        return nil if val.nil?
+        self.identity_map.get(target, target.primary_key => val)
+      when :one_to_many
+        self.identity_map.all(target, key => [pk] )
+      when :many_to_many
+        # OPTIMIZE: cache this result
+        join_model = opts[:join_model].constantize
+
+        left_key = opts[:left_key]
+        right_key = opts[:right_key]
+
+        right_values = self.identity_map.
+          all(join_model, left_key => Array(values[primary_key])).
+          collect(&right_key)
+
+        self.identity_map.all(target, target.primary_key => right_values )
+      else
+        raise "#{opts[:type]} is not currently supported"
+      end
+    end
+
+
+    def identities
+      self.class.identities.each_with_object(Hash.new) do |identity, hash|
+        case identity
+        when Symbol
+          hash[identity] = values[identity].freeze
+        else
+          hash[identity] = values.values_at(*identity).collect(&:freeze)
+        end
+      end
+    end
+
+
+  end
+end

data/lib/praxis-mapper/version.rb

@@ -1,5 +1,5 @@
 module Praxis
   module Mapper
-    VERSION = "3.4.0"
+    VERSION = "4.0"
   end
 end

data/praxis-mapper.gemspec

@@ -34,4 +34,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency(%q<pry-byebug>, ["~> 1"])
   spec.add_development_dependency(%q<pry-stack_explorer>, ["~> 0"])
   spec.add_development_dependency(%q<fuubar>, ["~> 1"])
+  spec.add_development_dependency('sqlite3')
+  spec.add_development_dependency('factory_girl')
 end

data/spec/factories/all.rb

@@ -0,0 +1,32 @@
+FactoryGirl.define do
+
+  to_create { |i| i.save }
+
+  factory :user, class: UserModel, aliases: [:author] do
+    name { /[:name:]/.gen }
+    email { /[:email:]/.gen }
+  end
+
+  factory :post, class: PostModel do
+    title { /\w+/.gen }
+    body  { /\w+/.gen }
+    author
+  end
+
+  factory :comment, class: CommentModel do
+    author
+    post
+  end
+
+  factory :composite, class: CompositeIdSequelModel do
+    id { /\w+/.gen }
+    type { /\w+/.gen }
+
+    name  { /\w+/.gen }
+  end
+
+  factory :other, class: OtherSequelModel do
+    composite
+  end
+
+end

data/spec/praxis-mapper/connection_factories/sequel_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Praxis::Mapper::ConnectionFactories::Sequel do
+
+  let(:database) { Sequel.mock}
+  let(:thread) { Thread.current }
+  let(:connection_manager) { double('Praxis::Mapper::ConnectionManager', thread: thread) }
+
+  subject(:factory) { described_class.new(connection:database) }
+
+  context 'checkout' do
+    it 'returns the connection' do
+      factory.checkout(connection_manager).should be database
+    end
+
+    it 'allocates a connection to the thread of the manager' do
+      database.pool.allocated.should_not have_key(thread)
+      factory.checkout(connection_manager)
+      database.pool.allocated.should have_key(thread)
+    end
+
+    it 'does not acquire a new connection if the thread already has one' do
+      connection = double('connection')
+      database.pool.allocated[thread] = connection
+
+      factory.checkout(connection_manager)
+      database.pool.allocated[thread].should be connection
+    end
+
+  end
+
+  context 'release' do
+    before do
+      factory.checkout(connection_manager)
+    end
+
+    it 'releases the connection' do
+      database.pool.allocated.should have_key(thread)
+      factory.release(connection_manager, database)
+      database.pool.allocated.should_not have_key(thread)
+    end
+  end
+
+  context 'across multiple threads' do
+    before do
+      factory.checkout(connection_manager)
+    end
+
+    it 'acquires a connection in a separate thread' do
+      database.pool.allocated.should have_key(thread)
+
+      thread_2 = Thread.new do
+        connection_manager_2 = Praxis::Mapper::ConnectionManager.new
+        database.pool.allocated.should_not have_key(Thread.current)
+        database.pool.allocated.should have_key(thread)
+
+        factory.checkout(connection_manager_2)
+        database.pool.allocated.should have_key(Thread.current)
+        database.pool.allocated.should have_key(thread)
+      end
+
+      thread_2.join
+    end
+  end
+
+
+end

data/spec/praxis-mapper/connection_factories/simple_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Praxis::Mapper::ConnectionFactories::Simple do
+
+  let(:connection) { double("connection") }
+
+  let(:connection_manager) { double('Praxis::Mapper::ConnectionManager') }
+
+  context 'with a raw connection' do
+    subject(:factory) { described_class.new(connection:connection) }
+
+    it 'returns the connection on checkout' do
+      factory.checkout(connection_manager).should be connection
+    end
+
+  end
+
+  context 'with a proc' do
+    let(:block) { Proc.new { connection } }
+
+    subject(:factory) { described_class.new(&block) }
+    
+    it 'calls the block on checkout' do
+      block.should_receive(:call).and_call_original
+      factory.checkout(connection_manager).should be connection
+    end
+  end
+
+end

data/spec/praxis-mapper/connection_manager_spec.rb

@@ -1,117 +1,95 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 class DummyFactory
+  attr_reader :opts
   def initialize(opts)
     @opts = opts
   end
 
-  def opts
-    @opts
+  def checkout(connection_manager)
   end
 
-  def checkout
-  end
-
-  def release(connection)
+  def release(connection_manager, connection)
   end
 
 end
 
-
 describe Praxis::Mapper::ConnectionManager do
   let(:mock_connection) { double("connection") }
 
   let(:default_hash) { Hash.new }
   let(:factory_opts) { {:foo => "bar"} }
-  let(:config) { {:dummy => {:connection_factory => "DummyFactory", :connection_opts => factory_opts}} }
 
+  let(:dummy_connection) { double("dummy connection")}
   let(:dummy_factory_mock) { double("dummy_factory")}
 
-  subject { Praxis::Mapper::ConnectionManager }
-  
+  subject(:connection_manager) { Praxis::Mapper::ConnectionManager }
+
   before do
-    Praxis::Mapper::ConnectionManager.setup(config)
+    opts = factory_opts
+    block = Proc.new { mock_connection }
+
+    Praxis::Mapper::ConnectionManager.setup do
+      repository :foo, &block
+      repository :bar, :factory => "DummyFactory", :opts => opts
+    end
   end
 
-  it 'has a :dummy repository' do
-    repository = subject.repository(:dummy)
+  it 'supports proc-based repostories' do
+    subject.repository(:foo)[:factory].should be_kind_of(Praxis::Mapper::ConnectionFactories::Simple)
+  end
 
-    repository[:connection_factory].should be_kind_of(DummyFactory)
-    repository[:connection_factory].opts.should == factory_opts
+  it 'supports config-based repositories' do
+    subject.repository(:bar)[:factory].should be_kind_of(DummyFactory)
+    subject.repository(:bar)[:factory].opts.should == factory_opts
   end
 
-  context "with repositories specified in a block for setup" do
-    let(:dummy_connection) { double("dummy connection")}
-
-    before do
-      opts = factory_opts
-      
-      block = Proc.new { mock_connection }
-      Praxis::Mapper::ConnectionManager.setup do
-        repository :foo, &block
-        repository :bar, :connection_factory => "DummyFactory", :connection_opts => opts
-      end
-    end
+  context 'getting connections' do
 
-    it 'supports proc-based repostories' do
-      subject.repository(:foo)[:connection_factory].should be_kind_of(Proc)
-    end
+    subject { Praxis::Mapper::ConnectionManager.new }
 
-    it 'supports config-based repositories' do
-      subject.repository(:bar)[:connection_factory].should be_kind_of(DummyFactory)
-      subject.repository(:bar)[:connection_factory].opts.should == factory_opts
+    it 'gets connections from proc-based repositories' do
+      subject.checkout(:foo).should == mock_connection
     end
 
-    context 'getting connections' do
-      
-      subject { Praxis::Mapper::ConnectionManager.new }
-
-      it 'gets connections from proc-based repositories' do
-        subject.checkout(:foo).should == mock_connection
-      end
+    it 'gets connections from config-based repositories' do
+      DummyFactory.any_instance.should_receive(:checkout).with(subject).and_return(dummy_connection)
+      subject.checkout(:bar).should == dummy_connection
+    end
 
-      it 'gets connections from config-based repositories' do
-        DummyFactory.any_instance.should_receive(:checkout).and_return(dummy_connection)
-        subject.checkout(:bar).should == dummy_connection
-      end
+  end
 
-    end
+  context 'releasing connections' do
+    subject { Praxis::Mapper::ConnectionManager.new }
 
-    context 'releasing connections' do
-      subject { Praxis::Mapper::ConnectionManager.new }
+    it 'releases connections from config-based repositories' do
+      DummyFactory.any_instance.should_receive(:checkout).with(subject).exactly(2).times.and_return(dummy_connection)
+      DummyFactory.any_instance.should_receive(:release).with(subject, dummy_connection).and_return(true)
 
-      it 'releases connections from config-based repositories' do
+      subject.checkout(:bar)
+      subject.checkout(:bar)
 
-        DummyFactory.any_instance.should_receive(:checkout).exactly(2).times.and_return(dummy_connection)
-        DummyFactory.any_instance.should_receive(:release).with(dummy_connection).and_return(true)
+      subject.release(:bar)
 
-        subject.checkout(:bar)
-        subject.checkout(:bar)
-        
-        subject.release(:bar)
-        
-        subject.checkout(:bar)
-      end
+      subject.checkout(:bar)
+    end
 
-      it 'releases connections from proc-based repositories' do
-        subject.checkout(:foo)
-        subject.release(:foo)
-      end
+    it 'releases connections from proc-based repositories' do
+      subject.checkout(:foo)
+      subject.release(:foo)
+    end
 
-      it 'releases all connections' do
-        DummyFactory.any_instance.should_receive(:checkout).exactly(1).times.and_return(dummy_connection)
-        DummyFactory.any_instance.should_receive(:release).with(dummy_connection).and_return(true)
+    it 'releases all connections' do
+      DummyFactory.any_instance.should_receive(:checkout).with(subject).exactly(1).times.and_return(dummy_connection)
+      DummyFactory.any_instance.should_receive(:release).with(subject, dummy_connection).and_return(true)
 
-        subject.checkout(:bar)
+      subject.checkout(:bar)
 
-        subject.should_not_receive(:release_one).with(:foo).and_call_original
-        subject.should_receive(:release_one).with(:bar).and_call_original
-        
-        subject.release
-      end
+      subject.should_not_receive(:release_one).with(:foo).and_call_original
+      subject.should_receive(:release_one).with(:bar).and_call_original
 
+      subject.release
     end
 
-
   end
 end

data/spec/praxis-mapper/identity_map_extensions/persistence_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Praxis::Mapper::IdentityMapExtensions::Persistence do
+
+  let(:user) { UserModel.create }
+  let(:post) { PostModel.create(title: 'title', author: user) }
+  
+  before do
+    identity_map.add_record(post)
+    identity_map.add_record(user)
+    identity_map.reindex!(PostModel, :author_id)
+  end
+
+  subject(:identity_map) { Praxis::Mapper::IdentityMap.new }
+
+  context '#attach(record)' do
+    context 'for a record that is missing an identity' do
+      let(:post) { PostModel.new(title: 'title') }
+
+      it 'saves the record before adding it ' do
+        post.should_receive(:save).and_call_original
+        identity_map.should_receive(:add_record).with(post).and_call_original
+
+        identity_map.attach(post)
+
+        identity_map.get(PostModel, id: post.id).should be post
+      end
+    end
+
+    context 'for a record that is not missing an identity' do
+      let(:post) { PostModel.create(title: 'title') }
+
+      it 'does not save the record before adding it' do
+        post.should_not_receive(:save).and_call_original
+        identity_map.should_receive(:add_record).with(post).and_call_original
+
+        identity_map.attach(post)
+
+        identity_map.get(PostModel, id: post.id).should be post
+      end
+    end
+  end
+
+  context '#flush!(object=nil)' do
+
+    context 'with a single record' do
+      it 'saves the changes' do
+        post.title = 'something else'
+
+        identity_map.flush!(post)
+        post.modified?.should be false
+      end
+    end
+
+    context 'for an entire model class' do
+      it 'flushes every changed record' do
+        post.title = 'something else'
+
+        identity_map.flush!(PostModel)
+        post.modified?.should be false
+      end
+    end
+
+    context 'with no object' do
+      it 'flushes every class' do
+        identity_map.should_receive(:flush!).with(no_args).and_call_original
+        identity_map.should_receive(:flush!).with(PostModel)
+        identity_map.should_receive(:flush!).with(UserModel)
+
+
+        identity_map.flush!
+      end
+    end
+  end
+
+  context '#remove(record)' do
+    it 'detaches and deletes the record' do
+      identity_map.should_receive(:detach).with(post).and_call_original
+      post.should_receive(:delete)
+
+      identity_map.remove(post)
+    end
+  end
+
+  context '#detach(record)' do
+
+    it 'unsets record identity_map and deindexes the record' do
+      identity_map.should_receive(:deindex).with(post)
+      identity_map.detach(post)
+      post.identity_map.should be nil
+    end
+  end
+
+  context '#deindex(record)' do
+    let!(:original_id) { post.id }
+
+    before do
+      post.id = 100
+
+      # build secondary index and ensure it's populated correctly
+      identity_map.all(PostModel, title: [post.title]).should include post
+ 
+      identity_map.deindex(post)
+    end
+
+    it 'cleans up all-rows index' do
+      identity_map.all(PostModel).should be_empty
+    end
+
+    it 'cleans up identity indexes' do
+      identity_map.all(PostModel, id: [original_id]).should be_empty
+      identity_map.all(PostModel, id: [post.id]).should be_empty
+    end
+
+    it 'cleans up secondary indexes' do
+      identity_map.all(PostModel, title: [post.title]).should_not include post
+    end
+
+  end
+
+
+end