document-store 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0af94c22aff4e1c04e680ca2f71a7cb26b26b379
+  data.tar.gz: 623a7699d80a76cedf3c8b54f915eb89a307be3f
+SHA512:
+  metadata.gz: c16170ccad0fd2c63132527452491ec41ac3849ac4f651f1cf09490fecbaa5e229df7c50987f2aa9c5229d0616fb6906ad66088ac745ed8327c082e23b8671c1
+  data.tar.gz: 39da60cd1bc23817aab499a8c10aaf0eb181c63ad58bafc9091a5a83722dc9fed4c509f37441740b9644d11296335ef4598ea3cf3bdfcd2120fd4f99da6af455

data/CHANGELOG.mdown

@@ -0,0 +1,11 @@
+
+# ChangeLog
+
+## 1.0.0
+
+* Change gem name to document-store
+
+## 0.2
+
+* Allow `slave_ok` for mongo connection
+* Change gem name to sc-store

data/Gemfile

@@ -0,0 +1,9 @@
+source :rubygems
+
+gem 'turn'
+gem 'shoulda'
+gem 'mocha'
+gem 'rake'
+gem 'em-minitest'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    document-store (1.0.0)
+      em-mongo (= 0.4.3)
+      em-synchrony
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.7)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    ansi (1.4.3)
+    bson (1.9.2)
+    em-minitest (1.0.1)
+    em-mongo (0.4.3)
+      bson (>= 1.1.3)
+      eventmachine (>= 0.12.10)
+    em-synchrony (1.0.3)
+      eventmachine (>= 1.0.0.beta.1)
+    eventmachine (1.0.3)
+    i18n (0.6.0)
+    metaclass (0.0.1)
+    mocha (0.14.0)
+      metaclass (~> 0.0.1)
+    multi_json (1.3.6)
+    rake (10.1.0)
+    shoulda (3.1.1)
+      shoulda-context (~> 1.0)
+      shoulda-matchers (~> 1.2)
+    shoulda-context (1.0.0)
+    shoulda-matchers (1.2.0)
+      activesupport (>= 3.0.0)
+    turn (0.9.6)
+      ansi
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  document-store!
+  em-minitest
+  mocha
+  rake
+  shoulda
+  turn

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+task :default => :test
+

data/app.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Mikael Wikman']
+  gem.email         = ['mikael@wikman.me']
+  gem.description   = %q{This wrapper provides a minimalistic interfaced to document-based databases. It includes a in-memory store that can be easily used for writing tests, as well as a in-memory cached version of each implementation.}
+  gem.summary       = %q{A wrapper around document-based databases to provide a minimalistic interface that can be easily changed}
+  gem.homepage      = "https://github.com/mikaelwikman/document-store"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|features)/})
+  gem.name          = "document-store"
+  gem.require_paths = ["lib"]
+  gem.version       = '1.0.0'
+  gem.add_dependency 'em-synchrony'
+  gem.add_dependency 'em-mongo', '0.4.3'
+end

data/lib/store/cache.rb

@@ -0,0 +1,98 @@
+require 'store/caches/in_memory'
+require 'store/caches/memcached'
+
+class Store
+  class Cache
+    attr_reader :backend
+    
+    def initialize backend_store, args={}
+      @backend = backend_store
+      if args[:memcached]
+        @cache = Caches::Memcached.new
+      else
+        @cache = Caches::InMemory.new
+      end
+    end
+
+    def timestamper= ts
+      backend.timestamper = ts
+    end
+
+    def timestamper
+      backend.timestamper
+    end
+
+    def close
+      @cache.invalidate
+      backend.close
+    end
+
+    def create *args
+      @cache.invalidate
+      backend.create *args
+    end
+
+    def update *args
+      @cache.invalidate
+      backend.update *args
+    end
+
+    def all table
+      each(table).map{|i|i}
+    end
+
+    def count table
+      backend.count(table)
+    end
+
+    def each table
+      if data=@cache.load(table)
+        data
+      else
+        data = backend.all(table)
+        @cache.save table, data
+        data
+      end
+    end
+
+    def reset *args
+      @cache.invalidate
+      backend.reset(*args)
+    end
+
+    def find *args
+      key = Marshal.dump(args)
+      if data=@cache.load(key)
+        data
+      else
+        data = backend.find(*args)
+        @cache.save key, data
+        data
+      end
+    end
+
+    def collate *args
+      key = Marshal.dump(args)
+      if data=@cache.load(key)
+        data
+      else
+        data = backend.collate(*args)
+        @cache.save(key,data)
+        data
+      end
+    end
+
+    def create_equal_filter *args
+      backend.create_equal_filter(*args)
+    end
+    def create_lt_filter *args
+      backend.create_lt_filter(*args)
+    end
+    def create_gt_filter *args
+      backend.create_gt_filter(*args)
+    end
+    def create_gte_filter *args
+      backend.create_gte_filter(*args)
+    end
+  end
+end

data/lib/store/caches/in_memory.rb

@@ -0,0 +1,23 @@
+
+module Caches
+  class InMemory
+    def initialize
+      @cache = {}
+    end
+
+    def invalidate
+      @cache = {}
+    end
+
+    def load(key)
+      data = @cache[key]
+      if data
+        Marshal.load(data)
+      end
+    end
+
+    def save key, data
+      @cache[key] = Marshal.dump(data)
+    end
+  end
+end

data/lib/store/caches/memcached.rb

@@ -0,0 +1,73 @@
+#
+# THIS IS UNTESTED, AND UNUSED, DON'T USE!!
+#
+
+require 'em-synchrony/em-memcache'
+
+module Caches
+  class Memcached
+    @@max_size = 1000000
+    def initialize
+      @cache = EM::P::Memcache.connect
+    end
+
+    def invalidate
+      set 'invalidated_at', Time.new
+    end
+
+    def load(key)
+      key_date = "#{key}_date"
+
+      time_set = get(key_date) 
+      invalidated_at = get('invalidated_at')
+
+      if time_set && (!invalidated_at || time_set > invalidated_at)
+        data = get(key)
+        data
+      end
+    end
+
+    def save key, data
+      key_date = "#{key}_date"
+
+      set(key, data)
+      set(key_date, Time.new)
+    end
+
+    private
+
+    def clean! key
+      key.gsub! /[^a-zA-Z_]/, ''
+    end
+
+    def get key
+      clean!(key)
+      data = ""
+      i = 0
+      puts "READ #{key}_#{i}"
+      while new_data=@cache.get("#{key}_#{i}")
+        data << new_data
+        puts "Got #{new_data.length} characters"
+        i+=1
+        puts "READ #{key}_#{i}"
+      end
+      if data.length > 0 
+        Marshal.load(data)
+      end
+    end
+
+    def set key, data
+      clean!(key)
+      data = Marshal.dump(data)
+      i = 0
+      while i*@@max_size < data.length
+        tkey = "#{key}_#{i}"
+        minidata = data[i*@@max_size, @@max_size]
+        puts "Write #{tkey}, block of #{minidata.length}"
+        @cache.set(tkey, minidata)
+
+        i+=1
+      end
+    end
+  end
+end

data/lib/store/memory.rb

@@ -0,0 +1,269 @@
+class Store
+  class Memory
+    attr_writer :timestamper
+    def timestamper
+      @timestamper || lambda {Time.new}
+    end
+
+    def initialize database_name
+      @collections = {}
+      @id = 0
+    end
+
+    def create table, entry
+      if !entry['_id']
+        entry['_id'] = @id += 1
+      end
+      entry.keys.each do |k|
+        entry[k.to_s] = entry.delete(k)
+      end
+      entry['updated_at'] = entry['created_at'] = timestamper.call
+      collection(table)[entry['_id']] = entry
+      entry['_id']
+    end
+
+    def all table
+      collection(table).values
+    end
+
+    def count table
+      collection(table).count
+    end
+
+    def each table, &block
+      collection(table).values.each &block
+    end
+
+    def reset table
+      @collections.delete(table)
+    end
+
+    def find table, filters, opts={}
+      values = collection(table).values
+
+      filters.each do |filter|
+        values = filter.filter(values)
+      end
+
+      if opts[:sort]
+        fields = opts[:sort].split(',')
+        fields.map! do |field|
+          sort = field.split('=')
+          [sort[0], (sort[1] || 1).to_i]
+        end
+
+        values.sort! do |e1,e2| 
+          order = 0
+
+          fields.each do |field|
+            name = field[0]
+            asc = field[1]
+            f1 = e1[name]
+            f2 = e2[name]
+
+            f1 = 1 if f1 == true
+            f1 = 0 if f1 == false
+            f2 = 1 if f2 == true
+            f2 = 0 if f2 == false
+
+            order = asc * ((f1 <=> f2) || 0)
+            break if order != 0
+          end
+
+          order
+        end
+      end
+
+      if opts[:start]
+        opts[:start].times do |i|
+          values.shift
+        end
+      end
+
+      if opts[:limit]
+        values.pop while values.count > opts[:limit]
+      end
+
+      values
+    end
+
+    def collate table, filters, opts={}
+      # need to get all items, or else we can't calculate facets
+      start = opts.delete(:start)
+      limit = opts.delete(:limit)
+      facetlimit = opts.delete(:facetlimit)
+
+      result = {
+        items: find(table, filters, opts)
+      }
+
+      if opts[:facets]
+        result[:facets] = calculate_facets(opts[:facets], result[:items])
+
+        if facetlimit
+          result[:facets].each do |k,v|
+            v.pop while v.count > facetlimit
+          end
+        end
+      end
+
+      result[:count] = result[:items].count
+
+      if start
+        start.times do |i|
+          result[:items].shift
+        end
+      end
+
+      if limit
+        result[:items].pop while result[:items].count > limit
+      end
+
+      result
+    end
+
+    def update table, id, entry
+      old_entry=nil
+
+      if id.kind_of?(Hash)
+        collection(table).each do |orig_k,orig_v|
+          if id.all?{|k,v| orig_v[k.to_s] == v}
+            old_entry = orig_v
+            id = orig_k
+            break;
+          end
+        end
+      else
+        old_entry = collection(table)[id]
+      end
+
+      if not old_entry
+        create table, entry
+        return entry
+      end
+
+      entry.keys.each do |key|
+        entry[key.to_s] = entry.delete(key)
+      end
+
+      entry = old_entry.merge(entry)
+      entry['updated_at'] = timestamper.call
+
+      collection(table)[id] = entry
+      entry
+    end
+
+    # filters
+    def create_equal_filter field, value
+      EqualFilter.new(field,value)
+    end
+    def create_lt_filter field, value
+      LTFilter.new(field,value)
+    end
+    def create_gt_filter field, value
+      GTFilter.new(field,value)
+    end
+    def create_gte_filter field, value
+      GTEFilter.new(field,value)
+    end
+
+    private 
+
+    def collection table
+      @collections[table] ||= {}
+    end
+
+    def calculate_facets facets, records
+      result = {}
+      facets.each do |facet| 
+        facet = facet.to_s
+        temp = {}
+
+        records.each do |record|
+          record_value = record[facet] || 'unknown'
+
+          r = record_value.kind_of?(Array) ? record_value : [record_value]
+
+          r.each do |value|
+            value = value.to_s
+            value = 'unknown' if value.strip == '' 
+
+            temp[value] ||= 0
+            temp[value] += 1
+          end
+        end
+
+        facet_entries = temp.map do |name, value|
+          [name.to_s, value]
+        end
+
+        facet_entries.sort! {|e1, e2| e2[1] <=> e1[1] }
+        result[facet.to_s] = facet_entries
+      end
+      result
+    end
+
+    class EqualFilter
+      def initialize field, value
+        @field = field.to_s
+        @value = value
+        @value = "" if value == 'unknown' || value == nil
+      end
+
+      def filter entries
+        entries.find_all do |entry|
+          value2 = entry[@field]
+          value2 = '' if value2 == nil
+          value2 == @value
+        end
+      end
+    end
+
+    class LTFilter
+      def initialize field, value
+        @field = field.to_s
+        @value = value
+        @value = "" if value == 'unknown' || value == nil
+      end
+
+      def filter entries
+        entries.find_all do |entry|
+          value2 = entry[@field]
+          value2 = '' if value2 == nil
+          value2 < @value
+        end
+      end
+    end
+
+    class GTFilter
+      def initialize field, value
+        @field = field.to_s
+        @value = value
+        @value = "" if value == 'unknown' || value == nil
+      end
+
+      def filter entries
+        entries.find_all do |entry|
+          value2 = entry[@field]
+          value2 = '' if value2 == nil
+          value2 > @value
+        end
+      end
+    end
+    class GTEFilter
+      def initialize field, value
+        @field = field.to_s
+        @value = value
+        @value = "" if value == 'unknown' || value == nil
+      end
+
+      def filter entries
+        entries.find_all do |entry|
+          value2 = entry[@field]
+          value2 = '' if value2 == nil
+          value2 >= @value
+        end
+      end
+    end
+  end
+end

data/lib/store/mongodb.rb

@@ -0,0 +1,284 @@
+require 'em-mongo'
+
+class Store
+  class Mongodb
+    attr_writer :timestamper
+    def timestamper
+      @timestamper ||= lambda { Time.new }
+    end
+
+    def initialize database_name
+      @database_name = database_name
+      @free_connections ||= []
+    end
+
+    def close
+      @db.close
+      @db=nil
+    end
+
+    def create table, entry
+      connect do |db|
+        entry['created_at'] = entry['updated_at'] = timestamper.call
+
+        resp = db.collection(table).safe_insert(entry)
+
+        f = Fiber.current
+        resp.callback{|doc| f.resume(doc)}
+        resp.errback{|err| f.resume(:err, err)}
+
+        result, error = Fiber.yield
+
+        if result == :err
+          raise error.inspect
+        else
+          result
+        end
+      end
+    end
+
+    def update table, id, entry
+      if entry.keys.any?{|key| key.kind_of?(Symbol) }
+        raise "MongoDb can't handle symbols, use only string keys!"
+      end
+      matcher = []
+      filter = id.kind_of?(Hash) ? id : { _id: id }
+
+      filter.each do |k,v|
+        matcher << create_equal_filter(k,v)
+      end
+
+      connect do |db|
+        old_entry = find(table, matcher).first
+
+        if old_entry
+          entry = old_entry.merge(entry)
+          entry['updated_at'] = timestamper.call
+
+          f = Fiber.current
+          resp = db.collection(table).safe_update(filter, entry)
+          resp.errback{|err| exit -1}
+          resp.callback{|doc| f.resume doc}
+          Fiber.yield
+          entry
+        else
+          id = create(table, entry)
+          find(table, matcher).first
+        end
+      end
+    end
+
+    def all table
+      find(table,{})
+    end
+
+    def count table
+      connect do |db|
+        resp = db.collection(table).count
+        f = Fiber.current
+        resp.callback {|count| f.resume count }
+        resp.errback {|err| raise err }
+
+        Fiber.yield
+      end
+    end
+
+    def reset table
+      connect do |db|
+        db.collection(table).remove()
+      end
+    end
+
+    def find table, filters, opts={}
+      real_filters = {}
+      filters.inject(real_filters) do |hash,f|
+        f.add_filter(hash)
+        hash
+      end
+
+      if opts[:sort]
+        fields = opts.delete(:sort).split(',')
+        opts[:sort] = []
+        fields.each do |field|
+          sort = field.split('=')
+          name = sort[0]
+          order = (sort[1] || '1') == '1' ? :asc : :desc
+          opts[:sort] << [name,order]
+        end
+      end
+
+      if opts[:start]
+        start = opts.delete(:start)
+        opts[:skip] = start
+      end
+
+      connect do |db|
+        f = Fiber.current
+        docs = []
+        resp = db.collection(table).find(real_filters, opts).each do |doc|
+          if doc
+            docs << doc
+          else
+            f.resume if f.alive?
+          end
+        end
+        Fiber.yield
+        docs
+      end
+    end
+
+    def collate table, filters, opts={}
+      # need to get all items, or else we can't calculate facets
+      start = opts.delete(:start)
+      limit = opts.delete(:limit)
+      facets = opts.delete(:facets)
+      facetlimit = opts.delete(:facetlimit)
+
+      result = {
+        items: find(table, filters, opts)
+      }
+
+      if facets
+        result[:facets] = calculate_facets(facets, result[:items])
+
+        if facetlimit
+          result[:facets].each do |k,v|
+            v.pop while v.count > facetlimit
+          end
+        end
+      end
+
+      result[:count] = result[:items].count
+
+      if start
+        start.times do |i|
+          result[:items].shift
+        end
+      end
+
+      if limit
+        result[:items].pop while result[:items].count > limit
+      end
+
+      result
+    end
+
+    # filter factories
+    def create_equal_filter field, name
+      EqualFilter.new(field, name)
+    end
+    def create_lt_filter field, name
+      LTFilter.new(field, name)
+    end
+    def create_gt_filter field, name
+      GTFilter.new(field, name)
+    end
+    def create_gte_filter field, name
+      GTEFilter.new(field, name)
+    end
+
+    private
+
+    def connect
+      # some simple connection pooling to avoid conflicts..
+
+      con = if @free_connections.length > 0
+        @free_connections.pop
+      else
+        EM::Mongo::Connection.new('localhost', 27017, nil, slave_ok: true).db(@database_name)
+      end
+
+      result = yield(con)
+      @free_connections << con
+      result
+    end
+
+    def calculate_facets facets, records
+      result = {}
+      facets.each do |facet| 
+        facet = facet.to_s
+        temp = {}
+
+        records.each do |record|
+          record_value = record[facet] || 'unknown'
+
+          r = record_value.kind_of?(Array) ? record_value : [record_value]
+
+          r.each do |value|
+            value = value.to_s
+            value = 'unknown' if value.strip == '' 
+
+            temp[value] ||= 0
+            temp[value] += 1
+          end
+        end
+
+        facet_entries = temp.map do |name, value|
+          [name.to_s, value]
+        end
+
+        facet_entries.sort! {|e1, e2| e2[1] <=> e1[1] }
+        result[facet] = facet_entries
+      end
+      result
+    end
+
+    class EqualFilter
+      def initialize(field, value)
+        @field = field; @value = value
+      end
+
+      def add_filter(hash)
+        if @value == 'unknown' 
+          hash[@field] = nil
+        elsif @value.kind_of?(BSON::ObjectId)
+          hash[@field] = @value
+        else
+          hash[@field] = @value
+        end
+      end
+    end
+
+    class LTFilter
+      def initialize(field, value)
+        @field = field; @value = value
+      end
+
+      def add_filter(hash)
+        h = hash[@field] ||= {}
+
+        if @value != 'unknown'
+          h['$lt'] = @value
+        end
+      end
+    end
+
+    class GTFilter
+      def initialize(field, value)
+        @field = field; @value = value
+      end
+
+      def add_filter(hash)
+        h = hash[@field] ||= {}
+
+        if @value != 'unknown'
+          h['$gt'] = @value
+        end
+      end
+    end
+
+    class GTEFilter
+      def initialize(field, value)
+        @field = field; @value = value
+      end
+
+      def add_filter(hash)
+        h = hash[@field] ||= {}
+
+        if @value != 'unknown'
+          h['$gte'] = @value
+        end
+      end
+    end
+  end
+end

data/test/store_test.rb

@@ -0,0 +1,346 @@
+require 'test_helper'
+require 'store/mongodb'
+require 'store/memory'
+require 'store/cache'
+require 'em-synchrony'
+
+# The cache store differs in initializer from the others, so we'll
+# create a fake one to initialize it properly
+class InMemoryCacheStore < Store::Cache
+  def initialize database
+    super(Store::Memory.new(database))
+  end
+end
+#class MemcachedStore < Store::Cache
+#  def initialize database
+#    super(Store::Memory.new(database), memcached: true)
+#  end
+#end
+
+[
+  Store::Mongodb,
+  Store::Memory,
+  InMemoryCacheStore
+].each do |store|
+  Class.new(TestCase).class_eval do 
+
+    should store.name+ ' use current Time as default time stamper' do
+      val = store.new('hubo').timestamper.call 
+      assert val.kind_of?(Time)
+    end
+
+    should store.name+ 'allow setting time stamper' do
+      s = store.new('hubo')
+      s.timestamper = lambda { 4 }
+      assert_equal 4, s.timestamper.call
+    end
+
+    context "Testing #{store.name}" do
+      setup do
+        @it = store.new('testDb')
+        @it.reset('test_table')
+        @it.reset('testosteron_table')
+        timestamp = 0
+        @it.timestamper = lambda { timestamp+=1 }
+      end
+
+      should '#count' do 
+        id = @it.create('test_table', { duck: 'monkey' })
+        id = @it.create('test_table', { duck: 'monkey' })
+        id = @it.create('testosteron_table', { duck: 'monkey' })
+
+        assert_equal 2, @it.count('test_table')
+      end
+
+      should '#all aggregate all results' do
+        id = @it.create('test_table', { duck: 'monkey' })
+
+        result = @it.all('test_table')
+
+        assert_equal 1, result.count
+        assert_equal 'monkey', result[0]['duck']
+      end
+
+      should "create and retrieve entry" do
+        id = @it.create('test_table', { duck: 'monkey' })
+
+        assert id.kind_of?(BSON::ObjectId) || id.to_i > 0
+
+        result = @it.all('test_table')
+        assert_equal 1, result.count
+        assert_equal 'monkey', result.first['duck']
+        assert_equal 1, result.first['created_at']
+      end
+
+      context '#update' do
+        should 'handle many concurrent updates' do
+          id = @it.create('test_table', { duck: 'monkey' })
+
+          100.times do
+            f = Fiber.new do
+              entry = { 'duck' => 'history' }
+              @it.update('test_table', id, entry)
+            end
+
+            EM.next_tick { f.resume }
+          end
+
+          EM::Synchrony.sleep(0.1)
+        end
+
+        should 'update given fields entry' do
+          id = @it.create('test_table', { duck: 'monkey' })
+
+          entry = { 'duck' => 'history' }
+
+          @it.update('test_table', id, entry)
+
+          entries = @it.all('test_table')
+
+          assert_equal 1, entries.count
+          assert_equal 'history', entries.first['duck']
+          assert_equal 2, entries.first['updated_at']
+        end
+
+        should 'update entry by matcher' do
+          @it.create('test_table', { duck: 'monkey' })
+          @it.create('test_table', { duck: 'donkey' })
+          @it.create('test_table', { duck: 'congo' })
+
+          @it.update('test_table', 
+                     { 'duck' => 'donkey'}, 
+                     { 'duck' => 'history'})
+
+          entries = @it.all('test_table')
+
+          assert_equal 3, entries.count
+          assert_equal 'monkey', entries[0]['duck']
+          assert_equal 'history', entries[1]['duck']
+          assert_equal 'congo', entries[2]['duck']
+        end
+
+        should 'update should create if not exist' do
+          r = @it.update('test_table', {'duck' => 'donkey'}, { 'duck' => 'donkey'})
+
+          entries = @it.all('test_table')
+          assert_equal 1, entries.count
+          assert_equal 'donkey', entries[0]['duck']
+          assert_equal 1, entries[0]['updated_at']
+          assert_equal 1, entries[0]['created_at']
+        end
+
+        should 'return the resulting entry while updating' do
+          id = @it.create('test_table', { duck: 'monkey', paid_taxes: true })
+          entry = @it.update('test_table', id, 'duck' => 'history')
+
+          assert_equal 'history', entry['duck']
+          assert_equal true, entry['paid_taxes']
+        end
+
+        should 'return the resulting entry after created' do
+          entry = @it.update('test_table', { 'duck' => 'history' }, 'duck' => 'history')
+
+          assert_equal 'history', entry['duck']
+          assert entry['_id'], 'ID should be set'
+        end
+
+        should 'make partial updates' do
+          entry = @it.create('test_table', { 'duck' => 'history', paid_taxes: true })
+          entry = @it.update('test_table', { 'duck' => 'history' }, 'duck' => 'monkey')
+
+          entries = @it.all('test_table')
+          assert_equal 1, entries.count
+          assert_equal 'monkey', entries[0]['duck']
+          assert_equal true, entries[0]['paid_taxes']
+        end
+      end
+
+      context '#find' do
+        setup do
+          @it.create('test_table', { 
+            duck: 'horse',
+            has_duck: true,
+            number: 1
+          })
+          @it.create('test_table', { 
+            duck: 'MoNkeY',
+            has_duck: true,
+            number: 2
+          })
+          @it.create('test_table', {
+            duck: 'donkey',
+            has_duck: true,
+            number: 3
+          })
+          @it.create('test_table', {
+            noduckie: 'here',
+            has_duck: false,
+            number: 4
+          })
+        end
+
+        should 'treat "unknown" as empty string as unexisting' do
+          @it.create('test_table', {
+            verify: true
+          })
+          filters = [@it.create_equal_filter(:duck, 'unknown')]
+          r = @it.find('test_table', filters)
+          assert_equal 2, r.count
+          assert_equal 'here', r[0]['noduckie']
+          assert_equal true, r[1]['verify']
+        end
+
+        should 'find entries case sensitive by filter' do
+          filters = [@it.create_equal_filter(:duck, 'monkey')]
+          result = @it.find('test_table', filters).map {|e| e}
+          assert_equal 0, result.count
+
+          filters = [@it.create_equal_filter(:duck, 'MoNkeY')]
+          result = @it.find('test_table', filters).map {|e| e}
+          assert_equal 1, result.count
+          assert_equal 'MoNkeY', result.first['duck']
+        end
+
+        context 'filters' do
+
+          should 'equal' do
+            filters = [@it.create_equal_filter(:has_duck, false)]
+            result = @it.find('test_table', filters).map {|e| e}
+            assert_equal 1, result.count
+            assert_equal 'here', result.first['noduckie']
+          end
+          
+          should 'less-than' do
+            filters = [@it.create_lt_filter(:number, 3)]
+            result = @it.find('test_table', filters).map {|e| e}
+            assert_equal 2, result.count
+            assert_equal 1, result[0]['number']
+            assert_equal 2, result[1]['number']
+          end
+
+          should 'greater-than' do
+            filters = [@it.create_gt_filter(:number, 3)]
+            result = @it.find('test_table', filters).map {|e| e}
+            assert_equal 1, result.count
+            assert_equal 4, result[0]['number']
+          end
+
+          should 'greater-or-equal' do
+            filters = [@it.create_gte_filter(:number, 3)]
+            result = @it.find('test_table', filters).map {|e| e}
+            assert_equal 2, result.count
+            assert_equal 3, result[0]['number']
+            assert_equal 4, result[1]['number']
+          end
+        end
+
+        should 'limit response size' do
+          result = @it.find('test_table', [], limit: 1).map{|i|i}
+          assert_equal 1, result.count
+        end
+
+        should 'set zero-based start index' do
+          result = @it.find('test_table', [], start: 2).map{|i|i}
+          assert_equal 2, result.count
+          assert_equal 'donkey', result[0]['duck']
+          assert_equal 'here', result[1]['noduckie']
+        end
+
+        should 'treat \'unknown\' as nil or empty' do
+          filters = [@it.create_equal_filter(:duck, 'unknown')]
+          result = @it.find('test_table', filters).map {|e| e}
+          assert_equal 1, result.count
+          assert_equal 'here', result.first['noduckie']
+        end
+
+        should 'sort asc' do
+          result = @it.find('test_table', [], sort: 'has_duck=-1,duck=1').map {|e| e}
+          assert_equal 4, result.count
+          assert_equal 'MoNkeY', result[0]['duck']
+          assert_equal 'donkey', result[1]['duck']
+          assert_equal 'horse', result[2]['duck']
+          assert_equal 'here', result[3]['noduckie']
+        end
+
+        should 'sort desc' do
+          result = @it.find('test_table', [], sort: 'has_duck=-1,duck=-1').map {|e| e}
+          assert_equal 4, result.count
+          assert_equal 'horse', result[0]['duck']
+          assert_equal 'donkey', result[1]['duck']
+          assert_equal 'MoNkeY', result[2]['duck']
+          assert_equal 'here', result[3]['noduckie']
+        end
+      end
+
+      context '#collate' do
+        setup do
+          @it.create('test_table', { duck: 1990 })
+          @it.create('test_table', { duck: nil })
+          @it.create('test_table', { duck: "" })
+          @it.create('test_table', { duck: 'monkey' })
+          @it.create('test_table', { duck: 'donkey' })
+          @it.create('test_table', { duck: 'donkey' })
+        end
+
+        should 'find entries by filter' do
+          filters = [@it.create_equal_filter(:duck, 'monkey')]
+          result = @it.collate('test_table', filters)
+          assert_equal 1, result[:items].count
+          assert_equal 'monkey', result[:items].first['duck']
+        end
+
+        should 'limit response size' do
+          result = @it.collate('test_table', [], limit: 1)
+          assert_equal 1, result[:items].count
+        end
+
+        should 'set zero-based start index' do
+          result = @it.collate('test_table', [], start: 3, limit: 2)
+          assert_equal 2, result[:items].count
+          assert_equal 'monkey', result[:items][0]['duck']
+          assert_equal 'donkey', result[:items][1]['duck']
+        end
+
+
+        context 'total count' do
+          should 'not be affected by limit' do
+            result = @it.collate('test_table', [], limit: 1)
+            assert_equal 6, result[:count]
+          end
+
+          should 'not be affected by start' do
+            result = @it.collate('test_table', [], start: 3)
+            assert_equal 6, result[:count]
+          end
+        end
+
+        should 'include facets if given' do
+          @it.create('test_table', { duck: ['donkey', 'muppet'] })
+
+          result = @it.collate('test_table', [], facets: [:duck])
+          assert_equal 7, result[:items].count
+          assert_equal 1, result[:facets].count
+
+          entries = result[:facets]['duck']
+          assert entries, "Expected facets to include 'duck'"
+          assert_equal 5, entries.count
+          assert_equal [
+            ['donkey'  , 3],
+            ['unknown' , 2],
+            ['monkey'  , 1],
+            ['1990'    , 1],
+            ['muppet'  , 1],
+          ], entries
+        end
+
+        should 'limit facet entries count, cutting lesser important' do
+          result = @it.collate('test_table', [], facets: [:duck], facetlimit: 2)
+          entries = result[:facets]['duck']
+          assert_equal 2, entries.count
+          assert_equal(['donkey', 2], entries[0])
+        end
+      end
+
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+require 'bundler/setup'
+require 'test/unit'
+require 'em-minitest'
+require 'turn/autorun'
+require 'shoulda'
+require 'mocha'
+
+#Turn.config.format = :dot
+
+$LOAD_PATH << 'lib'
+
+class TestCase < Test::Unit::TestCase
+end
+

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: document-store
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mikael Wikman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: em-synchrony
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: em-mongo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.3
+description: This wrapper provides a minimalistic interfaced to document-based databases.
+  It includes a in-memory store that can be easily used for writing tests, as well
+  as a in-memory cached version of each implementation.
+email:
+- mikael@wikman.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.mdown
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- app.gemspec
+- lib/store/cache.rb
+- lib/store/caches/in_memory.rb
+- lib/store/caches/memcached.rb
+- lib/store/memory.rb
+- lib/store/mongodb.rb
+- test/store_test.rb
+- test/test_helper.rb
+homepage: https://github.com/mikaelwikman/document-store
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: A wrapper around document-based databases to provide a minimalistic interface
+  that can be easily changed
+test_files:
+- test/store_test.rb
+- test/test_helper.rb