schron 0.0.2

data/lib/schron/datastore/mongo/metadata.rb

@@ -0,0 +1,49 @@
+# require 'schron/datastore/metadata'
+
+module Schron
+  module Datastore
+    class Mongo
+      class Metadata < Schron::Datastore::Metadata
+        
+        NATIVELY_SUPPORTED = [
+          String,
+          Integer,
+          Fixnum,
+          Float,
+          Array,
+          Regexp,
+          TrueClass,
+          FalseClass,
+          Time,
+          Hash,
+          Symbol,
+          BSON::Binary
+        ]
+        
+        def initialize(db, collection_name=:schron_metadata)
+          @collection = db[collection_name]
+        end
+        
+        def recursive?
+          true
+        end
+        
+        def natively_supported?(value)
+          NATIVELY_SUPPORTED.include?(value.class)
+        end
+
+        # @return [Array] an array of hashes, each with the following keys:
+        #   * kind
+        #   * field
+        #   * type
+        def fetch_metadata
+          @collection.find
+        end
+
+        def insert_metadata(kind, field, type)
+          @collection.insert(kind: kind, field: field, type: type)
+        end
+      end
+    end
+  end
+end

data/lib/schron/datastore/mongo/serializer.rb

@@ -0,0 +1,38 @@
+module Schron
+  module Datastore
+    class Mongo
+      class Serializer
+        
+        def serialize_document(hash)
+          doc = hash.merge(_id: serialize_id(hash[:id]))
+          doc.delete :id
+          doc
+        end
+
+        def unserialize_document(doc)
+          hash = symbolize_keys(doc)
+          hash.merge!(id: unserialize_id(hash[:_id]))
+          hash.delete :_id
+          hash
+        end
+
+        def serialize_id(uuid)
+          BSON::Binary.new(uuid, BSON::Binary::SUBTYPE_UUID)
+        end
+
+        def unserialize_id(bin)
+          bin.to_s
+        end
+
+        def symbolize_keys(hash)
+          hash.reduce({}) do |symbolized, (k, v)|
+            val = v.kind_of?(Hash) ? symbolize_keys(v) : v
+            symbolized[k.to_sym] = val
+            symbolized
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/schron/datastore/sequel.rb

@@ -0,0 +1,137 @@
+require 'sequel'
+require 'json'
+require 'schron/datastore/interface'
+require 'schron/id'
+require 'schron/datastore/serializer'
+
+module Schron
+  module Datastore
+    class Sequel
+      
+      include Schron::Datastore::Interface
+      
+      MAX_LIMIT = 2**61
+
+      def initialize(db)
+        @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
+      end
+
+      def multi_get(kind, ids)
+        results = unserialize_all(kind, @db[kind].where(id: ids).all)
+        Schron::Util.sorted_by_id_list(results, ids)
+      end
+      
+      def insert(kind, hash)
+        hash[:id] = Schron::Id.generate unless hash[:id]
+        @db[kind].insert(serialize(kind, hash))
+        hash
+      end
+      
+      def multi_insert(kind, hashes)
+        hashes.each do |h|
+          h[:id] = Schron::Id.generate unless h[:id]
+        end
+        @db[kind].multi_insert(serialize_all(kind, hashes))
+        hashes
+      end
+      
+      def update(kind, hash)
+        raise "must provide an id" unless hash.key?(:id)
+        @db[kind].where(id: hash[:id]).update(serialize(kind, hash))
+        hash
+      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)
+        @db[kind].where(id: id).delete
+        nil
+      end
+      
+      def multi_remove(kind, ids)
+        @db[kind].where(id: ids).delete
+        nil
+      end
+
+      def reset!
+        protect_reset do
+          @db.tables.each do |table|
+            @db.drop_table(table)
+          end
+        end
+      end
+
+      private
+      
+      def serializer
+        @serializer ||= Schron::Datastore::Serializer.new
+      end
+
+      def serialize(kind, hash)
+        serializer.serialize(kind, hash)
+      end
+      
+      def serialize_all(kind, hashes)
+        hashes.map{ |h| serialize(kind, h) }
+      end
+      
+      def unserialize(kind, hash)
+        serializer.unserialize(kind, hash)
+      end
+      
+      def unserialize_all(kind, hashes)
+        hashes.map { |h| unserialize(kind, h) }
+      end
+      
+      def apply_filters(query, data)
+        final = query.filters.reduce(data) do |data, (name, op, value)|
+          case op
+          when '='
+            data.where name => value
+          when 'in'
+            data = data.where name => value
+            data = data.or(name => nil) if value.include?(nil)
+            data
+          when '!='
+            data = data.exclude(name: value)
+            data = data.or(name: nil) unless value.nil?
+            data
+          when '>', '<', '>=', '<='
+            data.where "#{name} #{op} ?", value
+          else
+            raise "unsupported op #{op}"
+          end
+        end
+      end
+
+      def apply_limit_and_offset(query, data)
+        if query.limit && query.offset
+          data.limit(query.limit, query.offset)
+        elsif query.limit
+          data.limit(query.limit)
+        elsif query.offset
+          data.limit(MAX_LIMIT, query.offset)
+        else
+          data
+        end
+      end
+      
+      def apply_sorts(query, data)
+        query.sorts.reduce(data) do |data, (field, dir)|
+          data.order_append(dir == :asc ? ::Sequel.asc(field) : ::Sequel.desc(field))
+        end
+      end
+    end
+  end
+end

data/lib/schron/datastore/serializer.rb

@@ -0,0 +1,46 @@
+require 'json'
+require 'time'
+require 'set'
+require 'schron/util'
+module Schron
+  module Datastore
+    class Serializer
+      
+      # Make this thing into a Hash of Arrays of Floats, ints and strings
+      
+      def serialize(kind, hash)
+        hash.each_with_object({}) do |(field, value), h|
+          h[field] = serialize_value(value)
+        end
+      end
+      
+      def unserialize(kind, hash)
+        Schron::Util.symbolize_keys(hash)
+        #   hash.each_with_object({}) do |(field, value), hash|
+        #     hash[field] = unserialize_value(value)
+        #   end
+        # )
+      end
+
+      private
+      
+      def serialize_value(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, val), serialized|
+            serialized[key] = serialize_value(val)
+          end
+        when Array, Set
+          value.map { |v| serialize_value(v) }.to_a
+        when Date, DateTime, Time
+          value.to_datetime.iso8601(9)
+        when BigDecimal
+          value.to_f
+        else
+          value
+        end
+      end
+
+    end
+  end
+end

data/lib/schron/dsl.rb

@@ -0,0 +1,28 @@
+module Schron
+  module DSL
+
+    def kind(kind=nil)
+      set_or_get(:kind, kind)
+    end
+
+    def entity_class(entity_class=nil)
+      set_or_get(:entity_class, entity_class)
+    end
+
+    def indexed_field(field)
+      (@indexed_fields ||= []) << field
+    end
+
+    def indexed_fields
+      @indexed_fields || []
+    end
+    
+    private
+
+    def set_or_get(name, val)
+      val.nil? ?
+        instance_variable_get("@#{name}") :
+        instance_variable_set("@#{name}", val)
+    end
+  end
+end

data/lib/schron/error.rb

@@ -0,0 +1,7 @@
+module Schron
+  class Error < StandardError
+  end
+  
+  class OperationDisabledError < Error
+  end
+end

data/lib/schron/id.rb

@@ -0,0 +1,22 @@
+require 'securerandom'
+module Schron
+  module Id
+    module_function
+    def generate
+      SecureRandom.uuid
+    end
+    
+    def require!(obj)
+      id_present = if obj.kind_of?(Hash)
+        obj[:id]
+      else
+        obj.id
+      end
+      raise "must provide an id" unless id_present
+    end
+    
+    def require_all!(objects)
+      objects.each { |o| require!(o) }
+    end
+  end
+end

data/lib/schron/identity_map.rb

@@ -0,0 +1,26 @@
+module Schron
+  class IdentityMap
+    
+    def initialize
+      @data = {}
+    end
+    
+    def put(id, object)
+      @data[id] = object
+    end
+    
+    def get(id)
+      @data[id]
+    end
+
+    def fetch(id, &block)
+      put(id, block.call) unless has?(id)
+      get(id)
+    end
+    
+    def has?(id)
+      @data.key?(id)
+    end
+    
+  end
+end

data/lib/schron/paginated_results.rb

@@ -0,0 +1,28 @@
+require 'schron/paging'
+
+module Schron
+  class PaginatedResults < Array
+
+    attr_reader :paging
+
+    def initialize(*args)
+      super
+      @paging = Paging.new
+    end
+    
+    [:map].each do |method|
+      define_method(method) do |*args, &block|
+        results = self.class.new(super(*args, &block))
+        results.paging = paging.dup
+        results
+      end
+    end
+    
+    protected
+    
+    def paging=(paging)
+      @paging = paging
+    end
+
+  end
+end

data/lib/schron/paging.rb

@@ -0,0 +1,5 @@
+module Schron
+  class Paging
+    attr_accessor :current_page, :next_page, :previous_page
+  end
+end

data/lib/schron/query.rb

@@ -0,0 +1,122 @@
+require 'schron/paginated_results'
+module Schron
+  class InvalidQueryError < StandardError
+  end
+  
+  class Query
+    attr_reader :filters
+    attr_reader :sorts
+    attr_reader :kind
+
+    def initialize(kind=nil, datastore=nil &block)
+      @kind = kind
+      @datastore = datastore
+      @filters = []
+      @sorts = []
+      @page = false
+      yield self if block_given?
+    end
+
+
+    ##
+    ## Fluent Builder
+
+    def limit(val=nil)
+      set_or_get(:limit, val)
+    end
+    
+    def offset(val=nil)
+      set_or_get(:offset, val)
+    end
+    
+    def page(page, per_page: 20)
+      @page = page
+      limit(per_page).offset((page - 1) * per_page)
+    end
+
+    def sort(attr, dir=:asc)
+      raise "invalid sort dir #{dir}, must be :asc or :desc" unless [:asc, :desc].include?(dir)
+      @sorts << [attr.to_sym, dir]
+      self
+    end
+    
+    # filter(:name, '=', 'David')
+    # filter(:age, '>', 18)
+    # filter(name: 'David', city: 'Tahoma') # => equivalent to 
+    #   filter(:name, '=', 'David').filter(:city, '=', 'Tahoma')
+    def filter(attr, op=nil, val=nil)
+      if op.nil?
+        attr.each do |key, value|
+          if value.kind_of?(Enumerable)
+            @filters << [key.to_sym, 'in', value]
+          else
+            @filters << [key.to_sym, '=', value]
+          end
+        end
+      else
+        @filters << [attr.to_sym, op, val]
+      end
+      self
+    end
+    
+    
+    ##
+    ## Query Terminators
+    
+    def all
+      with_pagination(@datastore.exec_query(@kind, self))
+    end
+    
+    def first
+      limit(1).all.first
+    end
+    
+    def exists?
+      !all.empty?
+    end
+    
+    
+    protected
+
+    def unpage
+      @page = false
+      self
+    end
+
+    private
+
+    def set_or_get(name, val)
+      if val.nil?
+        instance_variable_get("@#{name}")
+      else
+        instance_variable_set("@#{name}", val)
+        self
+      end
+    end
+    
+    def with_pagination(results)
+      if @page
+        apply_pagination(results)
+      else
+        results
+      end
+    end
+    
+    def apply_pagination(results)
+      Schron::PaginatedResults.new(results).tap do |r|
+        r.paging.current_page = @page
+        r.paging.previous_page = @page == 1 ? nil : (@page - 1)
+        r.paging.next_page = calculate_next_page
+      end
+    end
+    
+    def calculate_next_page
+      q = dup.unpage
+      q.offset(q.offset + q.limit)
+        .limit(1)
+      q.exists? ?
+        @page + 1 :
+        nil
+    end
+  end
+end