hyperion-api 0.1.3 → 0.2.0

data/lib/hyperion.rb

@@ -139,22 +139,22 @@ module Hyperion
   def self.build_query(kind, args)
     kind = Format.format_kind(kind)
     filters = build_filters(kind, args[:filters])
-    sorts = build_sorts(args[:sorts])
+    sorts = build_sorts(kind, args[:sorts])
     Query.new(kind, filters, sorts, args[:limit], args[:offset])
   end
 
   def self.build_filters(kind, filters)
     (filters || []).map do |(field, operator, value)|
       operator = Format.format_operator(operator)
-      field = Format.format_field(field)
+      packed_field = pack_field(kind, field)
       value = pack_value(kind, field, value)
-      Filter.new(field, operator, value)
+      Filter.new(packed_field, operator, value)
     end
   end
 
-  def self.build_sorts(sorts)
+  def self.build_sorts(kind, sorts)
     (sorts || []).map do |(field, order)|
-      field = Format.format_field(field)
+      field = pack_field(kind, field)
       order = Format.format_order(order)
       Sort.new(field, order)
     end
@@ -168,8 +168,10 @@ module Hyperion
 
   def self.unpack_record(record)
     if record
-      create_entity(record) do |field_spec, value|
-        field_spec.unpack(value)
+      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
@@ -182,13 +184,24 @@ module Hyperion
 
   def self.pack_record(record)
     if record
-      entity = create_entity(record) do |field_spec, value|
-        field_spec.pack(value || field_spec.default)
+      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 self.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 self.pack_value(kind, field, value)
     kind_spec = kind_spec_for(kind)
     return value unless kind_spec
@@ -236,8 +249,7 @@ module Hyperion
       base_record = {:kind => kind}
       base_record[:key] = key if key
       spec.fields.reduce(base_record) do |new_record, (name, spec)|
-        new_record[name] = yield(spec, record[name])
-        new_record
+        yield(record, new_record, name, spec)
       end
     end
   end
@@ -254,7 +266,7 @@ module Hyperion
 
   class FieldSpec
 
-    attr_reader :name, :default
+    attr_reader :name, :default, :db_name
 
     def initialize(name, opts={})
       @name = name
@@ -262,6 +274,7 @@ module Hyperion
       @type = opts[:type]
       @packer = opts[:packer]
       @unpacker = opts[:unpacker]
+      @db_name = opts[:db_name] ? Format.format_field(opts[:db_name]) : name
     end
 
     def pack(value)

data/lib/hyperion/dev/ds_spec.rb

@@ -26,7 +26,7 @@ shared_examples_for 'Datastore' do
 
     it 'saves an existing record' do
       record1 = api.save({:kind => 'other_testing', :name => 'ann'})
-      record2 = api.save(record1.merge(:name => 'james'))
+      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
@@ -81,17 +81,6 @@ shared_examples_for 'Datastore' do
   end
 
   context 'find by kind' 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
 
     it 'filters by the kind' do
       api.save({:kind => 'other_testing', :inti => 5})
@@ -102,19 +91,33 @@ shared_examples_for 'Datastore' do
     end
 
     it "can't filter on old values" do
-      record = api.find_by_kind('testing', :filters => [[:inti, '=', 12]]).first
+      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, '!=', 34]], [1, 12, 23, 44, 45], :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],
@@ -123,7 +126,7 @@ shared_examples_for 'Datastore' do
         [[[: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], :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],
@@ -144,6 +147,17 @@ shared_examples_for 'Datastore' do
     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],
@@ -163,6 +177,18 @@ shared_examples_for 'Datastore' do
     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]}
@@ -196,8 +222,9 @@ shared_examples_for 'Datastore' do
 
     before :each do
       api.save_many([
-        {:kind => 'testing', :inti => 1,  :data => 'one'    },
-        {:kind => 'testing', :inti => 12, :data => 'twelve' }
+        {:kind => 'testing', :inti => 1,   :data => 'one'    },
+        {:kind => 'testing', :inti => 12,  :data => 'twelve' },
+        {:kind => 'testing', :inti => nil, :data => 'twelve' }
       ])
     end
 
@@ -212,16 +239,19 @@ shared_examples_for 'Datastore' do
 
       [
         [[], []],
-        [[[:inti, '=', 1]], [12]],
-        [[[:data, '=', 'one']], [12]],
+        [[[:inti, '=', 1]], [12, nil]],
+        [[[:data, '=', 'one']], [12, nil]],
         [[[:inti, '!=', 1]], [1]],
-        [[[:inti, '<=', 1]], [12]],
-        [[[:inti, '<=', 2]], [12]],
-        [[[:inti, '>=', 2]], [1]],
-        [[[:inti, '>', 1]], [1]],
-        [[[:inti, 'in', [1]]], [12]],
-        [[[:inti, 'in', [1, 12]]], []],
-        [[[:inti, '=', 2]], [1, 12]]
+        [[[: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)
@@ -237,25 +267,28 @@ shared_examples_for 'Datastore' do
 
     before :each do
       api.save_many([
-        {:kind => 'testing', :inti => 1,  :data => 'one'    },
-        {:kind => 'testing', :inti => 12, :data => 'twelve' }
+        {:kind => 'testing', :inti => 1,   :data => 'one'    },
+        {:kind => 'testing', :inti => 12,  :data => 'twelve' },
+        {:kind => 'testing', :inti => nil, :data => 'twelve' }
       ])
     end
 
     context 'filters' do
 
       [
-        [[], 2],
+        [[], 3],
         [[[:inti, '=', 1]], 1],
         [[[:data, '=', 'one']], 1],
-        [[[:inti, '!=', 1]], 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, '=', 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
@@ -266,7 +299,7 @@ shared_examples_for 'Datastore' do
   end
 
   Hyperion.defentity(:shirt) do |kind|
-    kind.field(:account_key, :type => Hyperion::Types.foreign_key(:account))
+    kind.field(:account_key, :type => Hyperion::Types.foreign_key(:account), :db_name => :account_id)
   end
 
   Hyperion.defentity(:account) do |kind|
@@ -292,5 +325,19 @@ shared_examples_for 'Datastore' do
       found_shirts = api.find_by_kind(:shirt, :filters => [[:account_key, '=', account_key]])
       found_shirts[0].should == shirt
     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/hyperion/format.rb

@@ -10,12 +10,12 @@ module Hyperion
       end
 
       def format_field(field)
-        Util.snake_case(field.to_s).to_sym
+        field.to_sym
       end
 
       def format_record(record)
         record = record.reduce({}) do |new_record, (field_name, value)|
-          new_record[Util.snake_case(field_name.to_s).to_sym] = value
+          new_record[format_field(field_name)] = value
           new_record
         end
         record[:kind] = format_kind(record[:kind])

data/lib/hyperion/key.rb

@@ -15,11 +15,12 @@ module Hyperion
 
       def compose_key(kind, id=nil)
         _id = id.nil? || id.to_s.strip == "" ? generate_id : id.to_s
-        encode_key("#{encode_key(kind.to_s)}:#{encode_key(_id)}")
+        encode_key("#{encode_key(kind.to_s)}:#{_id}")
       end
 
       def decompose_key(key)
-        decode_key(key).split(/:/).map {|part| decode_key(part)}
+        kind, sep, id = decode_key(key).partition(/:/)
+        [decode_key(kind), id]
       end
 
       def generate_id

data/lib/hyperion/memory.rb

@@ -71,10 +71,10 @@ module Hyperion
         filters.all? do |filter|
           value = record[filter.field]
           case filter.operator
-          when '<'; value < filter.value
-          when '<='; value <= filter.value
-          when '>'; value > filter.value
-          when '>='; value >= filter.value
+          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)

data/spec/hyperion/key_spec.rb

@@ -36,9 +36,9 @@ describe Hyperion::Key do
     Hyperion::Key.compose_key(:foo, 1).should == Hyperion::Key.compose_key(:foo, 1)
   end
 
-  it 'composes and decomposes' do
-    kind = "testing"
-    id = "BLODQF0Z1DMEfQr7S3eBwfsX4ku"
+  it 'composes and decomposes a large id' do
+    kind = 'testing'
+    id = 'BLODQF0Z1DMEfQr7S3eBwfsX4ku'
     key = Hyperion::Key.compose_key(kind, id)
     Hyperion::Key.decompose_key(key).should == [kind, id]
   end
@@ -53,4 +53,9 @@ describe Hyperion::Key do
     Hyperion::Key.decompose_key(key).should == ['thing', 'my:key']
   end
 
+  it 'decomposes kinds with a :' do
+    key = Hyperion::Key.compose_key("thing:one", 'key')
+    Hyperion::Key.decompose_key(key).should == ['thing:one', 'key']
+  end
+
 end

data/spec/hyperion/shared_examples.rb

@@ -17,12 +17,12 @@ shared_examples_for 'field formatting' do |actor|
 
   {
     'field' => :field,
-    'Field' => :field,
-    'FieldOne' => :field_one,
-    'SomeBigAttr' => :some_big_attr,
-    :SomeBigAttr => :some_big_attr,
-    'one-two-three' => :one_two_three,
-    'one two three' => :one_two_three
+    'Field' => :Field,
+    'FieldOne' => :FieldOne,
+    'SomeBigAttr' => :SomeBigAttr,
+    :SomeBigAttr => :SomeBigAttr,
+    'one-two-three' => :'one-two-three',
+    'one two three' => :'one two three'
   }.each_pair do |field, result|
 
     it "#{field.inspect} to #{result.inspect}" do
@@ -134,16 +134,24 @@ shared_examples_for 'record packing' do |actor|
   it 'prefers the custom packer over the type packer' do
     result = actor.call(:kind => :packable, :two_packer => 'thing')
     result[:two_packer].should == 'gniht'
+  end
 
-  Hyperion.defentity(:keyed) do |kind|
-    kind.field(:widget,     :type   => Integer)
-    kind.field(:downed,     :type   => :down)
-    kind.field(:thing,      :type   => :nested_type)
-    kind.field(:bauble,     :packer => lambda {|value| value ? value.reverse : value})
-    kind.field(:bad_packer, :packer => true)
-    kind.field(:two_packer, :type   => Integer, :packer => lambda {|value| value ? value.reverse : value})
+  Hyperion.defentity(:pack_field_alias) do |kind|
+    kind.field(:widget, :db_name => :field1)
+    kind.field(:widget1, :db_name => "field2")
+  end
+
+  it 'packs field aliases' do
+    result = actor.call(:kind => :pack_field_alias, :widget => 'ABC')
+    result.should_not have_key(:widget)
+    result[:field1].should == 'ABC'
+  end
+
+  it 'packs field aliases as a string' do
+    result = actor.call(:kind => :pack_field_alias, :widget1 => 'ABC')
+    result.should_not have_key(:widget1)
+    result[:field2].should == 'ABC'
   end
- end
 
   context 'Timestamps' do
 
@@ -248,6 +256,24 @@ shared_examples_for 'record unpacking' do |actor|
     result = actor.call(:kind => :unpackable, :two_packer => 'thing')
     result[:two_packer].should == 'gniht'
   end
+
+  Hyperion.defentity(:unpack_field_alias) do |kind|
+    kind.field(:widget, :db_name => :field1)
+    kind.field(:widget1, :db_name => "field2")
+  end
+
+  it 'unpacks field aliases' do
+    result = actor.call(:kind => :pack_field_alias, :field1 => 'ABC')
+    result.should_not have_key(:field1)
+    result[:widget].should == 'ABC'
+  end
+
+  it 'unpacks field aliases as a string' do
+    result = actor.call(:kind => :pack_field_alias, 'field2' => 'ABC')
+    result.should_not have_key(:field2)
+    result.should_not have_key('field2')
+    result[:widget1].should == 'ABC'
+  end
 end
 
 shared_examples_for 'filtering' do |actor|
@@ -256,6 +282,11 @@ shared_examples_for 'filtering' do |actor|
     include_examples 'field formatting', lambda { |field|
       actor.call([field, '=', 0]).field
     }
+
+    it 'packs db_name aliases' do
+      result = actor.call([:test2, '=', 0])
+      result.field.should == :_test2
+    end
   end
 
   context 'operator' do

data/spec/hyperion_spec.rb

@@ -10,6 +10,7 @@ describe Hyperion do
 
   Hyperion.defentity(:filtering) do |kind|
     kind.field(:test, :packer => lambda { |value| 'i was packed' })
+    kind.field(:test2, :db_name => :_test2)
   end
 
   context 'datastore' do
@@ -172,6 +173,12 @@ describe Hyperion do
             Hyperion.find_by_kind('kind', :sorts => [[field, 'desc']])
             Hyperion.datastore.queries.first.sorts.first.field
           }
+
+          it 'packs db_name aliases' do
+            api.find_by_kind('filtering', :sorts => [[:test2, 'desc']])
+            query = fake_ds.queries.last
+            query.sorts.first.field.should == :_test2
+          end
         end
 
         context 'order' do
@@ -259,42 +266,50 @@ describe Hyperion do
           Hyperion.find_by_key('key')
         }
       end
-
     end
 
-    Hyperion.defentity(:keyed) do |kind|
-      kind.field(:spouse_key, :type => Hyperion::Types.foreign_key(:spouse))
-    end
+    context 'foreign key type' do
 
-    it 'returns the packer key' do
-      Hyperion::Types.foreign_key(:spouse).should == :spouse_key
-    end
+      Hyperion.defentity(:keyed) do |kind|
+        kind.field(:spouse_key, :type => Hyperion::Types.foreign_key(:spouse))
+      end
 
-    it 'defines a packer for the given kind' do
-      Hyperion.packer_defined?(:spouse_key)
-    end
+      it 'returns the packer key' do
+        Hyperion::Types.foreign_key(:spouse).should == :spouse_key
+      end
 
-    it 'defines an unpacker for the given kind' do
-      Hyperion.unpacker_defined?(:spouse_key)
-    end
+      it 'defines a packer for the given kind' do
+        Hyperion.packer_defined?(:spouse_key)
+      end
 
-    it 'formats the kind' do
-      Hyperion::Types.foreign_key(:SPouse).should == :spouse_key
-    end
+      it 'defines an unpacker for the given kind' do
+        Hyperion.unpacker_defined?(:spouse_key)
+      end
 
-    it 'asks the current datastore to pack the key' do
-      key = 'the key to pack'
-      Hyperion.save(:kind => :keyed, :spouse_key => key)
-      fake_ds.key_pack_queries.first[:kind].should == :spouse
-      fake_ds.key_pack_queries.first[:key].should == key
-    end
+      it 'formats the kind' do
+        Hyperion::Types.foreign_key(:SPouse).should == :spouse_key
+      end
+
+      it 'asks the current datastore to pack the key' do
+        key = 'the key to pack'
+        Hyperion.save(:kind => :keyed, :spouse_key => key)
+        fake_ds.key_pack_queries.first[:kind].should == :spouse
+        fake_ds.key_pack_queries.first[:key].should == key
+      end
+
+      it 'handles packing nil' do
+        Hyperion.save(:kind => :keyed, :spouse_key => nil)
+        fake_ds.key_pack_queries.first[:key].should == nil
+      end
+
+      it 'asks the current datastore to unpack the key' do
+        key = 'the key to pack'
+        fake_ds.returns = [[{:kind => :keyed, :spouse_key => key}]]
+        Hyperion.save(:kind => :keyed)
+        fake_ds.key_unpack_queries.first[:kind].should == :spouse
+        fake_ds.key_unpack_queries.first[:key].should == key
+      end
 
-    it 'asks the current datastore to unpack the key' do
-      key = 'the key to pack'
-      fake_ds.returns = [[{:kind => :keyed, :spouse_key => key}]]
-      Hyperion.save(:kind => :keyed)
-      fake_ds.key_unpack_queries.first[:kind].should == :spouse
-      fake_ds.key_unpack_queries.first[:key].should == key
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hyperion-api
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-01 00:00:00.000000000 Z
+date: 2012-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec