schron 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7769c035395e049f20cbede7cda51f0b39c8ed28
-  data.tar.gz: 6eacb27127b5d4770d36dd17692697b1bd39d93e
+  metadata.gz: 8f4bf73bf955f3f82baa2bab5bc3acc1b812cd61
+  data.tar.gz: 334dc42717de4a920f6c698a031829d6113615c3
 SHA512:
-  metadata.gz: e2f2c532a880389220906e087c45772d8430159ff4b102c33aa770793ba1c0e52e7db0714cfb6e3833c3a463e9aa3b273950d362d1e490b58d5600565280fe62
-  data.tar.gz: a3becfbd86f34a23e6a5d3038f35df103ce72cadb31753fbacae795574644987488a9fd8c83693a92fc458f2bc04a78dfc344e116a857ceeee283408b40babca
+  metadata.gz: 978dfca8ba3c7ea74efd6ad4825fcc34f6cf9641c2b8417185a9242c15e9a68122442c3736711288ccbb5b2fb48ce73364aaf602598ab517d5391d8be5b4dac1
+  data.tar.gz: 4385936c35b1df5c92c15d00fef37d12641f613766305d78baf319f1a3317618205f7f1d736734f03ab6027bf0f6ff0abba6dd3dd10be757f0b8d10d6d94d0b0

data/Rakefile

@@ -12,8 +12,9 @@ task :bundle do
   system "cd #{root} && bundle install"
 end
 
-task :spec do
-  system "cd #{root} && bundle exec rspec"
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = '--color'
 end
 
-task :default => [:bundle, :spec]
+task :default => [:bundle, :spec]

data/lib/schron/archive.rb

@@ -27,11 +27,28 @@ module Schron
     def query(&block)
       Query.new(self, &block)
     end
+
+    def exec_query(query)
+      raw_results = datastore.exec_query(query)
+      load_all(raw_results)
+    end
+
+    def exec_count(query)
+      datastore.exec_count(query)
+    end
     
     def all
       query.all
     end
     
+    def batches(size, &block)
+      query.batches(size, &block)
+    end
+    
+    def batched_each(size, &block)
+      query.batched_each(size, &block)
+    end
+    
     def first
       query.first
     end

data/lib/schron/datastore/mongo.rb

@@ -30,43 +30,55 @@ module Schron
       end
       
       def insert(kind, hash)
-        hash[:id] ||= Schron::Id.generate
-        serialized = serialize(kind, hash)
-        coll(kind).insert(serialized)
-        hash
+        with_write_errors! do
+          hash[:id] ||= Schron::Id.generate
+          serialized = serialize(kind, hash)
+          coll(kind).insert(serialized)
+          hash
+        end
       end
       
       def multi_insert(kind, hashes)
-        hashes.each { |h| h[:id] ||= Schron::Id.generate }
-        docs = hashes.map { |h| serialize(kind, h) }
-        coll(kind).insert(docs)
-        hashes
+        with_write_errors! do
+          hashes.each { |h| h[:id] ||= Schron::Id.generate }
+          docs = hashes.map { |h| serialize(kind, h) }
+          coll(kind).insert(docs)
+          hashes
+        end
       end
       
       def update(kind, hash)
-        Schron::Id.require!(hash)
-        doc = serialize(kind, hash)
-        coll(kind).update(id_selector(hash[:id]), doc)
-        hash
+        with_write_errors! do
+          Schron::Id.require!(hash)
+          doc = serialize(kind, hash)
+          coll(kind).update(id_selector(hash[:id]), doc)
+          hash
+        end
       end
       
       def multi_update(kind, hashes)
-        Schron::Id.require_all!(hashes)
-        hashes.each do |hash|
-          doc = serialize(kind, hash)
-          coll(kind).update(id_selector(hash[:id]), doc)
+        with_write_errors! do
+          Schron::Id.require_all!(hashes)
+          hashes.each do |hash|
+            doc = serialize(kind, hash)
+            coll(kind).update(id_selector(hash[:id]), doc)
+          end
+          hashes
         end
-        hashes
       end
       
       def remove(kind, id)
-        coll(kind).remove(id_selector(id))
-        nil
+        with_write_errors! do
+          coll(kind).remove(id_selector(id))
+          nil
+        end
       end
       
       def multi_remove(kind, ids)
-        coll(kind).remove(multiple_id_selector(ids))
-        nil
+        with_write_errors! do
+          coll(kind).remove(multiple_id_selector(ids))
+          nil
+        end
       end
       
       def exec_query(query)
@@ -138,6 +150,22 @@ module Schron
         {_id: {"$in" => serialized }}
       end
 
+
+      def with_write_errors!(&block)
+        block.call
+      rescue ::Mongo::OperationFailure => detail
+        if detail.result &&
+            detail.result['writeErrors'] &&
+            !detail.result['writeErrors'].empty?
+          case detail.result['writeErrors'].first['code']
+          when 11000
+            raise Schron::DuplicateKeyError.new(nil, detail.result)
+          end
+        end
+
+        raise detail
+      end
+
       def selector_for(query)
         selector = {}
         query.filters.each do |(field, op, filter_value)|
@@ -186,4 +214,4 @@ module Schron
       
     end
   end
-end
+end

data/lib/schron/db.rb

@@ -0,0 +1,36 @@
+module Schron
+  class DB
+
+    def initialize(repos={})
+      @repos = repos.each_with_object({}) do |(k,v), hash|
+        hash[k.to_sym] = v
+      end
+      @repos.each do |name, repo|
+        define_singleton_method(name) { self[name] }
+      end
+    end
+
+    def [](name)
+      @repos[name.to_sym]
+    end
+
+    def session_begin
+      @repos.each do |name, repo|
+        repo.session_begin if repo.respond_to?(:session_begin)
+      end
+    end
+
+    def session_end
+      @repos.each do |name, repo|
+        repo.session_end if repo.respond_to?(:session_end)
+      end
+    end
+
+    def session(&block)
+      session_begin
+      block.call
+    ensure
+      session_end
+    end
+  end
+end

data/lib/schron/error.rb

@@ -4,4 +4,12 @@ module Schron
   
   class OperationDisabledError < Error
   end
-end
+
+  class DuplicateKeyError < Error
+    
+    def initialize(message=nil, datastore_info=nil)
+      super(message)
+      @datastore_info = datastore_info
+    end
+  end
+end

data/lib/schron/identity_map.rb

@@ -21,6 +21,14 @@ module Schron
     def has?(id)
       @data.key?(id)
     end
+
+    def delete(id)
+      @data.delete(id)
+    end
     
+    def clear
+      @data = {}
+    end
+
   end
-end
+end

data/lib/schron/identity_map_repository.rb

@@ -0,0 +1,168 @@
+require 'schron/identity_map'
+require 'schron/repository/interface'
+require 'schron/repository'
+require 'schron/archive/interface'
+
+module Schron
+  module IdentityMapRepository
+    include Schron::Archive::Interface
+    include Schron::Repository::Interface
+    
+    include Schron::Repository
+
+    def self.included(archive_class)
+      archive_class.extend Schron::DSL
+    end
+
+
+    # def initialize(*args)
+    #   super(*args)
+    #   @id_map = nil
+    # end
+
+#     def method_missing(method_name, *args, &block)
+#       @repo.method(method_name).unbind.bind(self).call(*args, &block)
+# #      @repo.__send__(method_name, *args, &block)
+#     end
+
+    # def respond_to_missing?(method_name, include_private = false)
+    #   @repo.respond_to?(method_name, include_private)
+    # end
+
+    def session_begin
+      @id_map ||= IdentityMap.new
+      @sessions ||= 0
+      @sessions += 1
+      nil
+    end
+
+    def session_end
+      raise 'no session is open' unless @id_map
+      @sessions -= 1
+      @id_map = nil if @sessions == 0
+      nil
+    end
+
+    def session(&block)
+      session_begin
+      block.call
+    ensure
+      session_end
+    end
+
+    # [:datastore, :kind, :entity_class, :indexed_fields,
+    #   :identity].each do |repo_method|
+    #   define_method(repo_method) do |*args, &block|
+    #     @repo.__send__(repo_method, *args, &block)
+    #   end
+    # end
+    
+    # def query(&block)
+    #   Query.new(self, &block)
+    # end
+
+    def exec_query(query)
+      results = super
+      results.map do |object|
+        if identity_map.has?(object.id)
+          id_map_object = identity_map.get(object.id)
+          assign_attributes(from: object, to: id_map_object)
+          id_map_object
+        else
+          identity_map.put(object.id, object)
+          object
+        end
+      end
+    end
+
+    def get(id)
+      identity_map.fetch(id) do
+        super
+        # @repo.get(id)
+      end
+    end
+
+    def multi_get(ids)
+      ids = ids.to_a unless ids.kind_of?(Array)
+      result = Array.new(ids.size)
+      needed_ids = []
+
+      ids.each_with_index do |id, index|
+        if identity_map.has?(id)
+          result[index] = identity_map.get(id)
+        else
+          needed_ids << id
+        end
+      end
+      
+      needed_objects = super(needed_ids)#@repo.multi_get(needed_ids)
+      needed_objects.each do |object|
+        if object
+          identity_map.put(object.id, object)
+          result[ids.index(object.id)] = object
+        end
+      end
+      
+      result.compact
+    end
+
+    def insert(object)
+      result = super
+      # result = @repo.insert(object)
+      assign_attributes(from: result, to: object)
+      identity_map.put(object.id, object)
+      object
+    end
+
+    def multi_insert(objects)
+      # results = @repo.multi_insert(objects)
+      results = super
+      objects.each_with_index do |o, i|
+        assign_attributes(from: results[i], to: o)
+        identity_map.put(o.id, o)
+      end
+      objects
+    end
+
+    def update(object)
+      super
+      # @repo.update(object)
+      object
+    end
+
+    def multi_update(objects)
+      super
+      # @repo.multi_update(objects)
+      objects
+    end
+
+    def remove(id)
+      super
+      object = identity_map.delete(id)
+      object.freeze if object
+      nil
+    end
+
+    def multi_remove(ids)
+      super
+      ids.each do |id|
+        object = identity_map.delete(id)
+        object.freeze if object
+      end
+      nil
+    end
+
+    def identity_map
+      @id_map || raise('Must start a session before accessing data from an IdentityMapRepository')
+    end
+
+    private
+
+    def assign_attributes(from: from, to: to)
+      if to.respond_to?(:attributes=)
+        to.attributes = from.attributes
+      end
+    end
+
+  end
+end

data/lib/schron/logged_repository.rb

@@ -0,0 +1,58 @@
+require 'delegate'
+require 'logger'
+require 'benchmark'
+
+module Schron
+  class LoggedRepository
+
+    def initialize(repo,
+        logger: nil,
+        log_level: :info,
+        exclude_regexp: nil,
+        include_regexp: nil)
+      @repo = repo
+      @logger = logger || Logger.new(STDOUT)
+      @log_level = log_level
+      @exclude = exclude_regexp
+      @include = include_regexp
+    end
+
+    def method_missing(method_name, *args, &block)
+      if @repo.respond_to?(method_name)
+        log(method_name, *args) do
+          @repo.__send__(method_name, *args, &block)
+        end
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private=false)
+      @repo.respond_to?(method_name, include_private)
+    end
+
+    private
+
+    def log(method_name, *args, &block)
+      if should_log_method?(method_name)
+        label = "#{@repo.class.name}##{method_name}(#{args.inspect})"
+        return_val = nil
+        time = Benchmark.realtime { return_val = block.call }
+        @logger.__send__(@log_level, ":repo: finished #{label} (#{time}s)")
+        return_val
+      else
+        block.call
+      end
+    end
+
+    def should_log_method?(method_name)
+      if @exclude && method_name =~ @exclude
+        false
+      elsif @include && method_name !~ @include
+        false
+      else
+        true
+      end
+    end
+  end
+end

data/lib/schron/query.rb

@@ -71,9 +71,7 @@ module Schron
     ## Query Terminators
     
     def all
-      raw_results = datastore.exec_query(self)
-      loaded_results = archive.load_all(raw_results)
-      with_pagination(loaded_results)
+      with_pagination(archive.exec_query(self))
     end
     
     def first
@@ -81,13 +79,25 @@ module Schron
     end
     
     def count
-      datastore.exec_count(self)
+      archive.exec_count(self)
     end
     
     def exists?
       count > 0
     end
     
+    def batched_each(size, &block)
+      batches(size) { |group| group.each(&block) }
+    end
+
+    def batches(size, &block)
+      current_page = 1
+      begin
+        results = page(current_page, per_page: size).all
+        block.call(results)
+        current_page = results.paging.next_page
+      end while current_page
+    end
     
     protected
 

data/lib/schron/test/entity.rb

@@ -2,7 +2,8 @@ module Schron
   module Test
     class Entity
 
-      attr_reader :attributes
+      attr_accessor :attributes
+      
       def initialize(attrs={})
         @attributes = attrs
       end
@@ -18,4 +19,4 @@ module Schron
 
     end
   end
-end
+end

data/lib/schron/test/repository_examples.rb

@@ -65,4 +65,4 @@ if defined?(RSpec)
 
   end
   
-end
+end

data/schron.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "schron"
-  spec.version       = "0.0.3"
+  spec.version       = "0.0.4"
   spec.authors       = ["David Faber"]
   spec.email         = ["david@1bios.co"]
   spec.summary       = %q{Repository implementation for entity persistence}

data/spec/lib/schron/datastore/mongo_spec.rb

@@ -20,4 +20,21 @@ describe Schron::Datastore::Mongo do
   
   include_examples 'schron datastore'
 
-end
+  describe 'error handling' do
+    context 'duplicate key error' do
+      let(:coll_name) { 'books' }
+
+      before(:each) do
+        db[coll_name].create_index(:title, unique: true)
+      end
+
+      it 'raises a Schron::DuplicateKeyError' do
+        ds.insert('books', title: 'Hyperion')
+        expect do
+          ds.insert('books', title: 'Hyperion')
+        end.to raise_error(Schron::DuplicateKeyError)
+      end
+    end
+  end
+
+end

data/spec/lib/schron/db_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'schron/db'
+
+describe Schron::DB do
+  subject(:db) do
+    described_class.new(
+      users: id_map_repo,
+      foos: non_id_map_repo)
+  end
+
+  let(:id_map_repo) { double }
+
+  let(:non_id_map_repo) { double }
+
+  it 'defines accessors for each repository' do
+    expect(db.users).to be(id_map_repo)
+    expect(db.foos).to be(non_id_map_repo)
+  end
+
+  it 'access repos by name as a symbol with []' do
+    expect(db[:users]).to eq(id_map_repo)
+    expect(db[:foos]).to eq(non_id_map_repo)
+  end
+
+  it 'access repos by name as string with []' do
+    expect(db['users']).to eq(id_map_repo)
+    expect(db['foos']).to eq(non_id_map_repo)    
+  end
+
+  it 'opens sessions on all repos at once' do
+    expect(id_map_repo).to receive(:session_begin)
+    expect(id_map_repo).to receive(:session_end)
+    db.session {}
+  end
+end

data/spec/lib/schron/identity_map_repository_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+require 'schron/repository'
+require 'schron/datastore/memory'
+require 'schron/identity_map_repository'
+
+describe Schron::IdentityMapRepository do
+  include Schron::Test
+
+  subject(:repo) { repo_class.new(ds) }
+
+  let(:archive) { repo }
+  
+  let(:repo_class) do
+    Class.new do
+      include Schron::IdentityMapRepository
+      entity_class Schron::Test::Entity
+      kind 'test'
+    end
+  end
+  # let(:underlying_repo) do
+  #   underlying_repo_class.new(ds,
+  #     entity_class: Schron::Test::Entity,
+  #     kind: 'test')
+  # end
+
+  let(:ds) { Schron::Datastore::Memory.new }
+
+  describe 'session' do
+    it 'creates an identity map' do
+      expect { repo.identity_map }.to raise_error
+      repo.session do
+        expect(repo.identity_map).not_to be_nil
+      end
+    end
+
+    it 'creates a new one for each session' do
+      id_map = nil
+      repo.session { id_map = repo.identity_map }
+      repo.session do
+        expect(id_map).not_to be(repo.identity_map)
+      end
+    end
+
+    it 'uses the same identity map if a session has already started' do
+      repo.session_begin
+      id_map = repo.identity_map
+      repo.session_begin
+      expect(id_map).to be(repo.identity_map)
+    end
+
+    it 'closes sessions after an equal number of begin and end calls have been made' do
+      repo.session_begin
+      repo.session_begin
+      repo.session_end
+      expect(repo.identity_map).not_to be_nil
+      repo.session_end
+      expect{ repo.identity_map }.to raise_error
+    end
+  end
+
+  describe 'shared examples' do
+    around(:each) do |example|
+      repo.session { example.run }
+    end
+    
+    include_examples 'schron archive'
+    include_examples 'schron repository'
+  end
+
+  context 'within a session' do
+    around(:each) do |example|
+      repo.session { example.run }
+    end
+
+    let(:object) { repo.insert(repo.entity_class.new) }
+    let(:object2) { repo.insert(repo.entity_class.new) }
+
+    it 'returns the same object after insertion' do
+      obj = repo.entity_class.new
+      inserted = repo.insert(obj)
+      expect(inserted).to be(obj)
+    end
+
+    it 'returns the same objects after multi insertion' do
+      obj = repo.entity_class.new
+      inserted = repo.multi_insert([obj]).first
+      expect(obj).to be(inserted)
+    end
+    
+    it 'returns one object ref when retreived with get' do
+      loaded = repo.get(object.id)
+      expect(object).to be(loaded)
+    end
+
+    it 'returns the same object ref when retrieved by multi get' do
+      loaded = repo.multi_get([object.id]).first
+      expect(object).to be(loaded)
+    end
+
+    it 'can multi_get a set of ids' do
+      object
+      object2
+      repo.identity_map.clear
+      result = repo.multi_get(Set.new([object.id, object2.id]))
+      expect(result.map(&:id)).to include(object.id, object2.id)
+    end
+
+    it 'syncs updates' do
+      loaded = repo.get(object.id)
+      loaded.attributes[:thing] = 'thing'
+      updated = repo.update(loaded)
+      expect(updated).to be(object)
+      expect(object.attributes[:thing]).to eq('thing')
+      reloaded = repo.get(object.id)
+      expect(reloaded.attributes[:thing]).to eq('thing')
+      expect(reloaded).to be(object)
+    end
+
+    it 'syncs multi updates' do
+      l1 = repo.get(object.id)
+      l2 = repo.get(object2.id)
+      l1.attributes[:a] = 'b'
+      l2.attributes[:b] = 'c'
+
+      results = repo.multi_update([l1, l2])
+      expect(results[0]).to be(object)
+      expect(results[1]).to be(object2)
+
+      expect(object.attributes[:a]).to eq('b')
+      expect(object2.attributes[:b]).to eq('c')
+    end
+
+    it 'freezes removed objects' do
+      loaded = repo.get(object.id)
+      repo.remove(loaded.id)
+      expect(object).to be_frozen
+    end
+
+    it 'freezes multi-removed objects' do
+      loaded = repo.get(object.id)
+      repo.multi_remove([loaded.id])
+      expect(object).to be_frozen
+    end
+
+    # it 'calls custom repo methods on the original repo' do
+    #   repo.define_singleton_method(:my_query) do |a1, &block|
+    #     block.call(a1)
+    #   end
+    #   results = []
+    #   repo.my_query('testing') do |val|
+    #     results << val
+    #   end
+    #   expect(results).to eq(['testing'])
+    # end
+
+    # it 'responds_to? methods on the original repo' do
+    #   underlying_repo.define_singleton_method(:custom_thing) {}
+    #   expect(repo).to respond_to(:custom_thing)
+    # end
+
+  end
+
+  describe 'queries' do
+    it 'puts query results into the identiy map' do
+      repo.session { repo.insert(repo.entity_class.new) }
+      repo.session do
+        obj = repo.query.all.first
+        expect(obj).to be(repo.get(obj.id))
+      end
+    end
+
+    it 'pulls query results from the identity map' do
+      repo.session do
+        obj = repo.insert(repo.entity_class.new)
+        expect(obj).to be(repo.query.first)
+      end
+    end
+    
+  end
+end

data/spec/lib/schron/query_spec.rb

@@ -62,4 +62,26 @@ describe Schron::Query do
       expect(query.first).to eq('loaded')
     end
   end
+  
+  describe 'batches' do
+    it 'iterates over all results in groups, only loading the specified amount into memory at a time' do
+      expect(ds).to receive(:exec_query).at_least(2).and_call_original
+      2.times { archive.insert(Schron::GenericEntity.new) }
+      query.batches(1) do |group|
+        expect(group.size).to eq(1)
+      end
+    end
+  end
+  
+  describe 'batched each' do
+    it 'iterates over each result, only loading the specified amount into memory at a time' do
+      expect(ds).to receive(:exec_query).at_least(2).and_call_original
+      2.times { archive.insert(Schron::GenericEntity.new) }
+      i = 0
+      query.batches(1) do |item|
+        i += 1
+      end
+      expect(i).to eq(2)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: schron
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - David Faber
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-20 00:00:00.000000000 Z
+date: 2014-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -128,12 +128,15 @@ files:
 - lib/schron/datastore/mongo/serializer.rb
 - lib/schron/datastore/sequel.rb
 - lib/schron/datastore/serializer.rb
+- lib/schron/db.rb
 - lib/schron/dsl.rb
 - lib/schron/error.rb
 - lib/schron/generic_archive.rb
 - lib/schron/generic_entity.rb
 - lib/schron/id.rb
 - lib/schron/identity_map.rb
+- lib/schron/identity_map_repository.rb
+- lib/schron/logged_repository.rb
 - lib/schron/paginated_results.rb
 - lib/schron/paging.rb
 - lib/schron/query.rb
@@ -150,7 +153,9 @@ files:
 - spec/lib/schron/datastore/memory_spec.rb
 - spec/lib/schron/datastore/mongo_spec.rb
 - spec/lib/schron/datastore/sequel_spec.rb
+- spec/lib/schron/db_spec.rb
 - spec/lib/schron/dsl_spec.rb
+- spec/lib/schron/identity_map_repository_spec.rb
 - spec/lib/schron/identity_map_spec.rb
 - spec/lib/schron/paginaged_results_spec.rb
 - spec/lib/schron/query_spec.rb
@@ -185,7 +190,9 @@ test_files:
 - spec/lib/schron/datastore/memory_spec.rb
 - spec/lib/schron/datastore/mongo_spec.rb
 - spec/lib/schron/datastore/sequel_spec.rb
+- spec/lib/schron/db_spec.rb
 - spec/lib/schron/dsl_spec.rb
+- spec/lib/schron/identity_map_repository_spec.rb
 - spec/lib/schron/identity_map_spec.rb
 - spec/lib/schron/paginaged_results_spec.rb
 - spec/lib/schron/query_spec.rb