hikki 0.0.1

data/adapters/hikki-redis/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'hikki/adapters/redis_adapter'
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.filter_run_excluding :integration
+end

data/all_specs

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+rake
+rspec spec --tag integration
+cd adapters/hikki-redis
+rake
+rspec spec --tag integration
+cd ../hikki-mongo
+rake
+rspec spec --tag integration
+cd ../hikki-memcache
+rake
+rspec spec --tag integration

data/hikki.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hikki/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'hikki'
+  spec.version       = Hikki::VERSION
+  spec.authors       = ['alexpeachey']
+  spec.email         = ['alex.peachey@originate.com']
+  spec.summary       = 'A light weight persistence system.'
+  spec.description   = 'A light weight persistence system.'
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

data/lib/hikki.rb

@@ -0,0 +1,9 @@
+require 'hikki/version'
+require 'hikki/collection'
+require 'hikki/adapters/adapter'
+require 'hikki/adapters/memory_collection'
+require 'hikki/adapters/memory_adapter'
+require 'hikki/repository'
+
+module Hikki
+end

data/lib/hikki/adapters/adapter.rb

@@ -0,0 +1,43 @@
+module Hikki
+  module Adapters
+    class Adapter
+      attr_reader :collections
+
+      def initialize
+        @collections = {}
+      end
+
+      def index(collection, field)
+        collection_for(collection).index(field)
+      end
+
+      def save(collection, data)
+        collection_for(collection).save(data)
+      end
+
+      def find(collection, id)
+        collection_for(collection).find(id)
+      end
+
+      def all(collection, options={})
+        collection_for(collection).all(options)
+      end
+
+      def find_by(collection, field, value, options={})
+        collection_for(collection).find_by(field, value, options)
+      end
+
+      def remove(collection, id)
+        collection_for(collection).remove(id)
+      end
+
+      def remove_all(collection)
+        collection_for(collection).remove_all
+      end
+
+      def collection_for(collection)
+        collections.fetch(collection, Collection.new(collection, store, uuid_generator))
+      end
+    end
+  end
+end

data/lib/hikki/adapters/memory_adapter.rb

@@ -0,0 +1,18 @@
+module Hikki
+  module Adapters
+    class MemoryAdapter < Hikki::Adapters::Adapter
+      attr_reader :store, :uuid_generator, :collections
+
+      def initialize(uuid_generator=SecureRandom)
+        super()
+        @uuid_generator = uuid_generator
+        @store = {}
+        @collections = {}
+      end
+
+      def collection_for(collection)
+        collections.fetch(collection, MemoryCollection.new(collection, store, uuid_generator))
+      end
+    end
+  end
+end

data/lib/hikki/adapters/memory_collection.rb

@@ -0,0 +1,87 @@
+module Hikki
+  module Adapters
+    class MemoryCollection < Hikki::Collection
+      attr_reader :store, :uuid_generator
+
+      def initialize(collection, store, uuid_generator)
+        super(collection)
+        @store = store
+        @uuid_generator = uuid_generator
+      end
+
+      def index(field)
+        store[index_key] ||= {}
+        store[index_key][field.to_s] ||= {}
+        true
+      end
+
+      def save(data)
+        data = normalize_data(data)
+        store[collection] ||= {}
+        store[collection][data['id']] = data
+        add_to_index(data)
+        data
+      end
+
+      def find(id)
+        store.fetch(collection, {}).fetch(id.to_s, {})
+      end
+
+      def all(options={})
+        options = normalize_options(options)
+        store.fetch(collection, {}).values[page_range(options)]
+      end
+
+      def find_by(field, value, options={})
+        options = normalize_options(options)
+        return find_by_index(field, value, options) if has_index?(field)
+        all.select { |o| o.fetch(field.to_s) == value }[page_range(options)]
+      end
+
+      def remove(id)
+        remove_from_index(find(id))
+        store.fetch(collection, {}).delete(id.to_s)
+        true
+      end
+
+      def remove_all
+        store.delete(collection)
+        store.delete(index_key)
+        true
+      end
+
+      def has_index?(field)
+        store.has_key?(index_key) &&
+        store[index_key].has_key?(field.to_s)
+      end
+
+      def id_for(data)
+        data.fetch('id', uuid_generator.uuid).to_s
+      end
+
+      private
+      def index_key
+        collection + '_index'
+      end
+
+      def find_by_index(field, value, options)
+        store[index_key][field.to_s].fetch(value, []).map { |id| find(id) }.reject { |v| v == {} }[page_range(options)]
+      end
+
+      def add_to_index(data)
+        store.fetch(index_key, {}).keys.each do |field|
+          store[index_key][field][data[field]] ||= []
+          store[index_key][field][data[field]] << data['id']
+        end
+      end
+
+      def remove_from_index(data)
+        return if data == {}
+        store.fetch(index_key, {}).keys.each do |field|
+          store[index_key][field].fetch(data[field], []).delete(data['id'])
+        end
+      end
+
+    end
+  end
+end

data/lib/hikki/collection.rb

@@ -0,0 +1,62 @@
+require 'json'
+
+module Hikki
+  class Collection
+    attr_reader :collection
+
+    def initialize(collection)
+      @collection = collection.to_s
+    end
+
+    def index(field)
+      raise 'Implementation missing.'
+    end
+
+    def save(data)
+      raise 'Implementation missing.'
+    end
+
+    def find(id)
+      raise 'Implementation missing.'
+    end
+
+    def all(options)
+      raise 'Implementation missing.'
+    end
+
+    def find_by(field, value, options)
+      raise 'Implementation missing.'
+    end
+
+    def remove(id)
+      raise 'Implementation missing.'
+    end
+
+    def remove_all
+      raise 'Implementation missing.'
+    end
+
+    def normalize_data(data)
+      deep_copy(data).tap { |d| d.merge!('id' => id_for(d)) }
+    end
+
+    def deep_copy(h)
+      JSON.parse(h.to_json)
+    end
+
+    def id_for(data)
+      data.fetch('id', 'undefined').to_s
+    end
+
+    def normalize_options(options)
+      {
+        limit: options[:limit] || options['limit'] || -1,
+        offset: options[:offset] || options['offset'] || 0
+      }
+    end
+
+    def page_range(options)
+      (options[:offset]..(options[:limit] == -1 ? -1 : options[:offset] + options[:limit] - 1))
+    end
+  end
+end

data/lib/hikki/repository.rb

@@ -0,0 +1,54 @@
+module Hikki
+  class Repository
+
+    attr_reader :writers, :readers
+
+    def initialize(writers=[], readers=[])
+      @writers = Array(writers)
+      @writers << Hikki::Adapters::MemoryAdapter.new if @writers == []
+      @readers = Array(readers)
+      @readers << @writers.first if @readers == []
+    end
+
+    def save(collection, data)
+      writers.reduce({}) { |result, writer| writer.save(collection, data) }
+    end
+
+    def index(collection, field)
+      writers.all? { |writer| writer.index(collection, field) }
+    end
+
+    def remove(collection, field)
+      writers.all? { |writer| writer.remove(collection, field) }
+    end
+
+    def remove_all(collection)
+      writers.all? { |writer| writer.remove_all(collection) }
+    end
+
+    def find(collection, id)
+      readers.each do |reader|
+        result = reader.find(collection, id)
+        return result unless result == {}
+      end
+      {}
+    end
+
+    def all(collection, options={})
+      readers.each do |reader|
+        result = reader.all(collection, options)
+        return result unless result == []
+      end
+      []
+    end
+
+    def find_by(collection, field, value, options={})
+      readers.each do |reader|
+        result = reader.find_by(collection, field, value, options)
+        return result unless result == []
+      end
+      []
+    end
+
+  end
+end

data/lib/hikki/version.rb

@@ -0,0 +1,3 @@
+module Hikki
+  VERSION = "0.0.1"
+end

data/spec/hikki/adapters/memory_adapter_spec.rb

@@ -0,0 +1,242 @@
+require 'spec_helper'
+
+module Hikki
+  module Adapters
+    describe MemoryAdapter do
+      subject(:adapter) { MemoryAdapter.new(uuid_generator) }
+      let(:uuid_generator) { double :generator, uuid: '12345' }
+      let(:collection) { 'collection1' }
+
+      describe '#index' do
+        it 'returns true' do
+          expect(adapter.index(collection, :field1)).to be_true
+        end
+
+        it 'creates the index in the store' do
+          adapter.index(collection, :field1)
+          expect(adapter.store['collection1_index']['field1']).to eq Hash.new
+        end
+      end
+
+      describe '#save' do
+        context 'when an id is provided in the data' do
+          let(:data) { { id: id, field1: 'test', field2: 123 } }
+          let(:expected) { { 'id' => id, 'field1' => 'test', 'field2' => 123 } }
+          let(:id) { '1' }
+
+          it 'returns the data' do
+            expect(adapter.save(collection, data)).to eq expected
+          end
+
+          it 'persists the data in the store' do
+            adapter.save(collection, data)
+            expect(adapter.store['collection1']['1']).to eq expected
+          end
+        end
+
+        context 'when an id is not provided in the data' do
+          let(:data) { { field1: 'test', field2: 123 } }
+          let(:expected) { { 'id' => id, 'field1' => 'test', 'field2' => 123 } }
+          let(:id) { '12345' }
+
+          it 'returns the data with the id added' do
+            expect(adapter.save(collection, data)).to eq expected
+          end
+
+          it 'persists the data in the store' do
+            adapter.save(collection, data)
+            expect(adapter.store['collection1']['12345']).to eq expected
+          end
+        end
+
+        context 'when an index exists on a field in the data' do
+          let(:data) { { id: id, field1: 'test', field2: 123 } }
+          let(:expected) { { 'id' => id, 'field1' => 'test', 'field2' => 123 } }
+          let(:id) { '1' }
+          before { adapter.index(collection, :field1) }
+
+          it 'adds an entry in the index' do
+            adapter.save(collection, data)
+            expect(adapter.store['collection1_index']['field1']['test']).to eq ['1']
+          end
+        end
+      end
+
+      describe '#find' do
+          let(:id) { '1' }
+
+        context 'when the id exists' do
+          let(:data) { { id: id, field1: 'test', field2: 123 } }
+          let(:expected) { { 'id' => id, 'field1' => 'test', 'field2' => 123 } }
+          before { adapter.save(collection, data) }
+
+          it 'retrieves the data' do
+            expect(adapter.find(collection, id)).to eq expected
+          end
+        end
+
+        context 'when the id does not exist' do
+          let(:expected) { {} }
+
+          it 'returns an empty hash' do
+            expect(adapter.find(collection, id)).to eq expected
+          end
+        end
+      end
+
+      describe '#all' do
+        context 'with a record in the collection' do
+          let(:data) { { id: '1', field1: 'test', field2: 123 } }
+          let(:expected) { { 'id' => '1', 'field1' => 'test', 'field2' => 123 } }
+          before { adapter.save(collection, data) }
+
+          it 'returns an array containing the record' do
+            expect(adapter.all(collection)).to eq [expected]
+          end
+        end
+
+        context 'with no records in the collection' do
+          it 'returns an array containing the record' do
+            expect(adapter.all(collection)).to eq []
+          end
+        end
+
+        context 'with multiple records and paging options specified' do
+          before do
+            10.times do |i|
+              adapter.save(collection, {id: i+1, a: 1})
+            end
+          end
+
+          context 'with limit 2' do
+            let(:limit) { 2 }
+
+            it 'returns only 2 records' do
+              expect(adapter.all(collection, {limit: 2}).count).to eq 2
+            end
+
+            context 'with an offset of 4' do
+              it 'returns the 2 records starting with the offset' do
+                expect(adapter.all(collection, {limit: 2, offset: 4})).to eq [{'id' => '5', 'a' => 1}, {'id' => '6', 'a' => 1}]
+              end
+            end
+          end
+        end
+      end
+
+      describe '#find_by' do
+        context 'with a record in the collection matching' do
+          let(:data) { { id: '1', field1: 'test', field2: 123 } }
+          let(:expected) { { 'id' => '1', 'field1' => 'test', 'field2' => 123 } }
+
+          context 'without an index' do
+            before { adapter.save(collection, data) }
+
+            it 'returns an array containing the record' do
+              expect(adapter.find_by(collection, :field2, 123)).to eq [expected]
+            end
+          end
+
+          context 'with an index' do
+            before do
+              adapter.index(collection, :field1)
+              adapter.save(collection, data)
+            end
+
+            it 'returns an array containing the record' do
+              expect(adapter.find_by(collection, :field1, 'test')).to eq [expected]
+            end
+          end
+        end
+
+        context 'with no matching records in the collection' do
+          it 'returns an array containing the record' do
+            expect(adapter.find_by(collection, :field1, 'foo')).to eq []
+          end
+        end
+
+        context 'with multiple matching records and paging options specified' do
+          before do
+            10.times do |i|
+              adapter.save(collection, {id: i+1, a: 1})
+            end
+          end
+
+          context 'with limit 2' do
+            let(:limit) { 2 }
+
+            it 'returns only 2 records' do
+              expect(adapter.find_by(collection, :a, 1, {limit: 2}).count).to eq 2
+            end
+
+            context 'with an offset of 4' do
+              it 'returns the 2 records starting with the offset' do
+                expect(adapter.find_by(collection, :a, 1, {limit: 2, offset: 4})).to eq [{'id' => '5', 'a' => 1}, {'id' => '6', 'a' => 1}]
+              end
+            end
+          end
+        end
+      end
+
+      describe '#remove' do
+        context 'with a record for the id in the collection' do
+          let(:data) { { id: id, field1: 'test', field2: 123 } }
+          let(:id) { '1' }
+          before { adapter.save(collection, data) }
+
+          it 'returns true' do
+            expect(adapter.remove(collection, id)).to be_true
+          end
+
+          it 'removes the record from the store' do
+            adapter.remove(collection, id)
+            expect(adapter.store[collection][id]).to be_nil
+          end
+
+          context 'when there is an index' do
+            before do
+              adapter.index(collection, :field1)
+              adapter.save(collection, data)
+            end
+
+            it 'removes the id from the index' do
+              expect(adapter.store[collection + '_index']['field1']['test']).to eq ['1']
+              adapter.remove(collection, id)
+              expect(adapter.store[collection + '_index']['field1']['test']).to eq []
+            end
+          end
+        end
+      end
+
+      describe '#remove_all' do
+        context 'with a record in the collection' do
+          let(:data) { { id: id, field1: 'test', field2: 123 } }
+          let(:id) { '1' }
+          before { adapter.save(collection, data) }
+
+          it 'returns true' do
+            expect(adapter.remove_all(collection)).to be_true
+          end
+
+          it 'removes all records from the store' do
+            adapter.remove_all(collection)
+            expect(adapter.store[collection]).to be_nil
+          end
+
+          context 'when there is an index' do
+            before do
+              adapter.index(collection, :field1)
+              adapter.save(collection, data)
+            end
+
+            it 'removes the id from the index' do
+              expect(adapter.store[collection + '_index']['field1']['test']).to eq ['1']
+              adapter.remove_all(collection)
+              expect(adapter.store[collection + '_index']).to be_nil
+            end
+          end
+        end
+      end
+    end
+  end
+end