hyperion-api 0.0.1.alpha1

data/lib/hyperion/api.rb

@@ -0,0 +1,175 @@
+require 'hyperion/query'
+require 'hyperion/filter'
+require 'hyperion/sort'
+
+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
+
+      #   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[snake_case(key.to_s).to_sym] = value
+            new_record
+          end
+          record[:kind] = format_kind(record[:kind])
+          record
+        end
+      end
+
+      def format_kind(kind)
+        snake_case(kind.to_s)
+      end
+
+      def format_field(field)
+        snake_case(field.to_s).to_sym
+      end
+
+      def snake_case(str)
+        separate_camel_humps = str.gsub(/([a-z0-9])([A-Z])/, '\1 \2').downcase
+        separate_camel_humps.gsub(/[ |\-]/, '_')
+      end
+
+    end
+  end
+end

data/lib/hyperion/dev/ds_spec.rb

@@ -0,0 +1,253 @@
+shared_examples_for 'Datastore' do
+
+  def api
+    Hyperion::API
+  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(record1.merge(: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
+
+  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(record[:key])).should == remove_nils(record)
+    end
+  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})
+      found_records = api.find_by_kind('testing')
+      found_records.each do |record|
+        record[:kind].should == 'testing'
+      end
+    end
+
+    context 'filters' do
+
+      [
+        [[[: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, 'in', [12, 34]]], [12, 34], :inti],
+        [[[:inti, '<', 24], [:inti, '>', 25]], [], :inti],
+        [[[:inti, '!=', 12], [:inti, '!=', 23], [:inti, '!=', 34]], [1, 44, 45], :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
+
+      [
+        [[[: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
+      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' }
+      ])
+    end
+
+    it 'deletes by key' do
+      records = api.find_by_kind('testing')
+      record_to_delete = records.first
+      api.delete_by_key(record_to_delete[:key]).should be_nil
+      api.find_by_kind('testing').should_not include(record_to_delete)
+    end
+
+    context 'filters' do
+
+      [
+        [[], []],
+        [[[:inti, '=', 1]], [12]],
+        [[[:data, '=', 'one']], [12]],
+        [[[: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]]
+      ].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' }
+      ])
+    end
+
+    context 'filters' do
+
+      [
+        [[], 2],
+        [[[:inti, '=', 1]], 1],
+        [[[:data, '=', 'one']], 1],
+        [[[:inti, '!=', 1]], 1],
+        [[[:inti, '<=', 1]], 1],
+        [[[:inti, '<=', 2]], 1],
+        [[[:inti, '>=', 2]], 1],
+        [[[:inti, '>', 1]], 1],
+        [[[:inti, 'in', [1]]], 1],
+        [[[:inti, 'in', [1, 12]]], 2],
+        [[[:inti, '=', 2]], 0]
+      ].each do |filters, result|
+        it filters.inspect do
+          api.count_by_kind('testing', :filters => filters).should == result
+        end
+      end
+
+    end
+  end
+end

data/lib/hyperion/dev/memory.rb

@@ -0,0 +1,113 @@
+require 'hyperion/api'
+
+module Hyperion
+  module Dev
+    class Memory
+
+      def initialize
+        @id_counter = 0
+        @store = {}
+      end
+
+      def save(records)
+        records.map do |record|
+          key = API.new?(record) ? generate_key : record[:key]
+          record[:key] = key
+          store[key] = record
+          record
+        end
+      end
+
+      def find_by_key(key)
+        store[key]
+      end
+
+      def find(query)
+        records = store.values
+        records = filter_kind(query.kind,      records)
+        records = apply_filters(query.filters, records)
+        records = apply_sorts(query.sorts,     records)
+        records = apply_offset(query.offset,   records)
+        records = apply_limit(query.limit,     records)
+        records
+      end
+
+      def delete_by_key(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 apply_filters(filters, records)
+        records.select do |record|
+          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 == filter.value
+            when '!='; value != filter.value
+            when 'contains?'; filter.value.include?(value)
+            end
+          end
+        end
+      end
+
+      def apply_sorts(sorts, records)
+        records.sort { |record1, record2| compare_records record1, record2, sorts }
+      end
+
+      def compare_records(record1, record2, sorts)
+        sorts.each do |sort|
+          result = compare_record record1, record2, sort
+          return result if result
+        end
+        0
+      end
+
+      def compare_record(record1, record2, sort)
+        field1, field2 = record1[sort.field], record2[sort.field]
+        field1 == field2                      ?  nil :
+          field1 < field2 && sort.ascending?  ?  -1  :
+          field1 > field2 && sort.descending? ?  -1  : 1
+      end
+
+      def generate_key
+        @id_counter += 1
+      end
+
+      def apply_offset(offset, records)
+        return records unless offset
+        records.drop offset
+      end
+
+      def apply_limit(limit, records)
+        return records unless limit
+        records.take(limit)
+      end
+    end
+  end
+end

data/lib/hyperion/filter.rb

@@ -0,0 +1,12 @@
+module Hyperion
+  class Filter
+
+    attr_reader :operator, :field, :value
+
+    def initialize(field, operator, value)
+      @operator = operator
+      @field = field
+      @value = value
+    end
+  end
+end

data/lib/hyperion/query.rb

@@ -0,0 +1,14 @@
+module Hyperion
+  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
+
+  end
+end

data/lib/hyperion/sort.rb

@@ -0,0 +1,19 @@
+module Hyperion
+  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
+  end
+end

data/spec/hyperion/api_spec.rb

@@ -0,0 +1,203 @@
+require 'hyperion/api'
+require 'hyperion/shared_examples'
+require 'hyperion/fake_ds'
+
+describe Hyperion::API do
+
+  def api
+    Hyperion::API
+  end
+
+  context 'datastore' do
+    it 'will throw an error if the datastore is called before assignment' do
+      expect{ subject.datastore }.to raise_error
+    end
+  end
+
+  context 'new?' do
+    it 'false if a record exists' do
+      api.new?({:key => 1}).should be_false
+    end
+
+    it 'true if a record does not exist' do
+      api.new?({}).should be_true
+    end
+  end
+
+  context 'with fake datastore' do
+    attr_reader :fake_ds
+
+    before :each do
+      @fake_ds = FakeDatastore.new
+      api.datastore = @fake_ds
+    end
+
+    context 'save' do
+
+      it 'saves a record' do
+        record = {:kind => 'one'}
+        api.save(record)
+        api.datastore.saved_records.first.should == record
+      end
+
+      it 'merges the given attrs' do
+        api.save({:kind => 'one'}, :attr =>'value')
+        api.datastore.saved_records.first.should == {:kind => 'one', :attr => 'value'}
+      end
+
+      it 'handles nil input to attrs' do
+        api.save({:kind => 'one'}, nil)
+        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
+        }
+      end
+
+      context 'record formatting on return from datastore' do
+        include_examples 'record formatting', lambda {|record|
+          Hyperion::API.datastore.returns = [[record]]
+          Hyperion::API.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
+        }
+      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
+        }
+      end
+    end
+
+    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
+        }
+      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
+        }
+      end
+
+      context 'parses sorts' do
+
+        def do_find(sort)
+          api.find_by_kind('kind', :sorts => [sort])
+          query = fake_ds.queries.last
+          query.sorts.first
+        end
+
+        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
+          }
+        end
+
+        context 'order' do
+          {
+            'desc'       => :desc,
+            :desc        => :desc,
+            'descending' => :desc,
+            'asc'        => :asc,
+            :asc         => :asc,
+            'ascending'  => :asc
+          }.each_pair do |order, result|
+
+            it "#{order.inspect} to #{result.inspect}" do
+              do_find([:attr, order]).order.should == result
+            end
+
+          end
+        end
+      end
+
+      it 'passes limit to the query' do
+        api.find_by_kind('kind', :limit => 1)
+        fake_ds.queries.first.limit.should == 1
+      end
+
+      it 'passes offset to the query' do
+        api.find_by_kind('kind', :offset => 10)
+        fake_ds.queries.first.offset.should == 10
+      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
+        }
+      end
+    end
+
+    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
+        }
+      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
+        }
+      end
+    end
+
+    it 'deletes by key' do
+      api.delete_by_key('delete_key')
+      fake_ds.key_queries.first.should == 'delete_key'
+    end
+
+    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
+        }
+      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
+        }
+      end
+    end
+
+    context 'find by key' do
+      it 'finds by key' do
+        api.find_by_key('key')
+        fake_ds.key_queries.first.should == 'key'
+      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')
+        }
+      end
+
+    end
+  end
+end

data/spec/hyperion/dev/memory_spec.rb

@@ -0,0 +1,11 @@
+require 'hyperion/dev/memory'
+require 'hyperion/dev/ds_spec'
+
+describe Hyperion::Dev::Memory do
+
+  before :each do
+    Hyperion::API.datastore = Hyperion::Dev::Memory.new
+  end
+
+  it_behaves_like 'Datastore'
+end

data/spec/hyperion/fake_ds.rb

@@ -0,0 +1,43 @@
+class FakeDatastore
+
+  attr_accessor :saved_records, :queries, :key_queries, :returns
+
+  def initialize
+    @saved_records = []
+    @returns = []
+    @queries = []
+    @key_queries = []
+  end
+
+  def save(records)
+    @saved_records += records
+    returns.shift || []
+  end
+
+  def find_by_key(key)
+    @key_queries << key
+    returns.shift || nil
+  end
+
+  def find(query)
+    @queries << query
+    returns.shift || []
+  end
+
+  def delete_by_key(key)
+    @key_queries << key
+    nil
+  end
+
+  def delete(query)
+    @queries << query
+    returns.shift || nil
+  end
+
+  def count(query)
+    @queries << query
+    returns.shift || 0
+  end
+
+end
+

data/spec/hyperion/shared_examples.rb

@@ -0,0 +1,93 @@
+shared_examples_for 'kind formatting' do |actor|
+  {
+    'one'     => 'one',
+    :one      => 'one',
+    :TheKind  => 'the_kind',
+    'TheKind' => 'the_kind'
+  }.each_pair do |kind, result|
+
+    it "#{kind} to #{result}" do
+      actor.call(kind).should == result
+    end
+
+  end
+end
+
+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
+  }.each_pair do |field, result|
+
+    it "#{field.inspect} to #{result.inspect}" do
+      actor.call(field).should == result
+    end
+
+  end
+end
+
+shared_examples_for 'record formatting' do |actor|
+
+  context 'formats kind' do
+    include_examples 'kind formatting', lambda { |kind|
+      record = actor.call({:kind => kind})
+      record[:kind]
+    }
+  end
+
+  context 'formats fields' do
+    include_examples 'field formatting', lambda { |field|
+      record = actor.call({field => 'value'})
+      record.delete(:kind)
+      record.keys.first
+    }
+  end
+end
+
+shared_examples_for 'filtering' do |actor|
+
+  context 'field' do
+    include_examples 'field formatting', lambda { |field|
+      actor.call([field, '=', 0]).field
+    }
+  end
+
+  context 'operator' do
+
+    {
+      '='         => '=',
+      'eq'        => '=',
+      '<'         => '<',
+      'lt'        => '<',
+      '>'         => '>',
+      'gt'        => '>',
+      '<='        => '<=',
+      'lte'       => '<=',
+      '>='        => '>=',
+      'gte'       => '>=',
+      '!='        => '!=',
+      'not'       => '!=',
+      'contains'  => 'contains?',
+      'contains?' => 'contains?',
+      'in?'       => 'contains?',
+      'in'        => 'contains?',
+    }.each_pair do |filter, result|
+
+        it "#{filter} to #{result}" do
+          actor.call([:attr, filter, 0]).operator.should == result
+        end
+
+      end
+  end
+
+  it 'passes the value to the filter' do
+    actor.call([:attr, '=', 0]).value.should == 0
+  end
+end
+

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: hyperion-api
+version: !ruby/object:Gem::Version
+  version: 0.0.1.alpha1
+  prerelease: 6
+platform: ruby
+authors:
+- 8th Light, Inc.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+description: A Generic Persistence API for Ruby
+email:
+- myles@8thlight.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hyperion/dev/memory.rb
+- lib/hyperion/dev/ds_spec.rb
+- lib/hyperion/filter.rb
+- lib/hyperion/api.rb
+- lib/hyperion/sort.rb
+- lib/hyperion/query.rb
+- spec/hyperion/dev/memory_spec.rb
+- spec/hyperion/shared_examples.rb
+- spec/hyperion/api_spec.rb
+- spec/hyperion/fake_ds.rb
+homepage: https://github.com/mylesmegyesi/hyperion-ruby
+licenses:
+- Eclipse Public License
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A Generic Persistence API for Ruby
+test_files:
+- spec/hyperion/dev/memory_spec.rb
+- spec/hyperion/shared_examples.rb
+- spec/hyperion/api_spec.rb
+- spec/hyperion/fake_ds.rb