store 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a74cccaaa0ed4cdab16de31489b1ff617729d4c1
-  data.tar.gz: 5e91a636c220af914cb10fd87c91c13b69ccf476
+  metadata.gz: 3cf1280f06ddee3f9d3c5190390bbe8cf29ffd6b
+  data.tar.gz: da7e50bad1b9702421edb0820c1bcb91bc02a481
 SHA512:
-  metadata.gz: e4e07870ed58bdd9502ccda5399c2f356eb80044f1e35e100f2fa3a671056b1f15205bb765e7e54cfa4b5a01f172d845db925335ac78879336970039e04141a7
-  data.tar.gz: 984fc480e714a55d799f2fd57c598e632ddb4477c6a1a5fdc862e50c99f2858a6069992ddcf36f104d47a460eba1ee659c26ec4aa942e5e5a5ae14632968a1c0
+  metadata.gz: 8fa9a6d146e4c87c796032a3b3b7ff7f2db857c60a4d5ad2fd786f5ac405c26f8c61f4741805223bffeb63830a534da7b4ea385b9f6145a3eff46a8df303ed99
+  data.tar.gz: a0850ae08752a3eb8ea76f80640c71b82fa57609ce323844d0250a8e172a615cd482f844bd08f52bf50fed07f0e58aaa25195d99a35c750891de6c48704c1e02

data/example.rb

@@ -1,5 +1,6 @@
 require 'store'
 
+# Models #######################################################################
 class User
   attr_accessor :name
 end
@@ -20,72 +21,131 @@ class Product
   attr_accessor :name, :price
 end
 
-class UserEntityMapper < Struct.new(:store, :user)
-  def mapped
+# EntityMappers ################################################################
+
+class UserEntityMapper < Store::EntityMapper
+  def map(user)
     {
       'name' => user.name
     }
   end
+
+  def unmap(cls, mapped)
+    user = cls.new
+    user.name = mapped['name']
+    user
+  end
 end
 
-class CatalogEntityMapper < Struct.new(:store, :catalog)
-  def mapped
+class CatalogEntityMapper < Store::EntityMapper
+  def map(catalog)
     {
       'editor' => store.save(catalog.editor),
       'name' => catalog.name,
-      'products' => store.save(*catalog.products)
+      'products' => store.save(catalog.products)
     }
   end
+
+  def unmap(cls, mapped)
+    cls.new.tap do |entity|
+      entity.editor   = store.load(mapped['editor'])
+      entity.name     = mapped['name']
+      entity.products = store.load(mapped['products'])
+    end
+  end
 end
 
-class ProductEntityMapper < Struct.new(:store, :product)
-  def mapped
+class ProductEntityMapper < Store::EntityMapper
+  def map(product)
     {
       'name' => product.name,
       'price' => product.price
     }
   end
+
+  def unmap(cls, mapped)
+    user = cls.new
+    user.name = mapped['name']
+    user.price = mapped['price']
+    user
+  end
 end
 
-class UserDataMapper
+# DataMappers###################################################################
+
+class MemoryDataMapper < Store::DataMapper
+  def initialize
+    @items = {}
+    @id = 0
+  end
+
   def insert(data)
-    reference = :"user_#{rand 100}"
-    puts "user_insert[#{reference.inspect}] => #{data.inspect}"
-    reference
+    id = next_id
+    @items[id] = dup(data)
+    id
   end
 
-  def update(reference, data)
-    puts "user_update[#{reference.inspect}] => #{data.inspect}"
-    reference
+  def update(id, data)
+    @items[id] = dup(data)
+    id
   end
-end
 
-class CatalogDataMapper
-  def insert(data)
-    reference = :"catalog_#{rand 100}"
-    puts "catalog_insert[#{reference.inspect}] => #{data.inspect}"
-    reference
+  def delete(id)
+    @items.delete(id)
+    id
+  end
+
+  def single_find(reference)
+    dup(@items[reference])
   end
 
-  def update(reference, data)
-    puts "catalog_update[#{reference.inspect}] => #{data.inspect}"
-    reference
+  def bulk_find(references)
+    @items.values_at(*references).map do |data|
+      dup data
+    end
+  end
+
+  private
+
+  def all
+    @items
+  end
+
+  def next_id
+    @id += 1
+  end
+
+  def dup(data)
+    data and Marshal.load(Marshal.dump(data))
   end
 end
 
-class ProductDataMapper
-  def insert(data)
-    reference = :"product_#{rand 100}"
-    puts "product_insert[#{reference.inspect}] => #{data.inspect}"
-    reference
+class UserDataMapper < MemoryDataMapper
+end
+
+class CatalogDataMapper < MemoryDataMapper
+
+  def select(query)
+    if query.name == :find_by_name
+      select_by_name(query.args.first)
+    else
+      raise "Query not known"
+    end
   end
 
-  def update(reference, data)
-    puts "product_update[#{reference.inspect}] => #{data.inspect}"
-    reference
+  private
+
+  def select_by_name(name)
+    all.select do |id, data|
+      data['name'] == name
+    end
   end
 end
 
+class ProductDataMapper < MemoryDataMapper
+end
+
+# Store instantiation ##########################################################
 
 entities = {
   'User'    => User,
@@ -105,25 +165,40 @@ entity_mappers = {
   'Product' => ProductEntityMapper
 }
 
-store = Store.new(entities, data_mappers, entity_mappers)
+class Repo < Store::Repo
+  def find_catalogs_by_name(name)
+    query Store::Query.new('Catalog', :find_by_name, name)
+  end
+end
+
+repo = Repo.new(entities, data_mappers, entity_mappers)
 
-editor = store.build 'User', :name => 'Mr. Repo'
+# Usage ########################################################################
 
-catalog = store.build 'Catalog', :name => 'Catalog 1', :editor => editor
+editor = repo.build 'User', :name => 'Mr. Repo'
 
-catalog.add_product store.build('Product', :name => 'Pickaxe', :price => 100)
-catalog.add_product store.build('Product', :name => 'Scredriver', :price => 400)
+catalog = repo.build 'Catalog', :name => 'Catalog 1', :editor => editor
+
+catalog.add_product repo.build('Product', :name => 'Pickaxe', :price => 100)
+catalog.add_product repo.build('Product', :name => 'Scredriver', :price => 400)
 
 p 'save call'
-store.save(catalog)
+repo.save(catalog)
 
 catalog.products[0].price = 24
 
 p 'save call'
-store.save(catalog)
+repo.save(catalog)
+
+product = catalog.products.delete_at(1)
+repo.remove product
 
-catalog.products.delete_at(1)
+p catalog
 
 p 'save call'
 # no implicit delete here. is this a problem?
-store.save(catalog)
+repo.save(catalog)
+
+p repo.find_catalogs_by_name('test')
+
+p repo.find_catalogs_by_name('Catalog 1')

data/lib/store/data_mapper.rb

@@ -0,0 +1,27 @@
+class Store
+  class DataMapper
+    def insert(data)
+      raise NotImplementedError
+    end
+
+    def update(reference, data)
+      raise NotImplementedError
+    end
+
+    def delete(reference)
+      raise NotImplementedError
+    end
+
+    def select(query)
+      raise NotImplementedError
+    end
+
+    def single_find(reference)
+      raise NotImplementedError
+    end
+
+    def bulk_find(reference)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/store/entity_mapper.rb

@@ -0,0 +1,20 @@
+class Store
+  class EntityMapper
+    def initialize(store)
+      @store = store
+    end
+
+    def map(entity)
+      raise NotImplementedError
+    end
+
+    def unmap(entity_class, mapped_entity)
+      raise NotImplementedError
+    end
+
+    private
+    def store
+      @store
+    end
+  end
+end

data/lib/store/query.rb

@@ -0,0 +1,11 @@
+class Store
+  class Query
+    attr_reader :entity, :name, :args
+
+    def initialize(entity, name, *args)
+      @entity = entity
+      @name = name
+      @args = args
+    end
+  end
+end

data/lib/store/ref.rb

@@ -0,0 +1,17 @@
+class Store
+  class Ref
+    attr_reader :entity_type, :reference
+
+    def initialize(entity_type, reference)
+      @entity_type = entity_type
+      @reference = reference
+    end
+
+    def ==(other)
+      other.respond_to?(:entity_type) &&
+        other.respond_to?(:reference) &&
+        self.entity_type == other.entity_type &&
+        self.reference == other.reference
+    end
+  end
+end

data/lib/store/repo.rb

@@ -0,0 +1,28 @@
+require 'store/query'
+
+class Store
+  class Repo
+    def initialize(entity_classes, data_mapping, entity_mapping)
+      @store = Store.new(entity_classes, data_mapping, entity_mapping)
+    end
+
+    def build(entity, *args)
+      @store.build(entity, *args)
+    end
+
+    def save(entites)
+      @store.save(entites)
+      true
+    end
+
+    def remove(entity)
+      @store.remove(entity)
+      true
+    end
+
+    private
+    def query(query)
+      @store.query(query)
+    end
+  end
+end

data/lib/store/version.rb

@@ -1,3 +1,3 @@
 class Store
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/store.rb

@@ -1,10 +1,14 @@
-require 'set'
+require 'store/repo'
+require 'store/ref'
+require 'store/entity_mapper'
+require 'store/data_mapper'
 
 class Store
-  def initialize(entity_classes, data_mapping, entity_mapping = {})
+  def initialize(entity_classes, data_mapping, entity_mapping)
     @entity_classes = entity_classes
     @data_mapping = data_mapping
     @entity_mapping = entity_mapping
+
     @entity_references = Hash.new
   end
 
@@ -18,31 +22,20 @@ class Store
     entity
   end
 
-  def save(*entities)
-    references = entities.map do |entity|
-      next nil unless entity
-
-      data_mapper = data_mapper_for_entity(entity)
-      raise_unless_data_mapper_found(entity, data_mapper)
-
-      reference = find_entity_reference(entity)
-      if reference.nil?
-        reference = data_mapper.insert(map_entity entity)
-        save_entity_reference(reference, entity)
-      else
-        data_mapper.update(reference, map_entity(entity))
+  def save(entities)
+    if entities.kind_of? Array
+      entities.map do |entity|
+        save_entity(entity)
       end
-    end
-
-    if references.size == 1
-      references[0]
     else
-      references
+      entity = entities
+      save_entity(entity)
     end
   end
 
   def remove(entity)
     data_mapper = data_mapper_for_entity(entity)
+    raise_unless_data_mapper_found(entity, data_mapper)
 
     reference = find_entity_reference(entity)
     data_mapper.delete(reference)
@@ -52,23 +45,87 @@ class Store
 
   def query(query)
     data_mapper = data_mapper_for_query(query)
+    entity_mapper = entity_mapper_for_query(query)
+    entity_class = @entity_classes[query.entity]
+
+    raise_unless_data_mapper_found(query, data_mapper)
 
-    entities_with_references = data_mapper.select(query) || {}
+    mapped_entities_with_references = data_mapper.select(query) || {}
 
-    entities_with_references.map do |reference, entity|
+    mapped_entities_with_references.map do |reference, mapped_entity|
+      entity = entity_mapper.new(self).unmap(entity_class, mapped_entity)
       save_entity_reference reference, entity
       entity
     end
   end
 
+  def load(refs)
+    if refs.kind_of? Array
+      bulk_load refs
+    else
+      single_load refs
+    end
+  end
+
+  def single_load(ref)
+    data_mapper = data_mapper_for_ref(ref)
+    entity_mapper = entity_mapper_for_ref(ref)
+    entity_class = @entity_classes[ref.entity_type]
+    reference = ref.reference
+
+    mapped_entity = data_mapper.single_find(reference)
+
+    entity = entity_mapper.new(self).unmap(entity_class, mapped_entity)
+    save_entity_reference reference, entity
+    entity
+  end
+
+  def bulk_load(refs)
+    data_mapper = data_mapper_for_ref(refs.first)
+    entity_mapper = entity_mapper_for_ref(refs.first)
+    entity_class = @entity_classes[refs.first.entity_type]
+
+    references = refs.map(&:reference)
+    mapped_entities = data_mapper.bulk_find(references)
+
+    entities = []
+
+    references.each_with_index do |reference, i|
+      mapped_entity = mapped_entities[i]
+
+      entity = entity_mapper.new(self).unmap(entity_class, mapped_entity)
+      save_entity_reference reference, entity
+      entities << entity
+    end
+
+    entities
+  end
+
   private
-  def raise_unless_data_mapper_found(entity, data_mapper)
-    raise "No data_mapper for #{entity.inspect} found" unless data_mapper
+  def save_entity(entity)
+    return nil unless entity
+
+    data_mapper = data_mapper_for_entity(entity)
+    raise_unless_data_mapper_found(entity, data_mapper)
+
+    reference = find_entity_reference(entity)
+    if reference.nil?
+      reference = data_mapper.insert(map_entity entity)
+      save_entity_reference(reference, entity)
+    else
+      data_mapper.update(reference, map_entity(entity))
+    end
+
+    Ref.new(entity_type(entity), reference)
+  end
+
+  def raise_unless_data_mapper_found(source, data_mapper)
+    raise "No data_mapper for #{source.inspect} found" unless data_mapper
   end
 
   def map_entity(entity)
     entity_mapper = entity_mapper_for_entity(entity)
-    entity_mapper.new(self, entity).mapped
+    entity_mapper.new(self).map(entity)
   end
 
   def entity_mapper_for_entity(entity)
@@ -76,6 +133,16 @@ class Store
     entity_mapper_for_type(type)
   end
 
+  def entity_mapper_for_query(query)
+    type = query.entity
+    entity_mapper_for_type(type)
+  end
+
+  def entity_mapper_for_ref(ref)
+    type = ref.entity_type
+    entity_mapper_for_type(type)
+  end
+
   def entity_mapper_for_type(type)
     @entity_mapping[type]
   end
@@ -91,7 +158,12 @@ class Store
   end
 
   def data_mapper_for_query(query)
-    type = query.target
+    type = query.entity
+    data_mapper_for_type type
+  end
+
+  def data_mapper_for_ref(ref)
+    type = ref.entity_type
     data_mapper_for_type type
   end
 

data/spec/store_query_spec.rb

@@ -0,0 +1,11 @@
+require 'helper'
+
+describe 'Store::Query' do
+  it 'consists of three arguments' do
+    query = Store::Query.new('Entity', :query_name, :some, :args)
+
+    assert_equal 'Entity', query.entity
+    assert_equal :query_name, query.name
+    assert_equal [:some, :args], query.args
+  end
+end

data/spec/store_ref_spec.rb

@@ -0,0 +1,16 @@
+require 'helper'
+
+describe 'Store::Ref' do
+  it 'accepts entity_type and reference' do
+    Store::Ref.new('User', 23)
+  end
+
+  it 'is equal if all attributes are equal' do
+    store = Store::Ref.new('User', 23)
+
+    assert_equal Store::Ref.new('User', 23), store
+    refute_equal Store::Ref.new('Player', 23), store
+    refute_equal Store::Ref.new('User', 24), store
+    refute_equal nil, store
+  end
+end

data/spec/store_repo_spec.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+describe 'Store::Repo' do
+  let(:repo) do 
+    repo = Store::Repo.new(:a, :b, :c) 
+    repo.instance_variable_set :@store, store
+    repo
+  end
+
+  let(:store) { MiniTest::Mock.new }
+
+  it 'accepts three args' do
+    Store::Repo.new(:a, :b, :c)
+  end
+
+  it 'delegeates save to @store and swallows result' do
+    store.expect :save, :result, [:arg]
+    assert_equal true, repo.save(:arg)
+  end
+
+  it 'delegates remove to @store and swallows result' do
+    store.expect :remove, :result, [:arg]
+    assert_equal true, repo.remove(:arg)
+  end
+
+  it 'delegates build to @store and returns result' do
+    store.expect :build, :result, [:arg]
+    assert_equal :result, repo.build(:arg)
+
+    store.expect :build, :result, [:arg, :a, :b]
+    assert_equal :result, repo.build(:arg, :a, :b)
+  end
+end

data/spec/store_spec.rb

@@ -1,7 +1,7 @@
 require 'helper'
 
 describe 'store' do
-  let(:store)           { Store.new({}, data_mapping, entity_mapping) }
+  let(:store)           { Store.new({entity_class.name => entity_class}, data_mapping, entity_mapping) }
   let(:data_mapping)    {
     {
       entity_class.name => data_mapper
@@ -13,16 +13,19 @@ describe 'store' do
     }
   }
   let(:data_mapper)     { MiniTest::Mock.new }
-  let(:entity_mapper)   { Struct.new(:store, :entity) do
-    def mapped
+  let(:entity_mapper)   { Struct.new(:store) do
+    def map(entity)
       {
         'email' => entity.email,
         'gender' => entity.gender
       }
     end
+    def unmap(cls, mapped)
+      cls.new(mapped['email'], mapped['gender'])
+    end
   end }
 
-  let(:entity_class)    { Struct.new(:email, :gender) }
+  let(:entity_class)    { Struct.new(:email, :gender) {def self.name; 'name'; end} }
   let(:entity)          { entity_class.new("me@foo.bar", "w") }
   let(:entity_hash)     { {'email' => entity.email, 'gender' => entity.gender} }
 
@@ -38,11 +41,11 @@ describe 'store' do
   it 'delegates second save to update' do
     data_mapper.expect(:insert, :ref1, [entity_hash])
 
-    assert_equal :ref1, store.save(entity)
+    assert_equal Store::Ref.new(entity_class.name, :ref1), store.save(entity)
 
     data_mapper.expect(:update, :ref1, [:ref1, entity_hash])
 
-    assert_equal :ref1, store.save(entity)
+    assert_equal  Store::Ref.new(entity_class.name, :ref1), store.save(entity)
 
     assert data_mapper.verify
   end
@@ -72,50 +75,21 @@ describe 'store' do
     data_mapper.expect(:update, :ref1, [:ref1, e1_hash])
     data_mapper.expect(:insert, :ref2, [e2_hash])
 
-    assert_equal [:ref1, :ref2], store.save(e1, e2)
-
-    assert data_mapper.verify
-  end
-
-  it 'delegates query to select' do
-    data_mapper.expect(:select, nil, [query])
-
-    store.query(query)
+    refs = [ 
+      Store::Ref.new(entity_class.name, :ref1),
+      Store::Ref.new(entity_class.name, :ref2)
+    ]
+    assert_equal refs, store.save([e1, e2])
 
     assert data_mapper.verify
   end
 
-  it 'returns query result' do
-    data_mapper.expect(:select, {:ref1 => :e1, :ref2 => :e2}, [query])
-    assert_equal [:e1, :e2], store.query(query)
-  end
-
-  it 'maps nil query result to empty collection' do
-    data_mapper.expect(:select, nil, [query])
-    assert_equal [], store.query(query)
-  end
-
-  it 'only calls update for queried results' do
-    e1 = entity_class.new('e1', 'e1')
-    e1_hash = {'email' => 'e1', 'gender' => 'e1'}
-    e2 = entity_class.new('e2', 'e2')
-    e2_hash = {'email' => 'e2', 'gender' => 'e2'}
-    e3 = entity_class.new('e3', 'e3')
-    e3_hash = {'email' => 'e3', 'gender' => 'e3'}
-
-    data_mapper.expect(:select, {:ref1 => e1, :ref2 => e2}, [query])
-    store.query(query)
-
-    data_mapper.expect(:update, nil, [:ref1, e1_hash])
-    store.save(e1)
-
-    data_mapper.expect(:update, nil, [:ref2, e2_hash])
-    store.save(e2)
-
-    data_mapper.expect(:insert, :ref1, [e3_hash])
-    store.save(e3)
-
-    assert data_mapper.verify
+  it 'returns even one id as array on save with array' do
+    refs = [ 
+      Store::Ref.new(entity_class.name, :ref1)
+    ]
+    data_mapper.expect(:insert, :ref1, [entity_hash])
+    assert_equal refs, store.save([entity])
   end
 
   it 'identifies entity as existent if changed' do
@@ -149,6 +123,55 @@ describe 'store' do
     store.save(entity)
   end
 
+  it 'fails remove if data_mapper not found' do
+    entity = OpenStruct.new(:test => 42)
+    error = assert_raises RuntimeError do
+      store.remove(entity)
+    end
+
+    assert_match(/no data_mapper .* found/i, error.message)
+  end
+
+  describe 'load' do
+    it 'accepts a ref object and delegates to single_find' do
+      data_mapper.expect(:insert, :ref22, [entity_hash])
+      ref = store.save(entity)
+
+      data_mapper.expect(:single_find, entity_hash, [:ref22])
+      assert_equal entity, store.load(ref)
+    end
+
+    it 'accepts an array of ref objects and delegates to bulk_find' do
+      data_mapper.expect(:insert, :ref22, [entity_hash])
+      ref = store.save(entity)
+
+      data_mapper.expect(:bulk_find, [entity_hash], [[:ref22]])
+      assert_equal [entity], store.load([ref])
+    end
+
+    it 'adds single_loaded entites as known entities' do
+      data_mapper.expect(:insert, :ref22, [entity_hash])
+      ref = store.save(entity)
+
+      data_mapper.expect(:single_find, entity_hash, [:ref22])
+      result = store.load(ref)
+
+      data_mapper.expect(:update, :ref22, [:ref22, entity_hash])
+      store.save(result)
+    end
+
+    it 'adds bulk_loaded entites as known entities' do
+      data_mapper.expect(:insert, :ref22, [entity_hash])
+      ref = store.save(entity)
+
+      data_mapper.expect(:bulk_find, [entity_hash], [[:ref22]])
+      result = store.load([ref])
+
+      data_mapper.expect(:update, :ref22, [:ref22, entity_hash])
+      store.save(result[0])
+    end
+  end
+
   describe 'building' do
     Project = Struct.new(:name, :due_date)
 
@@ -170,6 +193,93 @@ describe 'store' do
     end
   end
 
+  describe 'query' do
+    Player = Struct.new(:email, :gender)
+
+    let(:store)               { Store.new({'Player'=>Player}, data_mapping, entity_mapping) }
+    let(:data_mapping)        do
+      {
+        'Player'  => player_data_mapper
+      }
+    end
+    let(:entity_mapping)      do
+      {
+        'Player'  => player_entity_mapper
+      }
+    end
+    let(:player_data_mapper)    { MiniTest::Mock.new }
+    let(:player_entity_mapper)  { Struct.new(:store) do
+      def map(entity)
+        {
+          'email' => entity.email,
+          'gender' => entity.gender
+        }
+      end
+
+      def unmap(cls, mapped)
+        cls.new.tap do |player|
+          player.email = mapped['email']
+          player.gender = mapped['gender']
+        end
+      end
+    end
+    }
+    let(:query) { Store::Query.new('Player', :test_query) }
+
+    it 'delegates query to select' do
+      player_data_mapper.expect(:select, nil, [query])
+
+      store.query(query)
+
+      assert player_data_mapper.verify
+    end
+
+    it 'returns query result' do
+      e1 = Player.new('e1', 'e2')
+      e1_hash = {'email' => 'e1', 'gender' => 'e2'}
+      e2 = Player.new('e3', 'e4')
+      e2_hash = {'email' => 'e3', 'gender' => 'e4'}
+
+      player_data_mapper.expect(:select, {:ref1 => e1_hash, :ref2 => e2_hash}, [query])
+      assert_equal [e1, e2], store.query(query)
+    end
+
+    it 'maps nil query result to empty collection' do
+      player_data_mapper.expect(:select, nil, [query])
+      assert_equal [], store.query(query)
+    end
+
+    it 'only calls update for queried results' do
+      e1_hash = {'email' => 'e1', 'gender' => 'e1'}
+      e2_hash = {'email' => 'e2', 'gender' => 'e2'}
+      e3 = Player.new('e3', 'e3')
+      e3_hash = {'email' => 'e3', 'gender' => 'e3'}
+
+      player_data_mapper.expect(:select, {:ref1 => e1_hash, :ref2 => e2_hash}, [query])
+      e1, e2 = store.query(query)
+
+      player_data_mapper.expect(:update, nil, [:ref1, e1_hash])
+      store.save(e1)
+
+      player_data_mapper.expect(:update, nil, [:ref2, e2_hash])
+      store.save(e2)
+
+      player_data_mapper.expect(:insert, :ref1, [e3_hash])
+      store.save(e3)
+
+      assert player_data_mapper.verify
+    end
+
+    it 'fails if data_mapper not found' do
+      query = OpenStruct.new(:entity => 'NotFound')
+      error = assert_raises RuntimeError do
+        store.query(query)
+      end
+
+      assert_match(/no data_mapper .* found/i, error.message)
+    end
+  end
+
   describe 'nesting' do
     User = Struct.new(:name)
     Group = Struct.new(:name, :users)
@@ -189,28 +299,19 @@ describe 'store' do
     end
     let(:user_data_mapper)    { MiniTest::Mock.new }
     let(:group_data_mapper)   { MiniTest::Mock.new }
-    let(:user_entity_mapper)  { Class.new do
-      def initialize(store, entity)
-        @entity = entity
-      end
-
-      def mapped
+    let(:user_entity_mapper)  { Struct.new(:store) do
+      def map(entity)
         {
-          'name' => @entity.name
+          'name' => entity.name
         }
       end
     end
     }
-    let(:group_entity_mapper)  { Class.new do
-      def initialize(store, entity)
-        @store = store
-        @entity = entity
-      end
-
-      def mapped
+    let(:group_entity_mapper)  { Struct.new(:store) do
+      def map(entity)
         {
-          'name' => @entity.name,
-          'users' => @store.save(*@entity.users)
+          'name' => entity.name,
+          'users' => store.save(entity.users)
         }
       end
     end
@@ -223,7 +324,11 @@ describe 'store' do
       ]
       group = Group.new('g1', users)
 
-      group_data_mapper.expect :insert, nil, [{'name' => 'g1', 'users' => [:ref1, :ref2]}]
+      refs = [ 
+        Store::Ref.new('User', :ref1),
+        Store::Ref.new('User', :ref2)
+      ]
+      group_data_mapper.expect :insert, nil, [{'name' => 'g1', 'users' => refs}]
       user_data_mapper.expect :insert, :ref1, [{'name' => 'u1'}]
       user_data_mapper.expect :insert, :ref2, [{'name' => 'u2'}]
 
@@ -243,7 +348,11 @@ describe 'store' do
       user_data_mapper.expect :insert, :uref1, [{'name' => 'u1'}]
       store.save(users[0])
 
-      group_data_mapper.expect :insert, nil, [{'name' => 'g1', 'users' => [:ref1, :ref2]}]
+      refs = [ 
+        Store::Ref.new('User', :uref1),
+        Store::Ref.new('User', :ref2)
+      ]
+      group_data_mapper.expect :insert, nil, [{'name' => 'g1', 'users' => refs}]
       user_data_mapper.expect :update, :ref1, [:uref1, {'name' => 'u1'}]
       user_data_mapper.expect :insert, :ref2, [{'name' => 'u2'}]
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: store
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Jakob Holderbaum
@@ -65,8 +65,16 @@ files:
 - Rakefile
 - example.rb
 - lib/store.rb
+- lib/store/data_mapper.rb
+- lib/store/entity_mapper.rb
+- lib/store/query.rb
+- lib/store/ref.rb
+- lib/store/repo.rb
 - lib/store/version.rb
 - spec/helper.rb
+- spec/store_query_spec.rb
+- spec/store_ref_spec.rb
+- spec/store_repo_spec.rb
 - spec/store_spec.rb
 - store.gemspec
 homepage: https://github.com/holderbaum/store
@@ -95,4 +103,7 @@ specification_version: 4
 summary: Repository Pattern and Data-Mapper Pattern
 test_files:
 - spec/helper.rb
+- spec/store_query_spec.rb
+- spec/store_ref_spec.rb
+- spec/store_repo_spec.rb
 - spec/store_spec.rb