hyperion-api 0.0.1.alpha5 → 0.1.0

data/lib/hyperion.rb

@@ -0,0 +1,283 @@
+require 'hyperion/query'
+require 'hyperion/filter'
+require 'hyperion/sort'
+require 'hyperion/util'
+require 'hyperion/format'
+
+module Hyperion
+
+  def self.defentity(kind)
+    kind = Format.format_kind(kind)
+    kind_spec = KindSpec.new(kind)
+    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 self.pack(type, &block)
+    @packers ||= {}
+    @packers[type] = block
+  end
+
+  def self.unpack(type, &block)
+    @unpackers ||= {}
+    @unpackers[type] = block
+  end
+
+  # Sets the active datastore
+  def self.datastore=(datastore)
+    @datastore = datastore
+  end
+
+  # Returns the current datastore instance
+  def self.datastore
+    Thread.current[:datastore] || @datastore || raise('No Datastore installed')
+  end
+
+  # Assigns the datastore within the given block
+  def self.with_datastore(name, opts={})
+    Util.bind(:datastore, new_datastore(name, opts)) do
+      yield
+    end
+  end
+
+  def self.new_datastore(name, opts={})
+    begin
+      require "hyperion/#{name}"
+    rescue LoadError
+      raise "Can't find datastore implementation: #{name}"
+    end
+    ds_klass = Hyperion.const_get(Util.class_name(name.to_s))
+    ds_klass.new(opts)
+  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 self.save(record, attrs={})
+    save_many([record.merge(attrs || {})]).first
+  end
+
+  # Saves multiple records at once.
+  def self.save_many(records)
+    unpack_records(datastore.save(pack_records(records)))
+  end
+
+  # Returns true if the record is new (not saved/doesn't have a :key), false otherwise.
+  def self.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 self.find_by_key(key)
+    unpack_record(datastore.find_by_key(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 self.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 self.delete_by_key(key)
+    datastore.delete_by_key(key)
+  end
+
+  # Deletes all records of the specified kind that match the filters provided.
+  def self.delete_by_kind(kind, args={})
+    datastore.delete(build_query(kind, args))
+  end
+
+  # Counts records of the specified kind that match the filters provided.
+  def self.count_by_kind(kind, args={})
+    datastore.count(build_query(kind, args))
+  end
+
+  private
+
+  def self.build_query(kind, args)
+    kind = Format.format_kind(kind)
+    filters = build_filters(args[:filters])
+    sorts = build_sorts(args[:sorts])
+    Query.new(kind, filters, sorts, args[:limit], args[:offset])
+  end
+
+  def self.build_filters(filters)
+    (filters || []).map do |(field, operator, value)|
+      operator = Format.format_operator(operator)
+      field = Format.format_field(field)
+      Filter.new(field, operator, value)
+    end
+  end
+
+  def self.build_sorts(sorts)
+    (sorts || []).map do |(field, order)|
+      field = Format.format_field(field)
+      order = Format.format_order(order)
+      Sort.new(field, order)
+    end
+  end
+
+  def self.unpack_records(records)
+    records.map do |record|
+      unpack_record(record)
+    end
+  end
+
+  def self.unpack_record(record)
+    if record
+      create_entity(record) do |field_spec, value|
+        field_spec.unpack(value)
+      end
+    end
+  end
+
+  def self.pack_records(records)
+    records.map do |record|
+      pack_record(record)
+    end
+  end
+
+  def self.pack_record(record)
+    if record
+      entity = create_entity(record) do |field_spec, value|
+        field_spec.pack(value || field_spec.default)
+      end
+      update_timestamps(entity)
+    end
+  end
+
+  def self.packer_for(type)
+    @packers[type]
+  end
+
+  def self.unpacker_for(type)
+    @unpackers[type]
+  end
+
+  def self.update_timestamps(record)
+    new?(record) ? update_created_at(record) : update_updated_at(record)
+  end
+
+  def self.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 self.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 self.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)|
+        new_record[name] = yield(spec, record[name])
+        new_record
+      end
+    end
+  end
+
+  def self.kind_spec_for(kind)
+    @kind_specs ||= {}
+    @kind_specs[kind]
+  end
+
+  def self.save_kind_spec(kind_spec)
+    @kind_specs ||= {}
+    @kind_specs[kind_spec.kind] = kind_spec
+  end
+
+  class FieldSpec
+
+    attr_reader :name, :default
+
+    def initialize(name, opts={})
+      @name = name
+      @default = opts[:default]
+      @type = opts[:type]
+      @packer = opts[:packer]
+      @unpacker = opts[:unpacker]
+    end
+
+    def pack(value)
+      if @packer && @packer.respond_to?(:call)
+        @packer.call(value)
+      elsif @type
+        type_packer = Hyperion.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 = Hyperion.unpacker_for(@type)
+        type_packer ? type_packer.call(value) : value
+      else
+        value
+      end
+    end
+
+  end
+
+  class KindSpec
+
+    attr_reader :kind, :fields
+
+    def initialize(kind)
+      @kind = kind
+      @fields = {}
+    end
+
+    def field(name, opts={})
+      name = Format.format_field(name)
+      @fields[name] = FieldSpec.new(name, opts)
+    end
+
+  end
+
+end

data/lib/hyperion/dev/ds_spec.rb

@@ -1,7 +1,7 @@
 shared_examples_for 'Datastore' do
 
   def api
-    Hyperion::API
+    Hyperion
   end
 
   context 'save' do
@@ -99,6 +99,12 @@ shared_examples_for 'Datastore' do
       end
     end
 
+    it "can't filter on old values" do
+      record = api.find_by_kind('testing', :filters => [[:inti, '=', 12]]).first
+      api.save(record, :inti => 2)
+      api.find_by_kind('testing', :filters => [[:inti, '=', 12]]).should == []
+    end
+
     context 'filters' do
 
       [
@@ -108,6 +114,12 @@ shared_examples_for 'Datastore' do
         [[[:inti, '=', 34]], [34], :inti],
         [[[:inti, '!=', 34]], [1, 12, 23, 44, 45], :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], :inti],
         [[[:data, '<', 'qux']], ['one', 'forty4', 'forty5'], :data],
@@ -212,7 +224,7 @@ shared_examples_for 'Datastore' do
         it filters.inspect do
           api.delete_by_kind('testing', :filters => filters)
           intis = api.find_by_kind('testing').map {|r| r[:inti]}
-          intis.should == result
+          intis.should =~ result
         end
       end
 

data/lib/hyperion/filter.rb

@@ -8,5 +8,13 @@ module Hyperion
       @field = field
       @value = value
     end
+
+    def to_h
+      {
+        :operator => operator,
+        :field    => field,
+        :value    => value
+      }
+    end
   end
 end

data/lib/hyperion/format.rb

@@ -0,0 +1,57 @@
+require 'hyperion/util'
+
+module Hyperion
+  class Format
+
+    class << self
+
+      def format_kind(kind)
+        Util.snake_case(kind.to_s)
+      end
+
+      def format_field(field)
+        Util.snake_case(field.to_s).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
+        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/hyperion/key.rb

@@ -6,11 +6,11 @@ module Hyperion
     class << self
 
       def encode_key(value)
-        normalize(Base64.encode64(value))
+        normalize(encode(value))
       end
 
       def decode_key(value)
-        Base64.decode64(denormalize(value))
+        decode(denormalize(value))
       end
 
       def compose_key(kind, id=nil)
@@ -22,14 +22,22 @@ module Hyperion
         decode_key(key).split(/:/).map {|part| decode_key(part)}
       end
 
-      private
-
       def generate_id
         UUIDTools::UUID.random_create.to_s.gsub(/-/, '')
       end
 
+      private
+
+      def encode(str)
+        [str].pack('m').tr('+/','-_').gsub("\n",'')
+      end
+
+      def decode(str)
+        str.tr('-_','+/').unpack('m')[0]
+      end
+
       def normalize(value)
-        value.gsub(/=/, '').chomp
+        value.chomp.gsub(/=/, '')
       end
 
       def denormalize(value)

data/lib/hyperion/memory.rb

@@ -1,4 +1,4 @@
-require 'hyperion/api'
+require 'hyperion'
 
 module Hyperion
   class Memory
@@ -10,7 +10,7 @@ module Hyperion
 
     def save(records)
       records.map do |record|
-        key = API.new?(record) ? generate_key : record[:key]
+        key = Hyperion.new?(record) ? generate_key : record[:key]
         record[:key] = key
         store[key] = record
         record

data/lib/hyperion/query.rb

@@ -10,5 +10,15 @@ module Hyperion
       @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/hyperion/sort.rb

@@ -15,5 +15,12 @@ module Hyperion
     def descending?
       order == :desc
     end
+
+    def to_h
+      {
+        :field => field,
+        :order => order
+      }
+    end
   end
 end

data/lib/hyperion/util.rb

@@ -40,7 +40,16 @@ module Hyperion
         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

data/spec/hyperion/key_spec.rb

@@ -36,6 +36,13 @@ 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"
+    key = Hyperion::Key.compose_key(kind, id)
+    Hyperion::Key.decompose_key(key).should == [kind, id]
+  end
+
   it 'decomposes keys' do
     key = Hyperion::Key.compose_key(:thing, 1)
     Hyperion::Key.decompose_key(key).should == ['thing', '1']

data/spec/hyperion/memory_spec.rb

@@ -4,7 +4,7 @@ require 'hyperion/dev/ds_spec'
 describe Hyperion::Memory do
 
   around :each do |example|
-    Hyperion::API.with_datastore(:memory) do
+    Hyperion.with_datastore(:memory) do
       example.run
     end
   end

data/spec/hyperion/shared_examples.rb

@@ -50,6 +50,197 @@ shared_examples_for 'record formatting' do |actor|
   end
 end
 
+shared_examples_for 'record packing' do |actor|
+  include_examples 'record formatting', lambda { |record|
+    actor.call(record)
+  }
+
+  Hyperion.defentity(:one_field) do |kind|
+    kind.field(:field, :default => 'ABC')
+  end
+
+  it 'only packs fields defined in the entity' do
+    result = actor.call(:kind => :one_field, :field => 'value', :foo => 'bar')
+    result.should == {:kind => 'one_field', :field => 'value'}
+  end
+
+  it 'packs the key field if not defined' do
+    result = actor.call(:kind => :one_field, :key => '1234', :field => 'value', :foo => 'bar')
+    result.should == {:kind => 'one_field', :key => '1234', :field => 'value'}
+  end
+
+  Hyperion.defentity(:two_fields) do |kind|
+    kind.field(:field1, :default => 'ABC')
+    kind.field(:field2, :default => 'CBD')
+  end
+
+  it 'applies defaults' do
+    actor.call(:kind => :two_fields).should == {:kind => 'two_fields', :field1 => 'ABC', :field2 => 'CBD'}
+    actor.call(:kind => :two_fields, :field1 => 'john').should == {:kind => 'two_fields', :field1 => 'john', :field2 => 'CBD'}
+  end
+
+  Hyperion.pack(Integer) do |value|
+    value ? value.to_i : value
+  end
+
+  Hyperion.pack(:up) do |value|
+    value ? value.upcase : value
+  end
+
+  Hyperion.pack(:down) do |value|
+    value ? value.downcase : value
+  end
+
+  Hyperion.defentity('nestedType') do |kind|
+    kind.field(:thingy, :type => Integer, :default => '2')
+    kind.field(:upped, :type => :up, :default => 'asdf')
+  end
+
+  Hyperion.defentity(:packable) 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})
+  end
+
+  it 'packs the given type' do
+    result = actor.call(:kind => :packable, :downed => 'ABC', :widget => '1')
+    result[:downed].should == 'abc'
+    result[:widget].should == 1
+  end
+
+  it 'packs nested types' do
+    result = actor.call(:kind => :packable, :downed => 'ABC', :widget => '1')
+    result[:thing].should == {:kind => 'nested_type', :thingy => 2, :upped => 'ASDF'}
+  end
+
+  it 'packs nested types and merges existing data' do
+    result = actor.call(:kind => :packable, :downed => 'ABC', :widget => '1', :thing => {:upped => 'FDAS'})
+    result[:thing].should == {:kind => 'nested_type', :thingy => 2, :upped => 'FDAS'}
+  end
+
+  it 'packs with custom callables' do
+    result = actor.call(:kind => :packable, :bauble => 'cba')
+    result[:bauble].should == 'abc'
+  end
+
+  it 'custom callable must respond to `call`' do
+    result = actor.call(:kind => :packable, :bad_packer => 'thing')
+    result[:bad_packer].should == 'thing'
+  end
+
+  it 'prefers the custom packer over the type packer' do
+    result = actor.call(:kind => :packable, :two_packer => 'thing')
+    result[:two_packer].should == 'gniht'
+  end
+
+  context 'Timestamps' do
+
+    Hyperion.defentity(:with_time) do |kind|
+      kind.field(:created_at)
+      kind.field(:updated_at)
+    end
+
+    Hyperion.defentity(:without_time) do |kind|
+    end
+
+    before :each do
+      @now = mock(:now)
+      Time.stub(:now).and_return(@now)
+    end
+
+    it 'auto populates created_at if it exists and if the record is new' do
+      old_time = mock(:old_time)
+      actor.call(:kind => :without_time).should == {:kind => 'without_time'}
+      actor.call(:kind => :with_time, :key => '1234', :created_at => old_time)[:created_at].should == old_time
+      actor.call(:kind => :with_time)[:created_at].should == @now
+    end
+
+    it 'auto populates updated_at if it exists and if the record is not new' do
+      old_time = mock(:old_time)
+      actor.call(:kind => :without_time).should == {:kind => 'without_time'}
+      result = actor.call(:kind => :with_time, :key => '1234', :created_at => old_time, :updated_at => old_time)
+      result[:created_at].should == old_time
+      result[:updated_at].should == @now
+    end
+  end
+end
+
+shared_examples_for 'record unpacking' do |actor|
+  include_examples 'record formatting', lambda { |record|
+    actor.call(record)
+  }
+
+  it 'only unpacks defined fields' do
+    result = actor.call(:kind => :one_field, :field => 'value', :foo => 'bar')
+    result.should == {:kind=>"one_field", :field=>"value"}
+  end
+
+  it 'unpacks the key field if not defined' do
+    result = actor.call(:kind => :one_field, :key => '1234', :field => 'value', :foo => 'bar')
+    result.should == {:kind=>"one_field", :key => '1234', :field=>"value"}
+  end
+
+  Hyperion.unpack(Integer) do |value|
+    value ? value.to_i : value
+  end
+
+  Hyperion.unpack(:up) do |value|
+    value ? value.upcase : value
+  end
+
+  Hyperion.unpack(:down) do |value|
+    value ? value.downcase : value
+  end
+
+  Hyperion.defentity('nested') do |kind|
+    kind.field(:thingy, :type => Integer, :default => '2')
+    kind.field(:upped, :type => :up, :default => 'asdf')
+  end
+
+  Hyperion.defentity(:unpackable) do |kind|
+    kind.field(:widget,     :type   => Integer)
+    kind.field(:downed,     :type   => :down)
+    kind.field(:thing,      :type   => :nested_type)
+    kind.field(:bauble,     :unpacker => lambda {|value| value ? value.reverse : value})
+    kind.field(:bad_packer, :unpacker => true)
+    kind.field(:two_packer, :type   => Integer, :unpacker => lambda {|value| value ? value.reverse : value})
+  end
+
+  it 'unpacks the given type' do
+    result = actor.call(:kind => :unpackable, :downed => 'ABC', :widget => '1')
+    result[:downed].should == 'abc'
+    result[:widget].should == 1
+  end
+
+  it 'unpacks nested types' do
+    result = actor.call(:kind => :unpackable, :downed => 'ABC', :widget => '1')
+    result[:thing].should == {:kind => 'nested_type', :thingy => nil, :upped => nil}
+  end
+
+  it 'unpacks nested types and merges existing data' do
+    result = actor.call(:kind => :unpackable, :downed => 'ABC', :widget => '1', :thing => {:upped => 'FDAS'})
+    result[:thing].should == {:kind => 'nested_type', :thingy => nil, :upped => 'FDAS'}
+  end
+
+  it 'unpacks with custom callables' do
+    result = actor.call(:kind => :unpackable, :bauble => 'cba')
+    result[:bauble].should == 'abc'
+  end
+
+  it 'custom callable must respond to `call`' do
+    result = actor.call(:kind => :unpackable, :bad_packer => 'thing')
+    result[:bad_packer].should == 'thing'
+  end
+
+  it 'prefers the custom packer over the type packer' do
+    result = actor.call(:kind => :unpackable, :two_packer => 'thing')
+    result[:two_packer].should == 'gniht'
+  end
+end
+
 shared_examples_for 'filtering' do |actor|
 
   context 'field' do

data/spec/hyperion/util_spec.rb

@@ -51,4 +51,45 @@ describe Hyperion::Util do
     util.class_name('').should == ''
     util.class_name(nil).should == nil
   end
+
+  context 'binding' do
+    it 'assigns the thread local var within the block' do
+      called = false
+      util.bind(:thing, 1) do
+        called = true
+        Thread.current[:thing].should == 1
+      end
+      called.should be_true
+    end
+
+    it 'reassigns the previous value' do
+      Thread.current[:thing].should == nil
+      util.bind(:thing, 1) do
+        util.bind(:thing, 2) do
+          Thread.current[:thing].should == 2
+        end
+        Thread.current[:thing].should == 1
+      end
+      Thread.current[:thing].should == nil
+    end
+
+    it 'reassigns when an exception is thrown' do
+      Thread.current[:thing].should == nil
+      util.bind(:thing, 1) do
+        expect {
+          util.bind(:thing, 2) do
+            raise 'my exception'
+          end
+        }.to raise_error('my exception')
+        Thread.current[:thing].should == 1
+      end
+      Thread.current[:thing].should == nil
+    end
+
+    it 'return the result of the block' do
+      util.bind(:thing, 1) do
+        :return
+      end.should == :return
+    end
+  end
 end

data/spec/{hyperion/api_spec.rb → hyperion_spec.rb}

@@ -1,11 +1,11 @@
-require 'hyperion/api'
+require 'hyperion'
 require 'hyperion/shared_examples'
 require 'hyperion/fake_ds'
 
-describe Hyperion::API do
+describe Hyperion do
 
   def api
-    Hyperion::API
+    Hyperion
   end
 
   context 'datastore' do
@@ -13,11 +13,27 @@ describe Hyperion::API do
       expect{ subject.datastore }.to raise_error
     end
 
-    it 'assigns datastore and returns the result' do
+    it 'assigns the datastore with brute force' do
+      api.datastore = :something
+      api.datastore.should == :something
+      api.datastore = nil
+    end
+
+    it 'assigns datastore with elegance and returns the result' do
       api.with_datastore(:memory) do
+        api.datastore.should be_a(Hyperion::Memory)
         :return
       end.should == :return
     end
+
+    it 'prefers the thread-local datastore over the global datastore' do
+      api.datastore = :something_else
+      api.with_datastore(:memory) do
+        api.datastore.should be_a(Hyperion::Memory)
+      end
+      api.datastore = :something_else
+      api.datastore = nil
+    end
   end
 
   context 'factory' do
@@ -41,10 +57,9 @@ describe Hyperion::API do
   end
 
   context 'with fake datastore' do
-    attr_reader :fake_ds
 
     def fake_ds
-      Thread.current[:datastore]
+      api.datastore
     end
 
     around :each do |example|
@@ -71,34 +86,34 @@ describe Hyperion::API do
         api.datastore.saved_records.first.should == {:kind => 'one'}
       end
 
-      context 'record formatting on save' do
-        include_examples 'record formatting', lambda { |record|
-          Hyperion::API.save(record)
-          Hyperion::API.datastore.saved_records.first
+      context 'record packing on save' do
+        include_examples 'record packing', lambda { |record|
+          Hyperion.save(record)
+          Hyperion.datastore.saved_records.last
         }
       end
 
-      context 'record formatting on return from datastore' do
-        include_examples 'record formatting', lambda {|record|
-          Hyperion::API.datastore.returns = [[record]]
-          Hyperion::API.save({})
+      context 'record unpacking on return from datastore' do
+        include_examples 'record unpacking', lambda {|record|
+          Hyperion.datastore.returns = [[record]]
+          Hyperion.save({})
         }
       end
     end
 
     context 'save many' do
 
-      context 'record formatting on save' do
-        include_examples 'record formatting', lambda { |record|
-          Hyperion::API.save_many([record])
-          Hyperion::API.datastore.saved_records.first
+      context 'record packing on save' do
+        include_examples 'record packing', lambda { |record|
+          Hyperion.save_many([record])
+          Hyperion.datastore.saved_records.last
         }
       end
 
-      context 'record formatting on return from datastore' do
-        include_examples 'record formatting', lambda { |record|
-          Hyperion::API.datastore.returns = [[record]]
-          Hyperion::API.save_many([{}]).first
+      context 'record unpacking on return from datastore' do
+        include_examples 'record unpacking', lambda { |record|
+          Hyperion.datastore.returns = [[record]]
+          Hyperion.save_many([{}]).last
         }
       end
     end
@@ -106,15 +121,15 @@ describe Hyperion::API do
     context 'find by kind' do
       context 'parses kind' do
         include_examples 'kind formatting', lambda { |kind|
-          Hyperion::API.find_by_kind(kind)
-          Hyperion::API.datastore.queries.last.kind
+          Hyperion.find_by_kind(kind)
+          Hyperion.datastore.queries.last.kind
         }
       end
 
       context 'parses filters' do
         include_examples 'filtering', lambda { |filter|
-          Hyperion::API.find_by_kind('kind', :filters => [filter])
-          Hyperion::API.datastore.queries.last.filters.first
+          Hyperion.find_by_kind('kind', :filters => [filter])
+          Hyperion.datastore.queries.last.filters.first
         }
       end
 
@@ -128,8 +143,8 @@ describe Hyperion::API do
 
         context 'field' do
           include_examples 'field formatting', lambda { |field|
-            Hyperion::API.find_by_kind('kind', :sorts => [[field, 'desc']])
-            Hyperion::API.datastore.queries.first.sorts.first.field
+            Hyperion.find_by_kind('kind', :sorts => [[field, 'desc']])
+            Hyperion.datastore.queries.first.sorts.first.field
           }
         end
 
@@ -162,9 +177,9 @@ describe Hyperion::API do
       end
 
       context 'formats records on return from ds' do
-        include_examples 'record formatting', lambda {|record|
-          Hyperion::API.datastore.returns = [[record]]
-          Hyperion::API.find_by_kind('kind').first
+        include_examples 'record unpacking', lambda {|record|
+          Hyperion.datastore.returns = [[record]]
+          Hyperion.find_by_kind('kind').first
         }
       end
     end
@@ -172,15 +187,15 @@ describe Hyperion::API do
     context 'delete by kind' do
       context 'parses kind' do
         include_examples 'kind formatting', lambda { |kind|
-          Hyperion::API.delete_by_kind(kind)
-          Hyperion::API.datastore.queries.last.kind
+          Hyperion.delete_by_kind(kind)
+          Hyperion.datastore.queries.last.kind
         }
       end
 
       context 'parses filters' do
         include_examples 'filtering', lambda { |filter|
-          Hyperion::API.delete_by_kind('kind', :filters => [filter])
-          Hyperion::API.datastore.queries.last.filters.first
+          Hyperion.delete_by_kind('kind', :filters => [filter])
+          Hyperion.datastore.queries.last.filters.first
         }
       end
     end
@@ -193,15 +208,15 @@ describe Hyperion::API do
     context 'count by kind' do
       context 'parses kind' do
         include_examples 'kind formatting', lambda { |kind|
-          Hyperion::API.count_by_kind(kind)
-          Hyperion::API.datastore.queries.last.kind
+          Hyperion.count_by_kind(kind)
+          Hyperion.datastore.queries.last.kind
         }
       end
 
       context 'parses filters' do
         include_examples 'filtering', lambda { |filter|
-          Hyperion::API.count_by_kind('kind', :filters => [filter])
-          Hyperion::API.datastore.queries.last.filters.first
+          Hyperion.count_by_kind('kind', :filters => [filter])
+          Hyperion.datastore.queries.last.filters.first
         }
       end
     end
@@ -213,9 +228,9 @@ describe Hyperion::API do
       end
 
       context 'formats records on return from ds' do
-        include_examples 'record formatting', lambda {|record|
-          Hyperion::API.datastore.returns = [record]
-          Hyperion::API.find_by_key('key')
+        include_examples 'record unpacking', lambda {|record|
+          Hyperion.datastore.returns = [record]
+          Hyperion.find_by_key('key')
         }
       end
 

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: hyperion-api
 version: !ruby/object:Gem::Version
-  version: 0.0.1.alpha5
-  prerelease: 6
+  version: 0.1.0
+  prerelease: 
 platform: ruby
 authors:
-- 8th Light, Inc.
+- Myles Megyesi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-18 00:00:00.000000000 Z
+date: 2012-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -46,24 +46,24 @@ dependencies:
 description: A Generic Persistence API for Ruby
 email:
 - myles@8thlight.com
-- skim@8thlight.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/hyperion/dev/ds_spec.rb
+- lib/hyperion/format.rb
 - lib/hyperion/util.rb
 - lib/hyperion/filter.rb
-- lib/hyperion/api.rb
 - lib/hyperion/key.rb
 - lib/hyperion/memory.rb
 - lib/hyperion/sort.rb
 - lib/hyperion/query.rb
+- lib/hyperion.rb
+- spec/hyperion_spec.rb
 - spec/hyperion/util_spec.rb
 - spec/hyperion/key_spec.rb
 - spec/hyperion/shared_examples.rb
 - spec/hyperion/memory_spec.rb
-- spec/hyperion/api_spec.rb
 - spec/hyperion/fake_ds.rb
 homepage: https://github.com/mylesmegyesi/hyperion-ruby
 licenses:
@@ -81,9 +81,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -91,9 +91,9 @@ signing_key:
 specification_version: 3
 summary: A Generic Persistence API for Ruby
 test_files:
+- spec/hyperion_spec.rb
 - spec/hyperion/util_spec.rb
 - spec/hyperion/key_spec.rb
 - spec/hyperion/shared_examples.rb
 - spec/hyperion/memory_spec.rb
-- spec/hyperion/api_spec.rb
 - spec/hyperion/fake_ds.rb

data/lib/hyperion/api.rb

@@ -1,189 +0,0 @@
-require 'hyperion/query'
-require 'hyperion/filter'
-require 'hyperion/sort'
-require 'hyperion/util'
-
-module Hyperion
-  class API
-
-    class << self
-
-      attr_writer :datastore
-
-      # Sets the thread-local active datastore
-      def datastore=(datastore)
-        Thread.current[:datastore] = datastore
-      end
-
-      # Returns the current thread-local datastore instance
-      def datastore
-        Thread.current[:datastore] || raise('No Datastore installed')
-      end
-
-      # Assigns the datastore within the given block
-      def with_datastore(name, opts={})
-        self.datastore = new_datastore(name, opts)
-        result = yield
-        self.datastore = nil
-        result
-      end
-
-      def new_datastore(name, opts={})
-        begin
-          require "hyperion/#{name}"
-        rescue LoadError
-          raise "Can't find datastore implementation: #{name}"
-        end
-        ds_klass = Hyperion.const_get(Util.class_name(name.to_s))
-        ds_klass.new(opts)
-      end
-
-      #   Saves a record. Any additional parameters will get merged onto the record before it is saved.
-
-      #  Hyperion::API.save({:kind => :foo})
-      #  => {:kind=>"foo", :key=>"<generated key>"}
-      #  Hyperion::API.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)
-        format_records(datastore.save(format_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(key)
-        format_record(datastore.find_by_key(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={})
-        format_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(key)
-        datastore.delete_by_key(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
-
-      private
-
-      def build_query(kind, args)
-        kind = format_kind(kind)
-        filters = build_filters(args[:filters])
-        sorts = build_sorts(args[:sorts])
-        Query.new(kind, filters, sorts, args[:limit], args[:offset])
-      end
-
-      def build_filters(filters)
-        (filters || []).map do |(field, operator, value)|
-          operator = format_operator(operator)
-          field = format_field(field)
-          Filter.new(field, operator, value)
-        end
-      end
-
-      def build_sorts(sorts)
-        (sorts || []).map do |(field, order)|
-          field = format_field(field)
-          order = format_order(order)
-          Sort.new(field, order)
-        end
-      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
-
-      def format_records(records)
-        records.map do |record|
-          format_record(record)
-        end
-      end
-
-      def format_record(record)
-        if record
-          record = record.reduce({}) do |new_record, (key, value)|
-            new_record[Util.snake_case(key.to_s).to_sym] = value
-            new_record
-          end
-          record[:kind] = format_kind(record[:kind])
-          record
-        end
-      end
-
-      def format_kind(kind)
-        Util.snake_case(kind.to_s)
-      end
-
-      def format_field(field)
-        Util.snake_case(field.to_s).to_sym
-      end
-
-    end
-  end
-end