schron 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8e1d0962975ce0ce8d619f4e757b60cdf631e82
-  data.tar.gz: 36477336e2e1a6c356cd4ba95430eb61e3d91947
+  metadata.gz: 7769c035395e049f20cbede7cda51f0b39c8ed28
+  data.tar.gz: 6eacb27127b5d4770d36dd17692697b1bd39d93e
 SHA512:
-  metadata.gz: f691c4bf156243994fa5ca0d0e3532b88f9dfc26442a51e56036d0cec8bd11558a1789bc00a573d0f5e2c93030505da18784c82663d4f7b0c7fdd6bb04abf294
-  data.tar.gz: 33fca3e587a68959a994bd584883426c5169340c2054b325b5a610f307408e6378c3601d8b659aa5f483b1b03e61e3fbd9ec31c05b28b19e2f7c189ab6771e48
+  metadata.gz: e2f2c532a880389220906e087c45772d8430159ff4b102c33aa770793ba1c0e52e7db0714cfb6e3833c3a463e9aa3b273950d362d1e490b58d5600565280fe62
+  data.tar.gz: a3becfbd86f34a23e6a5d3038f35df103ce72cadb31753fbacae795574644987488a9fd8c83693a92fc458f2bc04a78dfc344e116a857ceeee283408b40babca

data/lib/schron/archive.rb

@@ -25,14 +25,15 @@ module Schron
     end
 
     def query(&block)
-      load_all(Query.new(@kind, @datastore, &block).all)
+      Query.new(self, &block)
     end
     
-    def first(&block)
-      query do |q|
-        yield q if block_given?
-        q.limit(1)
-      end.first
+    def all
+      query.all
+    end
+    
+    def first
+      query.first
     end
     
     def get(id)

data/lib/schron/datastore/interface.rb

@@ -50,7 +50,7 @@ module Schron
       def protect_reset
         unless ENV['SCHRON_RESET']
           raise Schron::OperationDisabledError,
-            "Can not reset datastore with setting ENV['SCHRON_RESET'] to 1"
+            "Can not reset datastore without setting ENV['SCHRON_RESET'] to 1"
         end
         yield
       end

data/lib/schron/datastore/memory.rb

@@ -10,13 +10,17 @@ module Schron
         @data = {}
       end
 
-      def exec_query(kind, query)
-        results = data_for_kind(kind).values
+      def exec_query(query)
+        results = data_for_kind(query.kind).values
         results = apply_filters(query, results)
         results = apply_sorts(query, results)
         apply_limit_offset(query, results) || []
       end
       
+      def exec_count(query)
+        exec_query(query).count
+      end
+      
       def multi_get(kind, ids)
         ids.map { |id| get_data(kind, id) }.compact
       end

data/lib/schron/datastore/mongo.rb

@@ -6,15 +6,19 @@ require 'schron/datastore/serializer'
 
 module Schron
   module Datastore
+    class EmptyQueryError < StandardError
+    end
     class Mongo
       include Schron::Datastore::Interface
       
+      attr_reader :db
+
       def initialize(db)
         @db = db
       end
       
       def get(kind, id)
-        doc = coll(kind).find(id_selector(id)).first
+        doc = coll(kind).find_one(id_selector(id))
         doc ?
           unserialize(kind, doc) :
           nil
@@ -65,11 +69,22 @@ module Schron
         nil
       end
       
-      def exec_query(kind, query)
+      def exec_query(query)
         selector = selector_for(query)
         query_opts = query_opts_for(query)
-        docs = coll(kind).find(selector, query_opts)
-        docs.map{ |d| unserialize(kind, d) }
+        docs = coll(query.kind).find(selector, query_opts)
+        docs.map{ |d| unserialize(query.kind, d) }
+      rescue EmptyQueryError
+        []
+      end
+      
+      def exec_count(query)
+        query_selector = selector_for(query)
+        query_opts = query_opts_for(query)
+        query_opts.delete(:sort)
+        coll(query.kind).count(query_opts.merge(query: query_selector))
+      rescue EmptyQueryError
+        0
       end
 
       def reset!
@@ -133,6 +148,7 @@ module Schron
           when '!='
             selector[mongo_field] = { "$ne" => filter_value }
           when 'in'
+            raise EmptyQueryError if filter_value.to_a.empty?
             selector[mongo_field] = { "$in" => filter_value.to_a }
           when '>'
             selector[mongo_field] = { "$gt" => filter_value }

data/lib/schron/datastore/sequel.rb

@@ -16,12 +16,12 @@ module Schron
         @db = db
       end
 
-      def exec_query(kind, query)
-        dataset = @db[kind]
-        dataset = apply_filters(query, dataset)
-        dataset = apply_sorts(query, dataset)
-        dataset = apply_limit_and_offset(query, dataset)
-        dataset.all
+      def exec_query(query)
+        dataset_for_query(query).all
+      end
+      
+      def exec_count(query)
+        dataset_for_query(query).count
       end
 
       def multi_get(kind, ids)
@@ -94,6 +94,15 @@ module Schron
         hashes.map { |h| unserialize(kind, h) }
       end
       
+      
+      def dataset_for_query(query)
+        dataset = @db[query.kind]
+        dataset = apply_filters(query, dataset)
+        dataset = apply_sorts(query, dataset)
+        dataset = apply_limit_and_offset(query, dataset)
+        dataset
+      end
+
       def apply_filters(query, data)
         final = query.filters.reduce(data) do |data, (name, op, value)|
           case op

data/lib/schron/datastore/serializer.rb

@@ -1,6 +1,7 @@
 require 'json'
 require 'time'
 require 'set'
+require 'bigdecimal'
 require 'schron/util'
 module Schron
   module Datastore
@@ -33,7 +34,7 @@ module Schron
         when Array, Set
           value.map { |v| serialize_value(v) }.to_a
         when Date, DateTime, Time
-          value.to_datetime.iso8601(9)
+          value.to_time.utc
         when BigDecimal
           value.to_f
         else

data/lib/schron/generic_archive.rb

@@ -0,0 +1,10 @@
+require 'schron/archive'
+require 'schron/generic_entity'
+
+module Schron
+  class GenericArchive
+    include Schron::Archive
+    
+    entity_class GenericEntity
+  end
+end

data/lib/schron/generic_entity.rb

@@ -0,0 +1,18 @@
+module Schron
+  class GenericEntity
+
+    attr_reader :attributes
+
+    def initialize(attrs={})
+      @attributes = attrs
+    end
+
+    def method_missing(method, *args)
+      if args.empty? && @attributes.key?(method)
+        @attributes[method]
+      else
+        super
+      end
+    end
+  end
+end

data/lib/schron/query.rb

@@ -6,16 +6,23 @@ module Schron
   class Query
     attr_reader :filters
     attr_reader :sorts
-    attr_reader :kind
+    attr_reader :archive
 
-    def initialize(kind=nil, datastore=nil &block)
-      @kind = kind
-      @datastore = datastore
+    def initialize(archive=nil, &block)
+      @archive = archive
       @filters = []
       @sorts = []
       @page = false
       yield self if block_given?
     end
+    
+    def kind
+      archive.kind
+    end
+    
+    def datastore
+      archive.datastore
+    end
 
 
     ##
@@ -64,15 +71,21 @@ module Schron
     ## Query Terminators
     
     def all
-      with_pagination(@datastore.exec_query(@kind, self))
+      raw_results = datastore.exec_query(self)
+      loaded_results = archive.load_all(raw_results)
+      with_pagination(loaded_results)
     end
     
     def first
       limit(1).all.first
     end
     
+    def count
+      datastore.exec_count(self)
+    end
+    
     def exists?
-      !all.empty?
+      count > 0
     end
     
     

data/lib/schron/test/archive_examples.rb

@@ -19,7 +19,7 @@ if defined?(RSpec)
           expect(archive.datastore).to receive(:exec_query).and_call_original
           results = archive.query do |q|
             expect(q.kind).to eq(archive.kind)
-          end
+          end.all
           expect_same_entity results.first, entity
         end
       end

data/lib/schron/test/datastore_examples.rb

@@ -1,6 +1,7 @@
 if defined?(RSpec)
 
   require 'schron/query'
+  require 'schron/generic_archive'
   shared_examples 'schron datastore' do
     let(:entity_kind) { :entities }
     let(:named_kind) { :named }
@@ -169,8 +170,10 @@ if defined?(RSpec)
       end
 
       describe 'exec query' do
-        let(:query) { Schron::Query.new(named_kind, ds) }
-        let(:no_result_query) { Schron::Query.new(entity_kind, ds) }
+        let(:named_kind_archive) { Schron::GenericArchive.new(ds, kind: named_kind) }
+        let(:query) { Schron::Query.new(named_kind_archive) }
+        let(:entity_kind_archive) { Schron::GenericArchive.new(ds, kind: entity_kind) }
+        let(:no_result_query) { Schron::Query.new(entity_kind_archive) }
         
         before(:each) do
           @c = ds.insert(named_kind, name: 'c')
@@ -182,140 +185,291 @@ if defined?(RSpec)
         
         describe 'filters' do
           it 'filters by equality with a hash' do
-            found = query.filter(name: 'b').all
+            found = ds.exec_query(query.filter(name: 'b'))
             expect(found.size).to eq(1)
             expect(found.first[:id]).to eq(@b[:id])
           end
           
           it 'filters by inclusion with a hash' do
-            found = query.filter(name: ['b', 'c']).all
+            found = ds.exec_query(query.filter(name: ['b', 'c']))
             expect(found.size).to eq(2)
             expect(found.map{ |h| h[:id] }).to include(@b[:id], @c[:id])
           end
           
           it 'filters by "=" operator' do
-            found = query.filter(:name, '=', 'b').all
+            found = ds.exec_query(query.filter(:name, '=', 'b'))
             expect(found.size).to eq(1)
             expect(found.first[:id]).to eq(@b[:id])
           end
 
           it 'filters by "in" operator' do
-            found = query.filter(:name, 'in', ['a', 'b']).all
+            found = ds.exec_query(query.filter(:name, 'in', ['a', 'b']))
             expect(found.size).to eq(3)
             expect(found.map{ |h| h[:id] }).to include(@a1[:id], @a2[:id], @b[:id])
           end
           
           it 'filters by ">" operator' do
-            found = query.filter(:name, '>', 'a').all
+            found = ds.exec_query(query.filter(:name, '>', 'a'))
             expect(found.size).to be(2)
             expect(found.map{ |h| h[:id] }).to include(@b[:id], @c[:id])
           end
 
           it 'filters by ">=" operator' do
-            found = query.filter(:name, '>=', 'a').all
+            found = ds.exec_query(query.filter(:name, '>=', 'a'))
             expect(found.size).to be(4)
             expect(found.map{ |h| h[:id] }).to include(@a1[:id], @a2[:id], @b[:id], @c[:id])
           end
 
           it 'filters by "<" operator' do
-            found = query.filter(:name, '<', 'b').all
+            found = ds.exec_query(query.filter(:name, '<', 'b'))
             expect(found.size).to be(2)
             expect(found.map{ |h| h[:id] }).to include(@a1[:id], @a2[:id])
           end
 
           it 'filters by "<=" operator' do
-            found = query.filter(:name, '<=', 'b').all
+            found = ds.exec_query(query.filter(:name, '<=', 'b'))
             expect(found.size).to be(3)
             expect(found.map{ |h| h[:id] }).to include(@a1[:id], @a2[:id], @b[:id])
           end
           
           it 'filters by "!=" operator' do
-            found = query.filter(:name, '!=', 'a').all
+            found = ds.exec_query(query.filter(:name, '!=', 'a'))
             expect(found.size).to eq(3)
             expect(found.map{ |h| h[:id] }).to include(@c[:id], @b[:id], @nil[:id])
           end
 
           it 'returns an empty list if no results match' do
-            expect(query.filter(name: '123').all).to eq([])
+            expect(ds.exec_query(query.filter(name: '123'))).to eq([])
           end
 
           context 'nil filtering' do
             it 'filters by = nil' do
-              found = query.filter(name: nil).all
+              found = ds.exec_query(query.filter(name: nil))
               expect(found.size).to eq(1)
               expect(found.first[:id]).to eq(@nil[:id])
             end
             
             it 'filters by != nil' do
-              found = query.filter(:name, '!=', nil).all
+              found = ds.exec_query(query.filter(:name, '!=', nil))
               expect(found.size).to eq(4)
               expect(found.map{ |h| h[:id] }).to include(@a1[:id], @a2[:id], @b[:id], @c[:id])
             end
             
             it 'filters by in with nil' do
-              found = query.filter(:name, 'in', [nil, 'b']).all
+              found = ds.exec_query(query.filter(:name, 'in', [nil, 'b']))
               expect(found.size).to eq(2)
               expect(found.map{ |h| h[:id] }).to include(@b[:id], @nil[:id])
             end
+            
+            it 'filters by in with an empty list' do
+              found = ds.exec_query(query.filter(:name, 'in', []))
+              expect(found.size).to be(0)
+            end
           end
         end
 
         describe 'limit' do
           it 'limits the results' do
-            found = query.limit(1).all
+            found = ds.exec_query(query.limit(1))
             expect(found.size).to eq(1)
           end
           
           it 'returns an empty list if no results match' do
             q = no_result_query
-            expect(q.limit(2).all).to eq([])
+            expect(ds.exec_query(q.limit(2))).to eq([])
           end
         end
         
         describe 'offset' do
           it 'offsets the results' do
             all = 4.times.reduce([]) do |ary, i|
-              ary + query.limit(1).offset(i).all
+              ary + ds.exec_query(query.limit(1).offset(i))
             end
             all_ids = all.map { |h| h[:id] }
             expect(all_ids).to include(@a1[:id], @a2[:id], @b[:id], @c[:id])
           end
           
           it 'returns an empty list if no results match' do
-            expect(query.offset(10).all).to eq([])
+            expect(ds.exec_query(query.offset(10))).to eq([])
           end
         end
 
         describe 'sorts' do
           it 'sorts in asc direction by default' do
-            found = query.sort(:name).all
+            found = ds.exec_query(query.sort(:name))
             expect(found.map{ |h| h[:name] }).to eq(
               [nil, 'a', 'a', 'b', 'c']
             )
           end
           
           it 'sorts ascending' do
-            found = query.sort(:name, :asc).all
+            found = ds.exec_query(query.sort(:name, :asc))
             expect(found.map{ |h| h[:name] }).to eq([nil, 'a', 'a', 'b', 'c'])
           end
           
           it 'sorts descending' do
-            found = query.sort(:name, :desc).all
+            found = ds.exec_query(query.sort(:name, :desc))
             expect(found.map { |h| h[:name] }).to eq(['c', 'b', 'a', 'a', nil])
           end
           
           it 'sorts by multiple fields' do
-            found = query.sort(:name).sort(:id).all
+            found = ds.exec_query(query.sort(:name).sort(:id))
             expected = [@nil[:id]] + [@a1[:id], @a2[:id]].sort + [@b[:id], @c[:id]]
             expect(found.map { |h| h[:id] }).to eq(expected)
           end
 
           it 'returns an empty list if no results match' do
-            expect(no_result_query.sort(:id).all).to eq([])
+            expect(ds.exec_query(no_result_query.sort(:id))).to eq([])
           end
         end
 
       end
+
+      describe 'exec count' do
+        let(:named_kind_archive) { Schron::GenericArchive.new(ds, kind: named_kind) }
+        let(:query) { Schron::Query.new(named_kind_archive) }
+        let(:entity_kind_archive) { Schron::GenericArchive.new(ds, kind: entity_kind) }
+        let(:no_result_query) { Schron::Query.new(entity_kind_archive) }
+        
+        before(:each) do
+          @c = ds.insert(named_kind, name: 'c')
+          @a1 = ds.insert(named_kind, name: 'a')
+          @b = ds.insert(named_kind, name: 'b')
+          @a2 = ds.insert(named_kind, name: 'a')
+          @nil = ds.insert(named_kind, {name: nil})
+        end
+        
+        describe 'filters' do
+          it 'filters by equality with a hash' do
+            found = ds.exec_count(query.filter(name: 'b'))
+            expect(found).to eq(1)
+          end
+          
+          it 'filters by inclusion with a hash' do
+            found = ds.exec_count(query.filter(name: ['b', 'c']))
+            expect(found).to eq(2)
+          end
+          
+          it 'filters by "=" operator' do
+            found = ds.exec_count(query.filter(:name, '=', 'b'))
+            expect(found).to eq(1)
+          end
+
+          it 'filters by "in" operator' do
+            found = ds.exec_count(query.filter(:name, 'in', ['a', 'b']))
+            expect(found).to eq(3)
+          end
+          
+          it 'filters by ">" operator' do
+            found = ds.exec_count(query.filter(:name, '>', 'a'))
+            expect(found).to be(2)
+          end
+
+          it 'filters by ">=" operator' do
+            found = ds.exec_count(query.filter(:name, '>=', 'a'))
+            expect(found).to be(4)
+          end
+
+          it 'filters by "<" operator' do
+            found = ds.exec_count(query.filter(:name, '<', 'b'))
+            expect(found).to be(2)
+          end
+
+          it 'filters by "<=" operator' do
+            found = ds.exec_count(query.filter(:name, '<=', 'b'))
+            expect(found).to be(3)
+          end
+          
+          it 'filters by "!=" operator' do
+            found = ds.exec_count(query.filter(:name, '!=', 'a'))
+            expect(found).to eq(3)
+          end
+
+          it 'returns 0 if no results match' do
+            expect(ds.exec_count(query.filter(name: '123'))).to eq(0)
+          end
+
+          context 'nil filtering' do
+            it 'filters by = nil' do
+              found = ds.exec_count(query.filter(name: nil))
+              expect(found).to eq(1)
+            end
+            
+            it 'filters by != nil' do
+              found = ds.exec_count(query.filter(:name, '!=', nil))
+              expect(found).to eq(4)
+            end
+            
+            it 'filters by in with nil' do
+              found = ds.exec_count(query.filter(:name, 'in', [nil, 'b']))
+              expect(found).to eq(2)
+            end
+            
+            it 'filters by in with an empty list' do
+              found = ds.exec_count(query.filter(:name, 'in', []))
+              expect(found).to be(0)
+            end
+          end
+        end
+
+        describe 'limit' do
+          it 'limits the results' do
+            found = ds.exec_count(query.limit(1))
+            expect(found).to eq(1)
+          end
+          
+          it 'returns an empty list if no results match' do
+            q = no_result_query
+            expect(ds.exec_count(q.limit(2))).to eq(0)
+          end
+        end
+        
+        describe 'offset' do
+          it 'offsets the results' do
+            4.times do |i|
+              found = ds.exec_count(query.limit(1).offset(i))
+              expect(found).to eq(1)
+            end
+          end
+          
+          it 'returns an empty list if no results match' do
+            expect(ds.exec_count(query.offset(10))).to eq(0)
+          end
+        end
+
+        describe 'sorts' do
+          it 'sorts in asc direction by default' do
+            found = ds.exec_count(query.sort(:name))
+            expect(found).to eq(5)
+          end
+          
+          it 'sorts ascending' do
+            found = ds.exec_count(query.sort(:name, :asc))
+            expect(found).to eq(5)
+            # expect(found.map{ |h| h[:name] }).to eq([nil, 'a', 'a', 'b', 'c'])
+          end
+          
+          it 'sorts descending' do
+            found = ds.exec_count(query.sort(:name, :desc))
+            expect(found).to eq(5)
+            # expect(found.map { |h| h[:name] }).to eq(['c', 'b', 'a', 'a', nil])
+          end
+          
+          it 'sorts by multiple fields' do
+            found = ds.exec_count(query.sort(:name).sort(:id))
+            expect(found).to eq(5)
+            # expected = [@nil[:id]] + [@a1[:id], @a2[:id]].sort + [@b[:id], @c[:id]]
+            # expect(found.map { |h| h[:id] }).to eq(expected)
+          end
+
+          it 'returns an empty list if no results match' do
+            # expect(ds.exec_count(no_result_query.sort(:id))).to eq([])
+            expect(ds.exec_count(no_result_query.sort(:id))).to eq(0)
+          end
+        end
+        
+      end
+
     end
 
     describe 'datastore type handling' do

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.2"
+  spec.version       = "0.0.3"
   spec.authors       = ["David Faber"]
   spec.email         = ["david@1bios.co"]
   spec.summary       = %q{Repository implementation for entity persistence}

data/spec/lib/schron/query_spec.rb

@@ -1,10 +1,12 @@
 require 'spec_helper'
 require 'schron/query'
+require 'schron/generic_archive'
 require 'schron/datastore/memory'
 
 describe Schron::Query do
-  subject(:query) { described_class.new(kind, ds) }
+  subject(:query) { described_class.new(archive) }
   
+  let(:archive) { Schron::GenericArchive.new(ds, kind: kind) }
   let(:kind) { 'tests' }
   let(:ds) { Schron::Datastore::Memory.new }
   
@@ -43,4 +45,21 @@ describe Schron::Query do
       end
     end
   end
+
+  describe 'all' do
+    it 'executes the query and returns all results' do
+      expect(ds).to receive(:exec_query).with(query).and_return('raw results')
+      expect(archive).to receive(:load_all).with('raw results').and_return('loaded results')
+      expect(query.all).to eq('loaded results')
+    end
+  end
+  
+  describe 'first' do
+    it 'sets the limit to 1, executes the query, and returns just the first result' do
+      expect(query).to receive(:limit).with(1).and_call_original
+      expect(ds).to receive(:exec_query).with(query).and_return(['raw'])
+      expect(archive).to receive(:load).with('raw').and_return('loaded')
+      expect(query.first).to eq('loaded')
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: schron
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - David Faber
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-08 00:00:00.000000000 Z
+date: 2014-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -130,6 +130,8 @@ files:
 - lib/schron/datastore/serializer.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/paginated_results.rb