endymion 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7111de9207c18485a31aece27f1ed4f68ef6399d
+  data.tar.gz: 6643fae41c6caafee6a1192fa2ebaa5ef23d37e1
+SHA512:
+  metadata.gz: a9857cb58fba27edae36ebddd1b48e0dd27001752bde1dac7c74c0bbc4c2935f64d3dcaa60b5a86afd29b0a763e2725bd919db9959c7a4020a17a7ea96c16510
+  data.tar.gz: ee254058fd74cb6a91c59526f09ac5fde80aa95afbc20cd5b103135efe59f6f2c0957ed07545f96bdf998bff2ea997fd21290fe6ae81ba55f5d536af4ee688eb

data/lib/endymion.rb

@@ -0,0 +1,21 @@
+require 'endymion/api'
+module Endymion
+  
+  def self.new(datastore_name, datastore_opts={})
+    Endymion::API.new(new_datastore(datastore_name, datastore_opts))
+  end
+
+  def self.new_datastore(name, opts={})
+    begin
+      require "endymion/#{name}"
+    rescue LoadError
+      raise "Can't find datastore implementation: #{name}"
+    end
+    ds_klass = Endymion.const_get(Util.class_name(name.to_s))
+    ds_klass.new(opts)
+  end
+  
+  def self.new?(record)
+    !record.has_key?(:key)
+  end
+end

data/lib/endymion/api.rb

@@ -0,0 +1,284 @@
+require 'endymion/format'
+require 'endymion/field_spec'
+require 'endymion/kind_spec'
+require 'endymion/query'
+require 'endymion/filter'
+require 'endymion/sort'
+
+module Endymion
+  class API
+
+    attr_reader :datastore
+    
+    def initialize(datastore)
+      @datastore = datastore
+    end
+
+    def defentity(kind)
+      kind = Format.format_kind(kind)
+      kind_spec = KindSpec.new(kind, self)
+      yield(kind_spec)
+      save_kind_spec(kind_spec)
+      pack(kind.to_sym) {|value| pack_record((value || {}).merge(:kind => kind))}
+      unpack(kind.to_sym) {|value| unpack_record((value || {}).merge(:kind => kind))}
+    end
+
+    def pack(type, &block)
+      packers[type] = block
+    end
+
+    def packer_defined?(type)
+      packers.has_key?(type)
+    end
+
+    def unpack(type, &block)
+      unpackers[type] = block
+    end
+
+    def unpacker_defined?(type)
+      unpackers.has_key?(type)
+    end
+
+    # Assigns the datastore within the given block
+    def with_datastore(name, opts={})
+      old_datastore = @datastore
+      @datastore = Endymion.new_datastore(name, opts)
+      begin
+        yield
+      rescue
+        @datastore = old_datastore
+        raise
+      end
+    end
+
+
+    #  Saves a record. Any additional parameters will get merged onto the record before it is saved.
+    #
+    #  Hyperion.save({:kind => :foo})
+    #  => {:kind=>"foo", :key=>"<generated key>"}
+    #  Hyperion.save({:kind => :foo}, :value => :bar)
+    #  => {:kind=>"foo", :value=>:bar, :key=>"<generated key>"}
+    def save(record, attrs={})
+      save_many([record.merge(attrs || {})]).first
+    end
+
+    # Saves multiple records at once.
+    def save_many(records)
+      unpack_records(datastore.save(pack_records(records)))
+    end
+
+    # Creates a record.  While save delegates to a create or update based on the result
+    # of new?, this always creates.  This allows you to set the key explicitly
+    def create(record)
+      create_many([record]).first
+    end
+
+    # Create many records at once
+    def create_many(records)
+      unpack_records(datastore.create(pack_records(records)))
+    end
+
+    # Returns true if the record is new (not saved/doesn't have a :key), false otherwise.
+    def new?(record)
+      !record.has_key?(:key)
+    end
+
+    # Retrieves the value associated with the given key from the datastore. nil if it doesn't exist.
+    def find_by_key(kind, key)
+      unpack_record(datastore.find_by_key(kind, key))
+    end
+
+    # Returns all records of the specified kind that match the filters provided.
+    #
+    #   find_by_kind(:dog) # returns all records with :kind of \"dog\"
+    #   find_by_kind(:dog, :filters => [[:name, '=', "Fido"]]) # returns all dogs whos name is Fido
+    #   find_by_kind(:dog, :filters => [[:age, '>', 2], [:age, '<', 5]]) # returns all dogs between the age of 2 and 5 (exclusive)
+    #   find_by_kind(:dog, :sorts => [[:name, :asc]]) # returns all dogs in alphebetical order of their name
+    #   find_by_kind(:dog, :sorts => [[:age, :desc], [:name, :asc]]) # returns all dogs ordered from oldest to youngest, and gos of the same age ordered by name
+    #   find_by_kind(:dog, :limit => 10) # returns upto 10 dogs in undefined order
+    #   find_by_kind(:dog, :sorts => [[:name, :asc]], :limit => 10) # returns upto the first 10 dogs in alphebetical order of their name
+    #   find_by_kind(:dog, :sorts => [[:name, :asc]], :limit => 10, :offset => 10) # returns the second set of 10 dogs in alphebetical order of their name
+    #
+    # Filter operations and acceptable syntax:
+    #   "=" "eq"
+    #   "<" "lt"
+    #   "<=" "lte"
+    #   ">" "gt"
+    #   ">=" "gte"
+    #   "!=" "not"
+    #   "contains?" "contains" "in?" "in"
+    #
+    # Sort orders and acceptable syntax:
+    #   :asc "asc" :ascending "ascending"
+    #   :desc "desc" :descending "descending"
+    def find_by_kind(kind, args={})
+      unpack_records(datastore.find(build_query(kind, args)))
+    end
+
+    # Removes the record stored with the given key. Returns nil no matter what.
+    def delete_by_key(kind, key)
+      datastore.delete_by_key(kind, key)
+    end
+
+    # Deletes all records of the specified kind that match the filters provided.
+    def delete_by_kind(kind, args={})
+      datastore.delete(build_query(kind, args))
+    end
+
+    # Counts records of the specified kind that match the filters provided.
+    def count_by_kind(kind, args={})
+      datastore.count(build_query(kind, args))
+    end
+
+    
+    
+    # NOTE: these methods were marked as private in Hyperion, but were actually
+    # accessed from outside, in the FieldSpec class. Temporarily made public until
+    # things are cleand up
+    def packer_for(type)
+      @packers[type]
+    end
+
+    def unpacker_for(type)
+      @unpackers[type]
+    end
+
+
+    private
+
+    def packers
+      @packers ||= {}
+    end
+
+    def unpackers
+      @unpackers ||= {}
+    end
+
+    def build_query(kind, args)
+      kind = Format.format_kind(kind)
+      filters = build_filters(kind, args[:filters])
+      sorts = build_sorts(kind, args[:sorts])
+      Query.new(kind, filters, sorts, args[:limit], args[:offset])
+    end
+
+    def build_filters(kind, filters)
+      (filters || []).map do |(field, operator, value)|
+        operator = Format.format_operator(operator)
+        packed_field = pack_field(kind, field)
+        value = pack_value(kind, field, value)
+        Filter.new(packed_field, operator, value)
+      end
+    end
+
+    def build_sorts(kind, sorts)
+      (sorts || []).map do |(field, order)|
+        field = pack_field(kind, field)
+        order = Format.format_order(order)
+        Sort.new(field, order)
+      end
+    end
+
+    def unpack_records(records)
+      records.map do |record|
+        unpack_record(record)
+      end
+    end
+
+    def unpack_record(record)
+      if record
+        create_entity(record) do |record, entity, field, field_spec|
+          value = record[field_spec.db_name]
+          entity[field] = field_spec.unpack(value)
+          entity
+        end
+      end
+    end
+
+    def pack_records(records)
+      records.map do |record|
+        pack_record(record)
+      end
+    end
+
+    def pack_record(record)
+      if record
+        entity = create_entity(record) do |record, entity, field, field_spec|
+          value = record[field]
+          entity[field_spec.db_name] = field_spec.pack(value || field_spec.default)
+          entity
+        end
+        update_timestamps(entity)
+      end
+    end
+
+    def pack_field(kind, field)
+      field = Format.format_field(field)
+      kind_spec = kind_spec_for(kind)
+      return field unless kind_spec
+      field_spec = kind_spec.fields[field]
+      return field unless field_spec
+      return field_spec.db_name
+    end
+
+    def pack_value(kind, field, value)
+      kind_spec = kind_spec_for(kind)
+      return value unless kind_spec
+      field_spec = kind_spec.fields[field]
+      return value unless field_spec
+      return field_spec.pack(value)
+    end
+
+    def update_timestamps(record)
+      new?(record) ? update_created_at(record) : update_updated_at(record)
+    end
+
+    def update_updated_at(record)
+      spec = kind_spec_for(record[:kind])
+      if spec && spec.fields.include?(:updated_at)
+        record[:updated_at] = Time.now
+      end
+      record
+    end
+
+    def update_created_at(record)
+      spec = kind_spec_for(record[:kind])
+      if spec && spec.fields.include?(:created_at)
+        record[:created_at] = Time.now
+      end
+      record
+    end
+
+    def create_entity(record)
+      record = Format.format_record(record)
+      kind = record[:kind]
+      spec = kind_spec_for(kind)
+      unless spec
+        record
+      else
+        key = record[:key]
+        base_record = {:kind => kind}
+        base_record[:key] = key if key
+        spec.fields.reduce(base_record) do |new_record, (name, spec)|
+          yield(record, new_record, name, spec)
+        end
+      end
+    end
+
+    def kind_spec_for(kind)
+      @kind_specs ||= {}
+      @kind_specs[kind]
+    end
+
+    def save_kind_spec(kind_spec)
+      @kind_specs ||= {}
+      @kind_specs[kind_spec.kind] = kind_spec
+    end
+
+
+
+
+
+
+
+  end
+end

data/lib/endymion/dev/ds_spec.rb

@@ -0,0 +1,422 @@
+require 'endymion/types'
+
+shared_examples_for 'Datastore' do
+
+  let(:api) do
+    Endymion::API.new(datastore)
+  end
+  
+  # before(:each) do
+  #   api.defentity(:shirt) do |kind|
+  #     kind.field(:account_key, :type => Hyperion::Types.foreign_key(:account), :db_name => :account_id)
+  #   end
+  # 
+  #   api.defentity(:account) do |kind|
+  #     kind.field(:first_name)
+  #   end
+  # 
+  #   
+  # end
+
+  context 'save' do
+
+    it 'saves a hash and returns it' do
+      record = api.save({:kind => 'testing', :name => 'ann'})
+      record[:kind].should == 'testing'
+      record[:name].should == 'ann'
+    end
+
+    it 'saves an empty record' do
+      record = api.save({:kind => 'testing'})
+      record[:kind].should == 'testing'
+    end
+
+    it 'assigns a key to new records' do
+      record = api.save({:kind => 'testing', :name => 'ann'})
+      record[:key].should_not be_nil
+    end
+
+    it 'saves an existing record' do
+      record1 = api.save({:kind => 'other_testing', :name => 'ann'})
+      record2 = api.save({:kind => 'other_testing', :key => record1[:key]}, :name => 'james')
+      record1[:key].should == record2[:key]
+      api.find_by_kind('other_testing').length.should == 1
+    end
+
+    it 'saves an existing record to be empty' do
+      record1 = api.save({:kind => 'other_testing', :name => 'ann'})
+      record2 = record1.dup
+      record2.delete(:name)
+      record2 = api.save(record2)
+      record1[:key].should == record2[:key]
+      api.find_by_kind('other_testing').length.should == 1
+    end
+
+    def ten_testing_records(kind = 'testing')
+      (1..10).to_a.map do |i|
+        {:kind => kind, :name => i.to_s}
+      end
+    end
+
+    it 'assigns unique keys to each record' do
+      keys = ten_testing_records.map do |record|
+        api.save(record)[:key]
+      end
+      unique_keys = Set.new(keys)
+      unique_keys.length.should == 10
+    end
+
+    it 'can save many records' do
+      saved_records = api.save_many(ten_testing_records)
+      saved_records.length.should == 10
+      saved_names = Set.new(saved_records.map { |record| record[:name] })
+      found_records = api.find_by_kind('testing')
+      found_records.length.should == 10
+      found_names = Set.new(found_records.map { |record| record[:name] })
+      found_names.should == saved_names
+    end
+
+  end
+  
+  context 'create' do
+    
+    it 'saves a hash without a key and returns it' do
+      record = api.create({:kind => 'testing', :name => 'ann'})
+      record[:kind].should == 'testing'
+      record[:name].should == 'ann'
+    end
+    
+    it 'assigns a key to records without keys' do
+      record = api.create({:kind => 'testing', :name => 'ann'})
+      record[:key].should_not be_nil
+    end
+    
+    it 'saves a hash with an unpacked key and returns it' do
+      unpacked_key = "123"
+      record = api.create({:kind => 'testing', :key => unpacked_key, :name => 'ann'})
+      record[:kind].should == 'testing'
+      record[:name].should == 'ann'
+      record[:key].to_s.should == unpacked_key
+    end
+
+    it 'saves an empty record' do
+      record = api.create({:kind => 'testing'})
+      record[:kind].should == 'testing'
+    end
+
+    it 'raises an error with an existing record' do
+      record = api.create({:kind => 'other_testing', :name => 'ann'})
+      expect do
+        api.create({:kind => 'other_testing', :key => record[:key]}, :name => 'james')
+      end.to raise_error
+    end
+
+    def ten_testing_records(kind = 'testing')
+      (1..10).to_a.map do |i|
+        {:kind => kind, :name => i.to_s}
+      end
+    end
+
+    it 'assigns unique keys to each record' do
+      keys = ten_testing_records.map do |record|
+        api.create(record)[:key]
+      end
+      unique_keys = Set.new(keys)
+      unique_keys.length.should == 10
+    end
+
+    it 'can create many records' do
+      saved_records = api.create_many(ten_testing_records)
+      saved_records.length.should == 10
+      saved_names = Set.new(saved_records.map { |record| record[:name] })
+      found_records = api.find_by_kind('testing')
+      found_records.length.should == 10
+      found_names = Set.new(found_records.map { |record| record[:name] })
+      found_names.should == saved_names
+    end
+  end
+
+  def remove_nils(record)
+    record.reduce({}) do |non_nil_record, (field, value)|
+      non_nil_record[field] = value unless value.nil?
+      non_nil_record
+    end
+  end
+
+  context 'find by key' do
+    it 'finds by key' do
+      record = api.save({:kind => 'testing', :inti => 5})
+      remove_nils(api.find_by_key('testing', record[:key])).should == remove_nils(record)
+    end
+
+    it 'returns nil on non-existent keys' do
+      expect(api.find_by_key('testing', 1)).to be_nil
+    end
+  end
+
+  context 'find by kind' do
+
+    it 'filters by the kind' do
+      api.save({:kind => 'other_testing', :inti => 5})
+      found_records = api.find_by_kind('testing')
+      found_records.each do |record|
+        record[:kind].should == 'testing'
+      end
+    end
+
+    it "can't filter on old values" do
+      record = api.save(:kind => 'testing', :inti => 12)
+      api.save(record, :inti => 2)
+      api.find_by_kind('testing', :filters => [[:inti, '=', 12]]).should == []
+    end
+
+    context 'filters' do
+      before :each do
+        api.save_many([
+          {:kind => 'testing', :inti => 1,   :data => 'one'    },
+          {:kind => 'testing', :inti => 12,  :data => 'twelve' },
+          {:kind => 'testing', :inti => 23,  :data => 'twenty3'},
+          {:kind => 'testing', :inti => 34,  :data => 'thirty4'},
+          {:kind => 'testing', :inti => 45,  :data => 'forty5' },
+          {:kind => 'testing', :inti => 1,   :data => 'the one'},
+          {:kind => 'testing', :inti => 44,  :data => 'forty4' },
+          {:kind => 'testing', :inti => nil, :data => 'forty4' }
+        ])
+      end
+
+      [
+        [[[:inti, '<', 25]], [1, 12, 23], :inti],
+        [[[:inti, '<=', 25]], [1, 12, 23], :inti],
+        [[[:inti, '>', 25]], [34, 44, 45], :inti],
+        [[[:inti, '=', 34]], [34], :inti],
+        [[[:inti, '=', nil]], [nil], :inti],
+        [[[:inti, '!=', nil]], [1, 1, 12, 23, 34, 44, 45], :inti],
+        [[[:inti, '!=', 34]], [1, 12, 23, 44, 45, nil], :inti],
+        [[[:inti, 'in', [12, 34]]], [12, 34], :inti],
+        [[[:inti, '>', 10], [:inti, '<', 25]], [12, 23], :inti],
+        [[[:inti, '<', 25], [:inti, '>', 10]], [12, 23], :inti],
+        [[[:inti, '>', 25], [:data, '<', 'thirty4']], [44, 45], :inti],
+        [[[:data, '<', 'thirty4'], [:inti, '>', 25]], [44, 45], :inti],
+        [[[:inti, '>', 10], [:inti, '<', 25], [:inti, '=', 23]], [23], :inti],
+        [[[:inti, '=', 23], [:inti, '>', 10], [:inti, '<', 25]], [23], :inti],
+        [[[:inti, '<', 24], [:inti, '>', 25]], [], :inti],
+        [[[:inti, '!=', 12], [:inti, '!=', 23], [:inti, '!=', 34]], [1, 44, 45, nil], :inti],
+        [[[:data, '<', 'qux']], ['one', 'forty4', 'forty5'], :data],
+        [[[:data, '<=', 'one']], ['one', 'forty4', 'forty5'], :data],
+        [[[:data, '>=', 'thirty4']], ['twelve', 'twenty3', 'thirty4'], :data],
+        [[[:data, '=', 'one']], ['one'], :data],
+        [[[:data, '!=', 'one']], ['the one', 'twelve', 'twenty3', 'thirty4', 'forty4', 'forty5'], :data],
+        [[[:data, 'in', ['one', 'twelve']]], ['one', 'twelve'], :data],
+        [[[:data, '>', 'qux'], [:data, '<', 'qux']], [], :data],
+        [[[:data, '!=', 'one'], [:data, '!=', 'twelve'], [:data, '!=', 'twenty3']], ['the one', 'thirty4', 'forty4', 'forty5'], :data],
+      ].each do |filters, result, field|
+
+          it filters.map(&:to_s).join(', ') do
+            found_records = api.find_by_kind('testing', :filters => filters)
+            ints = Set.new(found_records.map {|record| record[field]})
+            ints.should == Set.new(result)
+          end
+        end
+
+    end
+
+    context 'sorts' do
+      before :each do
+        api.save_many([
+          {:kind => 'testing', :inti => 1,   :data => 'one'    },
+          {:kind => 'testing', :inti => 12,  :data => 'twelve' },
+          {:kind => 'testing', :inti => 23,  :data => 'twenty3'},
+          {:kind => 'testing', :inti => 34,  :data => 'thirty4'},
+          {:kind => 'testing', :inti => 45,  :data => 'forty5' },
+          {:kind => 'testing', :inti => 1,   :data => 'the one'},
+          {:kind => 'testing', :inti => 44,  :data => 'forty4' },
+        ])
+      end
+
+      [
+        [[[:inti, :asc]], [1, 1, 12, 23, 34, 44, 45], :inti],
+        [[[:inti, :desc]], [45, 44, 34, 23, 12, 1, 1], :inti],
+        [[[:data, :asc]], [44, 45, 1, 1, 34, 12, 23], :inti],
+        [[[:data, :desc]], [23, 12, 34, 1, 1, 45, 44], :inti],
+        [[[:inti, :asc], [:data, :asc]], ['one', 'the one', 'twelve', 'twenty3', 'thirty4', 'forty4', 'forty5'], :data],
+        [[[:data, :asc], [:inti, :asc]], [44, 45, 1, 1, 34, 12, 23], :inti]
+      ].each do |sorts, result, field|
+
+        it sorts.map(&:to_s).join(', ') do
+          found_records = api.find_by_kind('testing', :sorts => sorts)
+          ints = found_records.map {|record| record[field]}
+          ints.should == result
+        end
+      end
+    end
+
+    context 'limit and offset' do
+      before :each do
+        api.save_many([
+          {:kind => 'testing', :inti => 1,   :data => 'one'    },
+          {:kind => 'testing', :inti => 12,  :data => 'twelve' },
+          {:kind => 'testing', :inti => 23,  :data => 'twenty3'},
+          {:kind => 'testing', :inti => 34,  :data => 'thirty4'},
+          {:kind => 'testing', :inti => 45,  :data => 'forty5' },
+          {:kind => 'testing', :inti => 1,   :data => 'the one'},
+          {:kind => 'testing', :inti => 44,  :data => 'forty4' },
+        ])
+      end
+
+      specify 'offset n returns results starting at the nth record' do
+        found_records = api.find_by_kind('testing', :sorts => [[:inti, :asc]], :offset => 2)
+        ints = found_records.map {|record| record[:inti]}
+        ints.should == [12, 23, 34, 44, 45]
+      end
+
+      specify 'limit n takes only the first n records' do
+        found_records = api.find_by_kind('testing', :sorts => [[:inti, :asc]], :limit => 2)
+        found_records.map {|record| record[:inti]}.should == [1, 1]
+
+        found_records = api.find_by_kind('testing', :sorts => [[:inti, :asc]], :limit => 1_000_000)
+        found_records.map {|record| record[:inti]}.should == [1, 1, 12, 23, 34, 44, 45]
+      end
+
+      [
+        [{:limit => 2, :offset => 2}, [[:inti, :asc]],  [12, 23]],
+        [{:limit => 2, :offset => 4}, [[:inti, :asc]],  [34, 44]],
+        [{:limit => 2}              , [[:inti, :desc]], [45, 44]],
+        [{:limit => 2, :offset => 2}, [[:inti, :desc]], [34, 23]],
+        [{:limit => 2, :offset => 4}, [[:inti, :desc]], [12,  1]],
+      ].each do |constraints, sorts, result|
+          example constraints.inspect do
+            found_records = api.find_by_kind 'testing', constraints.merge(:sorts => sorts)
+            found_records.map { |record| record[:inti] }.should == result
+          end
+        end
+    end
+  end
+
+  context 'delete' do
+
+    before :each do
+      api.save_many([
+        {:kind => 'testing', :inti => 1,   :data => 'one'    },
+        {:kind => 'testing', :inti => 12,  :data => 'twelve' },
+        {:kind => 'testing', :inti => nil, :data => 'twelve' }
+      ])
+    end
+
+    it 'deletes by key' do
+      records = api.find_by_kind('testing')
+      record_to_delete = records.first
+      api.delete_by_key(record_to_delete[:kind], record_to_delete[:key]).should be_nil
+      api.find_by_kind('testing').should_not include(record_to_delete)
+    end
+
+    it 'returns nil when deleting non-existent keys' do
+      expect(api.delete_by_key('testing', 1)).to be_nil
+    end
+
+    context 'filters' do
+
+      [
+        [[], []],
+        [[[:inti, '=', 1]], [12, nil]],
+        [[[:data, '=', 'one']], [12, nil]],
+        [[[:inti, '!=', 1]], [1]],
+        [[[:inti, '<=', 1]], [12, nil]],
+        [[[:inti, '<=', 2]], [12, nil]],
+        [[[:inti, '>=', 2]], [1, nil]],
+        [[[:inti, '>', 1]], [1, nil]],
+        [[[:inti, 'in', [1]]], [12, nil]],
+        [[[:inti, 'in', [1, nil]]], [12]],
+        [[[:inti, 'in', [1, 12]]], [nil]],
+        [[[:inti, '=', 2]], [1, 12, nil]],
+        [[[:inti, '=', nil]], [1, 12]],
+        [[[:inti, '!=', nil]], [nil]],
+      ].each do |filters, result|
+        it filters.inspect do
+          api.delete_by_kind('testing', :filters => filters)
+          intis = api.find_by_kind('testing').map {|r| r[:inti]}
+          intis.should =~ result
+        end
+      end
+
+    end
+  end
+
+  context 'count' do
+
+    before :each do
+      api.save_many([
+        {:kind => 'testing', :inti => 1,   :data => 'one'    },
+        {:kind => 'testing', :inti => 12,  :data => 'twelve' },
+        {:kind => 'testing', :inti => nil, :data => 'twelve' }
+      ])
+    end
+
+    context 'filters' do
+
+      [
+        [[], 3],
+        [[[:inti, '=', 1]], 1],
+        [[[:data, '=', 'one']], 1],
+        [[[:inti, '!=', 1]], 2],
+        [[[:inti, '<=', 1]], 1],
+        [[[:inti, '<=', 2]], 1],
+        [[[:inti, '>=', 2]], 1],
+        [[[:inti, '>', 1]], 1],
+        [[[:inti, 'in', [1]]], 1],
+        [[[:inti, 'in', [1, 12]]], 2],
+        [[[:inti, '=', 2]], 0],
+        [[[:inti, '=', nil]], 1],
+        [[[:inti, '!=', nil]], 2],
+      ].each do |filters, result|
+        it filters.inspect do
+          api.count_by_kind('testing', :filters => filters).should == result
+        end
+      end
+
+    end
+  end
+
+  # context 'foreign_keys' do
+  #   it 'saves records with foreign keys' do
+  #     account = api.save(:kind => :account)
+  #     account_key = account[:key]
+  #     shirt  = api.save(:kind => :shirt, :account_key => account_key)
+  #     found_shirt = api.find_by_key(:shirt, shirt[:key])
+  #     found_account = api.find_by_key(:account, account_key)
+  #     shirt[:account_key].should == account_key
+  #     found_shirt[:account_key].should == account_key
+  #     found_account[:key].should == account_key
+  #   end
+  # 
+  #   it 'filters on foreign keys' do
+  #     account = api.save(:kind => :account)
+  #     account_key = account[:key]
+  #     shirt  = api.save(:kind => :shirt, :account_key => account_key)
+  #     found_shirts = api.find_by_kind(:shirt, :filters => [[:account_key, '=', account_key]])
+  #     found_shirts[0].should == shirt
+  #   end
+  # 
+  #   it 'filters on multiple foreign keys' do
+  #     account_keys = (1..2).map { api.save(:kind => :account)[:key] }
+  #     shirt1 = api.save(:kind => :shirt, :account_key => account_keys[0])
+  #     shirt2 = api.save(:kind => :shirt, :account_key => account_keys[1])
+  #     found_shirts = api.find_by_kind(:shirt, :filters => [[:account_key, 'in', account_keys]])
+  #     found_shirts.should include(shirt1)
+  #     found_shirts.should include(shirt2)
+  #   end
+  # 
+  #   it 'unpacks nil foreign keys' do
+  #     shirt  = api.save(:kind => :shirt, :account_key => nil)
+  #     shirt[:account_key].should be_nil
+  #     found_shirt = api.find_by_kind(:shirt, :filters => [[:account_key, '=', nil]]).first
+  #     found_shirt[:account_key].should be_nil
+  #   end
+  # 
+  #   it 'filters on nil foreign key' do
+  #     account = api.save(:kind => :account)
+  #     shirt  = api.save(:kind => :shirt, :account_key => account[:key])
+  #     nil_shirt  = api.save(:kind => :shirt, :account_key => nil)
+  #     api.find_by_kind(:shirt, :filters => [[:account_key, '=', nil]]).should == [nil_shirt]
+  #   end
+  # end
+end

data/lib/endymion/fake_ds.rb

@@ -0,0 +1,53 @@
+module Endymion
+  class FakeDs
+
+    attr_accessor :saved_records, :created_records, :queries, :key_queries, 
+      :returns, :key_pack_queries,:key_unpack_queries
+
+    def initialize(opts={})
+      @saved_records = []
+      @created_records = []
+      @returns = []
+      @queries = []
+      @key_queries = []
+      @key_pack_queries = []
+      @key_unpack_queries = []
+    end
+
+    def save(records)
+      @saved_records += records
+      returns.shift || []
+    end
+    
+    def create(records)
+      @created_records += records
+      returns.shift || []
+    end
+
+    def find_by_key(kind, key)
+      @key_queries << [kind, key]
+      returns.shift || nil
+    end
+
+    def find(query)
+      @queries << query
+      returns.shift || []
+    end
+
+    def delete_by_key(kind, key)
+      @key_queries << [kind, key]
+      nil
+    end
+
+    def delete(query)
+      @queries << query
+      returns.shift || nil
+    end
+
+    def count(query)
+      @queries << query
+      returns.shift || 0
+    end
+
+  end
+end

data/lib/endymion/field_spec.rb

@@ -0,0 +1,41 @@
+require 'endymion/format'
+
+module Endymion
+  class FieldSpec
+
+    attr_reader :name, :default, :db_name
+
+    def initialize(name, opts={})
+      @name = name
+      @default = opts[:default]
+      @type = opts[:type]
+      @packer = opts[:packer]
+      @unpacker = opts[:unpacker]
+      @db_name = opts[:db_name] ? Format.format_field(opts[:db_name]) : name
+      @api = opts[:api]
+    end
+
+    def pack(value)
+      if @packer && @packer.respond_to?(:call)
+        @packer.call(value)
+      elsif @type
+        type_packer = @api.packer_for(@type)
+        type_packer ? type_packer.call(value) : value
+      else
+        value
+      end
+    end
+
+    def unpack(value)
+      if @unpacker && @unpacker.respond_to?(:call)
+        @unpacker.call(value)
+      elsif @type
+        type_packer = @api.unpacker_for(@type)
+        type_packer ? type_packer.call(value) : value
+      else
+        value
+      end
+    end
+
+  end
+end

data/lib/endymion/filter.rb

@@ -0,0 +1,20 @@
+module Endymion
+  class Filter
+
+    attr_reader :operator, :field, :value
+
+    def initialize(field, operator, value)
+      @operator = operator
+      @field = field
+      @value = value
+    end
+
+    def to_h
+      {
+        :operator => operator,
+        :field    => field,
+        :value    => value
+      }
+    end
+  end
+end

data/lib/endymion/format.rb

@@ -0,0 +1,57 @@
+require 'endymion/util'
+
+module Endymion
+  class Format
+
+    class << self
+
+      def format_kind(kind)
+        Util.snake_case(kind.to_s)
+      end
+
+      def format_field(field)
+        field.to_sym
+      end
+
+      def format_record(record)
+        record = record.reduce({}) do |new_record, (field_name, value)|
+          new_record[format_field(field_name)] = value
+          new_record
+        end
+        record[:kind] = format_kind(record[:kind])
+        record
+      end
+
+      def format_order(order)
+        order.to_sym
+        case order
+        when :desc, 'desc', 'descending'
+          :desc
+        when :asc, 'asc', 'ascending'
+          :asc
+        end
+      end
+
+      def format_operator(operator)
+        case operator
+        when '=', 'eq'
+          '='
+        when '!=', 'not'
+          '!='
+        when '<', 'lt'
+          '<'
+        when '>', 'gt'
+          '>'
+        when '<=', 'lte'
+          '<='
+        when '>=', 'gte'
+          '>='
+        when 'contains?', 'contains', 'in?', 'in'
+          'contains?'
+        end
+      end
+
+    end
+  end
+end
+

data/lib/endymion/key.rb

@@ -0,0 +1,14 @@
+require 'base64'
+require 'uuidtools'
+
+module Endymion
+  class Key
+    class << self
+
+      def generate_id
+        UUIDTools::UUID.random_create.to_s.gsub(/-/, '')
+      end
+
+    end
+  end
+end

data/lib/endymion/kind_spec.rb

@@ -0,0 +1,21 @@
+require 'endymion/format'
+
+module Endymion
+  class KindSpec
+
+    attr_reader :kind, :fields, :api
+
+    def initialize(kind, api)
+      @kind = kind
+      @fields = {}
+      @api = api
+    end
+
+    def field(name, opts={})
+      name = Format.format_field(name)
+      @fields[name] = FieldSpec.new(name, opts.merge(api: api))
+    end
+
+  end
+
+end

data/lib/endymion/memory.rb

@@ -0,0 +1,75 @@
+require 'endymion'
+require 'endymion/key'
+require 'endymion/memory/helper'
+
+module Endymion
+  class Memory
+
+    def initialize(opts={})
+      @store = {}
+    end
+
+    def save(records)
+      records.map do |record|
+        key = Endymion.new?(record) ? generate_key : record[:key]
+        record[:key] = key
+        store[key] = record
+        record
+      end
+    end
+    
+    def create(records)
+      records.map do |record|
+        raise 'duplicate key' if record[:key] && store.key?(record[:key])
+        record[:key] ||= generate_key
+        store[record[:key]] = record
+        record
+      end
+    end
+
+    def find_by_key(kind, key)
+      store[key]
+    end
+
+    def find(query)
+      records = store.values
+      records = filter_kind(query.kind,             records)
+      records = Helper.apply_filters(query.filters, records)
+      records = Helper.apply_sorts(query.sorts,     records)
+      records = Helper.apply_offset(query.offset,   records)
+      records = Helper.apply_limit(query.limit,     records)
+      records
+    end
+
+    def delete_by_key(kind, key)
+      store.delete(key)
+      nil
+    end
+
+    def delete(query)
+      records = find(query)
+      store.delete_if do |key, record|
+        records.include?(record)
+      end
+      nil
+    end
+
+    def count(query)
+      find(query).length
+    end
+
+    private
+
+    attr_reader :store
+
+    def filter_kind(kind, records)
+      records.select do |record|
+        record[:kind] == kind
+      end
+    end
+
+    def generate_key
+      Endymion::Key.generate_id
+    end
+  end
+end

data/lib/endymion/memory/helper.rb

@@ -0,0 +1,52 @@
+module Endymion
+  class Memory
+    module Helper
+      def self.apply_filters(filters, records)
+        records.select do |record|
+          filters.all? do |filter|
+            value = record[filter.field]
+            case filter.operator
+            when '<'; value && value < filter.value
+            when '<='; value && value <= filter.value
+            when '>'; value && value > filter.value
+            when '>='; value && value >= filter.value
+            when '='; value == filter.value
+            when '!='; value != filter.value
+            when 'contains?'; filter.value.include?(value)
+            end
+          end
+        end
+      end
+
+      def self.apply_sorts(sorts, records)
+        records.sort { |record1, record2| compare_records record1, record2, sorts }
+      end
+
+      def self.compare_records(record1, record2, sorts)
+        sorts.each do |sort|
+          result = compare_record record1, record2, sort
+          return result if result
+        end
+        0
+      end
+
+      def self.compare_record(record1, record2, sort)
+        field1, field2 = record1[sort.field], record2[sort.field]
+        field1 == field2                      ?  nil :
+          field1 < field2 && sort.ascending?  ?  -1  :
+          field1 > field2 && sort.descending? ?  -1  : 1
+      end
+
+      def self.apply_offset(offset, records)
+        return records unless offset
+        records.drop offset
+      end
+
+      def self.apply_limit(limit, records)
+        return records unless limit
+        records.take(limit)
+      end
+    end
+  end
+end
+

data/lib/endymion/query.rb

@@ -0,0 +1,24 @@
+module Endymion
+  class Query
+    attr_reader :kind, :filters, :sorts, :limit, :offset
+
+    def initialize(kind, filters, sorts, limit, offset)
+      @kind = kind
+      @filters = filters || []
+      @sorts = sorts || []
+      @limit = limit
+      @offset = offset
+    end
+
+    def to_h
+      {
+        :kind    => kind,
+        :filters => filters.map(&:to_h),
+        :sorts   => sorts.map(&:to_h),
+        :limit   => limit,
+        :offset  => offset
+      }
+    end
+
+  end
+end

data/lib/endymion/sort.rb

@@ -0,0 +1,26 @@
+module Endymion
+  class Sort
+
+    attr_reader :field, :order
+
+    def initialize(field, order)
+      @field = field
+      @order = order
+    end
+
+    def ascending?
+      order == :asc
+    end
+
+    def descending?
+      order == :desc
+    end
+
+    def to_h
+      {
+        :field => field,
+        :order => order
+      }
+    end
+  end
+end

data/lib/endymion/types.rb

@@ -0,0 +1,22 @@
+require 'endymion'
+require 'endymion/format'
+
+module Endymion
+  class Types
+    class << self
+
+      # def foreign_key(kind)
+      #   kind_key = "#{Format.format_kind(kind)}_key".to_sym
+      #   unless Hyperion.packer_defined?(kind_key)
+      #     Hyperion.pack(kind_key) do |key|
+      #       key
+      #     end
+      #     Hyperion.unpack(kind_key) do |key|
+      #       key
+      #     end
+      #   end
+      #   kind_key
+      # end
+    end
+  end
+end

data/lib/endymion/util.rb

@@ -0,0 +1,55 @@
+module Endymion
+  class Util
+
+    class << self
+
+      def camel_case(str)
+        cameled = str.gsub(/[_| |\-][A-Za-z]/) { |a| a[1..-1].upcase } if str
+        uncapitalize(cameled)
+      end
+
+      def class_name(str)
+        capitalize(camel_case(str))
+      end
+
+      def snake_case(str)
+        str.gsub(/([a-z0-9])([A-Z])/, '\1 \2').downcase.gsub(/[ |\-]/, '_') if str
+      end
+
+      def capitalize(str)
+        do_to_first(str) do |first_letter|
+          first_letter.upcase
+        end
+      end
+
+      def uncapitalize(str)
+        do_to_first(str) do |first_letter|
+          first_letter.downcase
+        end
+      end
+
+      def do_to_first(str)
+        if str
+          first = yield(str[0, 1])
+          if str.length > 1
+            last = str[1..-1]
+            first + last
+          else
+            first
+          end
+        end
+      end
+
+      def bind(name, value)
+        old_value = Thread.current[name]
+        begin
+          Thread.current[name] = value
+          yield
+        ensure
+          Thread.current[name] = old_value
+        end
+      end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: endymion
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- David Faber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-29 00:00:00.000000000 Z
+dependencies: []
+description: Key/Value persistence interface.  Forked from Hyperion.
+email: dafaber@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/endymion.rb
+- lib/endymion/api.rb
+- lib/endymion/dev/ds_spec.rb
+- lib/endymion/fake_ds.rb
+- lib/endymion/field_spec.rb
+- lib/endymion/filter.rb
+- lib/endymion/format.rb
+- lib/endymion/key.rb
+- lib/endymion/kind_spec.rb
+- lib/endymion/memory.rb
+- lib/endymion/memory/helper.rb
+- lib/endymion/query.rb
+- lib/endymion/sort.rb
+- lib/endymion/types.rb
+- lib/endymion/util.rb
+homepage: 
+licenses:
+- MIT
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Key/Value persistence interface.  Forked from Hyperion.
+test_files: []