schron 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a8e1d0962975ce0ce8d619f4e757b60cdf631e82
+  data.tar.gz: 36477336e2e1a6c356cd4ba95430eb61e3d91947
+SHA512:
+  metadata.gz: f691c4bf156243994fa5ca0d0e3532b88f9dfc26442a51e56036d0cec8bd11558a1789bc00a573d0f5e2c93030505da18784c82663d4f7b0c7fdd6bb04abf294
+  data.tar.gz: 33fca3e587a68959a994bd584883426c5169340c2054b325b5a610f307408e6378c3601d8b659aa5f483b1b03e61e3fbd9ec31c05b28b19e2f7c189ab6771e48

data/.gitignore

@@ -0,0 +1,3 @@
+.bundle
+bin
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+
+gemspec

data/Rakefile

@@ -0,0 +1,19 @@
+require 'pathname'
+root = Pathname.new(File.expand_path(__dir__))
+
+task :irb do
+  ARGV.clear
+  require 'irb'
+  require 'schron'
+  IRB.start
+end
+
+task :bundle do
+  system "cd #{root} && bundle install"
+end
+
+task :spec do
+  system "cd #{root} && bundle exec rspec"
+end
+
+task :default => [:bundle, :spec]

data/lib/schron.rb

@@ -0,0 +1,4 @@
+# Dir[File.join(__dir__, '**/*.rb')].each { |f| require f }
+
+require 'schron/repository'
+require 'schron/archive'

data/lib/schron/archive.rb

@@ -0,0 +1,88 @@
+require 'schron/archive/interface'
+require 'schron/dsl'
+require 'schron/query'
+
+module Schron
+  module Archive
+
+    def self.included(archive_class)
+      archive_class.extend Schron::DSL
+    end
+
+    include Schron::Archive::Interface
+
+    attr_reader :datastore, :kind, :entity_class, :indexed_fields
+
+    def initialize(datastore, 
+        kind: nil, 
+        entity_class: nil,
+        indexed_fields: nil)
+      @datastore = datastore
+      @kind = kind || self.class.kind
+      @entity_class = entity_class || self.class.entity_class
+      @indexed_fields = indexed_fields || self.class.indexed_fields
+      yield self if block_given?
+    end
+
+    def query(&block)
+      load_all(Query.new(@kind, @datastore, &block).all)
+    end
+    
+    def first(&block)
+      query do |q|
+        yield q if block_given?
+        q.limit(1)
+      end.first
+    end
+    
+    def get(id)
+      maybe_load(@datastore.get(@kind, id))
+    end
+
+    def multi_get(ids)
+      load_all(@datastore.multi_get(@kind, ids)).compact
+    end
+
+    def insert(object)
+      maybe_load(@datastore.insert(@kind, dump(object)))
+    end
+
+    def multi_insert(objects)
+      load_all(@datastore.multi_insert(@kind, dump_all(objects)))
+    end
+
+    def dump(object)
+      object.attributes.each_with_object({}) do |(k,v), h|
+        h[dump_value(k)] = dump_value(v)
+      end
+    end
+
+    def load(attributes)
+      attributes.nil? ?
+        nil :
+        entity_class.new(attributes)
+    end
+
+    def dump_all(objects)
+      objects.map { |o| dump(o) }
+    end
+
+    def load_all(attributes)
+      attributes.map { |attrs| maybe_load(attrs) }
+    end
+    
+    
+    private
+
+    def maybe_load(attrs)
+      attrs.nil? ? nil : load(attrs)
+    end
+    
+    def dump_value(val)
+      val.respond_to?(:attributes) && !val.kind_of?(Class) ?
+        val.attributes :
+        val
+    end
+
+  end
+end

data/lib/schron/archive/interface.rb

@@ -0,0 +1,52 @@
+module Schron
+  module Archive
+    module Interface
+
+      def query(&block)
+        raise NotImplementedError
+      end
+
+      def first(&block)
+        raise NotImplementedError
+      end
+
+      def get(id)
+        raise NotImplementedError
+      end
+
+      def multi_get(ids)
+        raise NotImplementedError
+      end
+
+      def insert(object)
+        raise NotImplementedError
+      end
+
+      def multi_insert(objects)
+        raise NotImplementedError
+      end
+
+      def load(attributes)
+        raise NotImplementedError
+      end
+
+      def dump(object)
+        raise NotImplementedError
+      end
+
+      def dump_all(objects)
+        objects.map { |o| dump(o) }
+      end
+
+      def load_all(attributes)
+        attributes.map { |a| load(a) }
+      end
+
+      def identity(object)
+        object.__send__ :id
+      end
+
+
+    end
+  end
+end

data/lib/schron/datastore/interface.rb

@@ -0,0 +1,60 @@
+require 'schron/error'
+module Schron
+  module Datastore
+    module Interface
+      
+      def exec_query(kind, query)
+        raise NotImplementedError
+      end
+      
+      def get(kind, id)
+        multi_get(kind, [id]).first
+      end
+      
+      def multi_get(kind, ids)
+        raise NotImplementedError
+      end
+      
+      def insert(kind, hash)
+        raise NotImplementedError
+      end
+      
+      def multi_insert(kind, hashes)
+        raise NotImplementedError
+      end
+      
+      def update(kind, hash)
+        raise NotImplementedError
+      end
+      
+      def multi_update(kind, hashes)
+        raise NotImplementedError
+      end
+
+      def remove(kind, id)
+        raise NotImplementedError
+      end
+      
+      def multi_remove(kind, ids)
+        raise NotImplementedError
+      end
+      
+      def reset!
+        protect_reset do
+          raise NotImplementedError
+        end
+      end
+      
+      protected
+      
+      def protect_reset
+        unless ENV['SCHRON_RESET']
+          raise Schron::OperationDisabledError,
+            "Can not reset datastore with setting ENV['SCHRON_RESET'] to 1"
+        end
+        yield
+      end
+        
+    end
+  end
+end

data/lib/schron/datastore/memory.rb

@@ -0,0 +1,152 @@
+require 'securerandom'
+require 'schron/datastore/interface'
+
+module Schron
+  module Datastore
+    class Memory
+      include Schron::Datastore::Interface
+
+      def initialize
+        @data = {}
+      end
+
+      def exec_query(kind, query)
+        results = data_for_kind(kind).values
+        results = apply_filters(query, results)
+        results = apply_sorts(query, results)
+        apply_limit_offset(query, results) || []
+      end
+      
+      def multi_get(kind, ids)
+        ids.map { |id| get_data(kind, id) }.compact
+      end
+      
+      def insert(kind, hash)
+        hash = hash.merge(id: generate_id) unless hash[:id]
+        set_data(kind, hash[:id], hash)
+        hash.dup
+      end
+      
+      def multi_insert(kind, hashes)
+        hashes.map { |h| insert(kind, h) }
+      end
+      
+      def update(kind, hash)
+        raise "record must have id to update" unless hash.key?(:id)
+        set_data(kind, hash[:id], hash)
+        hash.dup
+      end
+      
+      def multi_update(kind, hashes)
+        raise "records must all have ids to multi update" unless hashes.all?{ |h| h[:id] }
+        hashes.map { |h| update(kind, h) }
+      end
+
+      def remove(kind, id)
+        data_for_kind(kind).delete(id)
+        nil
+      end
+      
+      def multi_remove(kind, ids)
+        ids.each { |id| remove(kind, id) }
+        nil
+      end
+      
+      def reset!
+        protect_reset do
+          @data = {}
+        end
+      end
+      
+      private
+      
+      def data_for_kind(kind)
+        @data[kind] ||= {}
+      end
+      
+      def get_data(kind, id)
+        data = data_for_kind(kind)[id]
+        data ? data.dup : nil
+      end
+      
+      def set_data(kind, id, data)
+        data_for_kind(kind)[id] = data
+      end
+      
+      def generate_id
+        SecureRandom.uuid.gsub('-', '')
+      end
+      
+      
+      def apply_filters(query, data)
+        query.filters.reduce(data) do |data, (field, op, filter_value)|
+          case op
+          when '='
+            data.select { |obj| obj[field] == filter_value }
+          when '!='
+            data.select { |obj| obj[field] != filter_value }
+          when 'in'
+            data.select { |obj| filter_value.include?(obj[field]) }
+          when '>'
+            data.select { |obj| obj[field] && obj[field] > filter_value }
+          when '<'
+            data.select { |obj| obj[field] && obj[field] < filter_value }
+          when '>='
+            data.select { |obj| obj[field] && obj[field] >= filter_value }
+          when '<='
+            data.select { |obj| obj[field] && obj[field] <= filter_value }
+          else
+            raise "unsupported op #{op}"
+          end
+        end
+      end
+      
+      def apply_sorts(query, data)
+        data.sort { |a, b| compare_records(a, b, query.sorts) }
+      end
+      
+      def compare_records(record1, record2, sorts)
+        sorts.each do |sort|
+          result = compare_record record1, record2, sort
+          return result if result
+        end
+        0
+      end
+
+      def compare_record(record1, record2, sort)
+        field, direction = sort
+        field1, field2 = record1[field], record2[field]
+        if field1 == field2
+          nil
+        elsif field1.nil?
+          direction == :asc ? -1 : 1
+        elsif field2.nil?
+          direction == :asc ? 1 : -1
+        elsif field1 < field2 && direction == :asc
+          -1
+        elsif field1 > field2 && direction == :desc
+          -1
+        else
+          1
+        end
+      end
+      
+      
+      def apply_limit_offset(query, data)
+        if query.limit && query.offset
+          data[query.offset...(query.offset+query.limit)]
+        elsif query.limit
+          data[0...query.limit]
+        elsif query.offset
+          data[query.offset..data.size]
+        else
+          data
+        end
+      end
+      
+      
+      
+    end
+  end
+end
+

data/lib/schron/datastore/mongo.rb

@@ -0,0 +1,173 @@
+require 'mongo'
+require 'schron/id'
+require 'schron/util'
+require 'schron/datastore/interface'
+require 'schron/datastore/serializer'
+
+module Schron
+  module Datastore
+    class Mongo
+      include Schron::Datastore::Interface
+      
+      def initialize(db)
+        @db = db
+      end
+      
+      def get(kind, id)
+        doc = coll(kind).find(id_selector(id)).first
+        doc ?
+          unserialize(kind, doc) :
+          nil
+      end
+      
+      def multi_get(kind, ids)
+        docs = coll(kind).find(multiple_id_selector(ids))
+        Schron::Util.sorted_by_id_list(docs.map{ |doc| unserialize(kind, doc) }, ids)
+      end
+      
+      def insert(kind, hash)
+        hash[:id] ||= Schron::Id.generate
+        serialized = serialize(kind, hash)
+        coll(kind).insert(serialized)
+        hash
+      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
+      end
+      
+      def update(kind, hash)
+        Schron::Id.require!(hash)
+        doc = serialize(kind, hash)
+        coll(kind).update(id_selector(hash[:id]), doc)
+        hash
+      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)
+        end
+        hashes
+      end
+      
+      def remove(kind, id)
+        coll(kind).remove(id_selector(id))
+        nil
+      end
+      
+      def multi_remove(kind, ids)
+        coll(kind).remove(multiple_id_selector(ids))
+        nil
+      end
+      
+      def exec_query(kind, query)
+        selector = selector_for(query)
+        query_opts = query_opts_for(query)
+        docs = coll(kind).find(selector, query_opts)
+        docs.map{ |d| unserialize(kind, d) }
+      end
+
+      def reset!
+        protect_reset do
+          @db.collections.each do |coll|
+            unless coll.name =~ /^system\./
+              coll.drop
+            end
+          end
+        end
+      end
+      
+      private
+      
+      def coll(kind)
+        @db[kind]
+      end
+
+      def serializer
+        @serializer ||= Schron::Datastore::Serializer.new
+      end
+      
+      def serialize(kind, hash)
+        doc = hash.merge(_id: serialize_id(hash[:id]))
+        doc.delete(:id)
+        serializer.serialize(kind, doc)
+      end
+
+      def unserialize(kind, doc)
+        hash = Schron::Util.symbolize_keys(doc)
+        hash.merge! id: hash[:_id].to_s
+        hash.delete(:_id)
+        serializer.unserialize(kind, hash)
+      end
+
+      def serialize_id(uuid)
+        uuid = uuid.dup if uuid.frozen?
+        BSON::Binary.new(uuid, BSON::Binary::SUBTYPE_UUID)
+      end
+
+      def unserialize_id(bin)
+        bin.to_s
+      end
+
+      def id_selector(id)
+        {_id: serialize_id(id)}
+      end
+      
+      def multiple_id_selector(ids)
+        serialized = ids.map { |id| serialize_id(id) }
+        {_id: {"$in" => serialized }}
+      end
+
+      def selector_for(query)
+        selector = {}
+        query.filters.each do |(field, op, filter_value)|
+          mongo_field = mongoize_field(field)
+          case op
+          when '='
+            selector[mongo_field] = filter_value
+          when '!='
+            selector[mongo_field] = { "$ne" => filter_value }
+          when 'in'
+            selector[mongo_field] = { "$in" => filter_value.to_a }
+          when '>'
+            selector[mongo_field] = { "$gt" => filter_value }
+          when '<'
+            selector[mongo_field] = { "$lt" => filter_value }
+          when '>='
+            selector[mongo_field] = { "$gte" => filter_value }
+          when '<='
+            selector[mongo_field] = { "$lte" => filter_value }
+          else
+            raise "unsupported op #{op}"
+          end
+        end
+        selector
+      end
+      
+      def query_opts_for(query)
+        {}.tap do |opts|
+          opts[:sort] = query_sorts(query)
+          opts[:limit] = query.limit
+          opts[:skip] = query.offset
+        end
+      end
+      
+      def query_sorts(query)
+        query.sorts.map do |(field, direction)|
+          mongo_dir = (direction == :asc ? ::Mongo::ASCENDING : ::Mongo::DESCENDING)
+          [mongoize_field(field), mongo_dir]
+        end
+      end
+      
+      def mongoize_field(field_name)
+        field_name == :id ? :_id : field_name
+      end
+      
+    end
+  end
+end