schron 0.0.2

data/lib/schron/test/entity.rb

@@ -0,0 +1,21 @@
+module Schron
+  module Test
+    class Entity
+
+      attr_reader :attributes
+      def initialize(attrs={})
+        @attributes = attrs
+      end
+
+      def id
+        attributes[:id]
+      end
+
+      def ==(entity)
+        entity.is_a?(self.class) && attributes == entity.attributes
+      end
+
+
+    end
+  end
+end

data/lib/schron/test/repository_examples.rb

@@ -0,0 +1,68 @@
+if defined?(RSpec)
+
+  require 'schron/query'
+
+  # Be sure to set the repo before inclusion:
+  # let(:repo) { ... }
+  shared_examples 'schron repository' do
+
+    let(:entity_class) { repo.entity_class }
+    
+    describe 'update' do
+      it 'returns the updated object' do
+        object = repo.insert(repo.entity_class.new)
+        object.attributes[:a] = 6
+
+        result = repo.update(object)
+
+        expect_same_entity result, repo.entity_class.new(id: object.id, a: 6)
+        expect_same_entity repo.get(result.id), result
+      end
+    end
+    
+    describe 'multi update' do
+      it 'returns the updated objects' do
+        objects = repo.multi_insert([repo.entity_class.new, repo.entity_class.new])
+        objects[0].attributes[:a] = 6
+        objects[1].attributes[:a] = 7
+
+        results = repo.multi_update(objects)
+
+        expect(results[0].attributes).to eq(id: objects[0].id, a: 6)
+        expect(results[1].attributes).to eq(id: objects[1].id, a: 7)
+        0.upto(1) do |i|
+          expect_same_entity repo.get(results[i].id), results[i]
+        end
+      end      
+    end
+
+    describe 'remove' do
+      it 'returns nil when no object is removed' do
+        expect(repo.remove('1234')).to be_nil
+      end
+
+      it 'returns nil when an object is removed' do
+        obj = repo.insert(repo.entity_class.new)
+        expect(repo.remove(obj.id)).to be_nil
+      end
+
+      it 'removes the object from the repository by id' do
+        obj = repo.insert(repo.entity_class.new)
+        repo.remove(obj.id)
+        expect(repo.get(obj.id)).to be_nil
+      end    
+    end
+    
+    describe 'multi remove' do
+      it 'removes the objects from the repository by id and returns nil' do
+        objects = repo.multi_insert([entity_class.new, entity_class.new])
+        ids = objects.map(&:id)
+        result = repo.multi_remove(ids)
+        expect(result).to be_nil
+        expect(repo.multi_get(ids)).to be_empty
+      end      
+    end
+
+  end
+  
+end

data/lib/schron/util.rb

@@ -0,0 +1,27 @@
+module Schron
+  module Util
+    module_function
+    
+    def symbolize_keys(obj)
+      case obj
+      when Hash
+        obj.reduce({}) do |symbolized, (k, v)|
+          symbolized[k.to_sym] = symbolize_keys(v)
+          symbolized
+        end
+      when Array
+        obj.map { |v| symbolize_keys(v) }
+      else
+        obj
+      end
+    end
+
+    def sorted_by_id_list(records, ids)
+      if ids.respond_to?(:index)
+        records.sort_by { |r| ids.index(r[:id]) }
+      else
+        records
+      end
+    end
+  end
+end

data/schron.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "schron"
+  spec.version       = "0.0.2"
+  spec.authors       = ["David Faber"]
+  spec.email         = ["david@1bios.co"]
+  spec.summary       = %q{Repository implementation for entity persistence}
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ["lib"]
+
+
+  spec.add_development_dependency 'rake', '~> 10.1.0'
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rspec", "~> 3.0.0.beta1"
+  spec.add_development_dependency 'sequel', '~> 4.9.0'
+  spec.add_development_dependency 'sqlite3', '~> 1.3.9'
+  spec.add_development_dependency 'mongo', '~> 1.10.0'
+  spec.add_development_dependency 'bson_ext', '~> 1.10.0'
+end

data/spec/lib/schron/archive_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'schron/archive'
+require 'schron/datastore/memory'
+
+describe Schron::Archive do
+  
+  subject(:archive) do
+    archive_class.new(ds,
+      kind: 'test',
+      entity_class: Schron::Test::Entity,
+      indexed_fields: [])
+  end
+  
+  let(:archive_class) do
+    Class.new do
+      include Schron::Archive
+    end
+  end
+  
+  let(:ds) do
+    Schron::Datastore::Memory.new
+  end
+  
+  include_examples 'schron archive'
+  
+end

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

@@ -0,0 +1,9 @@
+require 'spec_helper'
+require 'schron/datastore/memory'
+
+describe Schron::Datastore::Memory do
+  subject(:ds) { described_class.new }
+
+  include_examples 'schron datastore'
+
+end

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

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'schron/datastore/mongo'
+
+describe Schron::Datastore::Mongo do
+  let(:ds) { described_class.new(db) }
+
+  let(:db) { client[db_name] }
+
+  let(:db_name) { 'test' }
+
+  let(:client) { Mongo::MongoClient.new }
+  
+  before(:each) do
+    db.collections.each do |coll|
+      unless coll.name =~ /^system\./
+        coll.drop
+      end
+    end
+  end
+  
+  include_examples 'schron datastore'
+
+end

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

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'logger'
+require 'schron/datastore/sequel'
+
+describe Schron::Datastore::Sequel do
+  subject(:ds) { described_class.new(db) }
+
+  let(:db) { Sequel.sqlite(':memory:', logger: LOGGER) }
+  
+  
+  before(:each) do
+    db.create_table :entities do
+      String :id, primary_key: true
+    end
+    db.create_table :named do
+      String :id, primary_key: true
+      String :name
+    end
+    db.create_table :with_types do
+      String :id, primary_key: true
+      String :array
+      String :set
+      Date :date
+      Time :time
+      String :date_time
+      String :hash
+      String :children
+      Float :float
+      String :name
+    end
+  end
+  
+  after(:each) do
+    db.drop_table? :entities
+    db.drop_table? :named
+  end
+  
+  include_examples 'schron datastore'
+
+end

data/spec/lib/schron/dsl_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'schron/dsl'
+
+describe Schron::DSL do
+  let(:repo_class) do
+    Class.new do
+      extend Schron::DSL
+    end
+  end
+  
+
+  describe 'kind' do
+    it 'should set and get on the class' do
+      repo_class.kind 'testing'
+      expect(repo_class.kind).to eq('testing')
+    end
+
+    it 'should not be inherited by subclasses' do
+      repo_class.kind 'testing'
+      sub = Class.new(repo_class)
+      expect(sub.kind).to be_nil
+    end
+  end
+
+  describe 'entity class' do
+    it 'should set and get on the class' do
+      klass = Class.new
+      repo_class.entity_class klass
+      expect(repo_class.entity_class).to be(klass)
+    end
+  
+    it 'should not be inherited by subclasses' do
+      repo_class.entity_class(Object)
+      sub = Class.new(repo_class)
+      expect(sub.entity_class).to be_nil
+    end
+  end
+  
+  describe 'indexed fields' do
+    it 'sets one at a time with indexed_field, and gets with indexed_fields' do
+      repo_class.indexed_field :a
+      repo_class.indexed_field :b
+      expect(repo_class.indexed_fields).to eq([:a, :b])
+    end
+  end
+end

data/spec/lib/schron/identity_map_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'schron/identity_map'
+
+describe Schron::IdentityMap do
+  subject(:map) { described_class.new }
+  
+  let(:object) { Object.new }
+  
+  describe 'put and get' do
+    it 'shoudl return nil if no object exists with the id' do
+      expect(map.get(123)).to be_nil
+    end
+    it 'should put things in and take things out by id' do
+      map.put(1, object)
+      expect(map.get(1)).to be(object)
+    end
+  end
+  
+  describe 'fetch' do
+    it 'should return objects already in the map without calling the block' do
+      spy = double
+      expect(spy).not_to receive(:uh_oh)
+      map.put(1, object)
+      fetched = map.fetch(1) { double.uh_oh }
+      expect(fetched).to be(object)
+    end
+  end
+  
+  describe 'has?' do
+    it 'returns true if the map has an entry for the given key, else false' do
+      expect(map.has?(1)).to be(false)
+      map.put(1, object)
+      expect(map.has?(1)).to be(true)
+    end
+  end
+end

data/spec/lib/schron/paginaged_results_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'schron/paginated_results'
+
+describe Schron::PaginatedResults do
+  
+  let(:results) do
+    ary = described_class.new([1,2])
+    ary.paging.previous_page = 1
+    ary.paging.current_page = 2
+    ary.paging.next_page = 3
+    ary
+  end
+
+  describe 'closure of enumerable operations' do
+
+    def verify_paging(p)
+      expect(p.previous_page).to eq(1)
+      expect(p.current_page).to eq(2)
+      expect(p.next_page).to eq(3)
+    end
+
+    it 'persists its paging' do
+      p = results.map {|i| i}.paging
+      verify_paging(p)
+    end
+  end
+end

data/spec/lib/schron/query_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'schron/query'
+require 'schron/datastore/memory'
+
+describe Schron::Query do
+  subject(:query) { described_class.new(kind, ds) }
+  
+  let(:kind) { 'tests' }
+  let(:ds) { Schron::Datastore::Memory.new }
+  
+  describe 'page' do
+    it 'sets the limit and offset' do
+      query.page(3, per_page: 7)
+      expect(query.limit).to eq(7)
+      expect(query.offset).to eq(14)
+    end
+    
+    describe 'paginated result set' do
+      before(:each) do
+        10.times { ds.insert('tests', {}) }
+      end
+
+      it 'has the current page' do
+        results = query.page(3, per_page: 1).all
+        expect(results.paging.current_page).to eq(3)
+      end
+
+      it 'indicates next and previous page when present' do
+        query.page(2, per_page: 3)
+        results = query.all
+        expect(results.paging.previous_page).to eq(1)
+        expect(results.paging.next_page).to eq(3)
+      end
+      
+      it 'shows previous page as nil on the first page' do
+        results = query.page(1).all
+        expect(results.paging.previous_page).to be_nil
+      end
+      
+      it 'shows next page as nil on last page' do
+        results = query.page(1, per_page: 10).all
+        expect(results.paging.next_page).to be_nil
+      end
+    end
+  end
+end

data/spec/lib/schron/repository_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'schron/repository'
+require 'schron/datastore/memory'
+
+describe Schron::Repository do
+  include Schron::Test
+  
+  subject(:repo) do
+    repo_class.new(ds,
+      entity_class: Schron::Test::Entity,
+      kind: 'tests')
+  end
+
+  let(:archive) { repo }
+  let(:ds) { Schron::Datastore::Memory.new }
+  
+  let(:repo_class) do
+    Class.new do
+      include Schron::Repository
+    end
+  end
+  
+  include_examples 'schron archive'
+  include_examples 'schron repository'
+  
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'logger'
+ENV['LOG_LEVEL'] ||= Logger::WARN.to_s
+
+LOGGER = Logger.new(STDOUT)
+LOGGER.level = ENV['LOG_LEVEL'].to_i
+
+require 'schron/test'
+
+Dir[File.join(__dir__, 'support', '**', '*.rb')].each { |f| require(f) }