store 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2fb59e3196b45ee40cb5849579674cbfa39f774b
-  data.tar.gz: 7ca7cd693fd58a40ced7e5b8aa2b47fa13ba0aef
+  metadata.gz: 05c439b9355bde8a092b4bfea3d5d95630177d3b
+  data.tar.gz: 459439d12096f896eea821d5e57a6a57e7b28217
 SHA512:
-  metadata.gz: dacc4c3b8bda6ec9d4cb7cc7276ff99f760c25e564a07d3ee1a0b82a032ff7d971ea199a8cb9264c8aefc4afbed8c70a36e0db17d621d13cd65c9e56ed17baa2
-  data.tar.gz: 7b33a857f9250a3391a2873872448ad2cc112e562b57ad44d317717910972132b3ecfb8b9b4b670437e445b9146cc004461726519161255e8f98d2f9e43821c3
+  metadata.gz: 575737d172c70e5338cffe8c85d3b6361a14b775e06ae061f285746832a358f9e9c871c80b80ed1708fdfcd49cc1bca31e431bd5af8e6fe15b3c9f1ab168e9f3
+  data.tar.gz: c5e233707425ffd8c367c7f4beea0c12748820c893fe1bfb08597f182df19bad000efdd376fed4d47c87eaeaa69f569012ed974080d7f062a80c847e5849a9a8

data/.gitignore

@@ -0,0 +1,3 @@
+doc
+pkg
+coverage

data/README.md

@@ -1,6 +1,6 @@
 # Store
 
-TODO: Write a gem description
+Implementations for using the Repository- and Data Mapper Pattern in ruby
 
 ## Installation
 
@@ -18,7 +18,7 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+See example.rb for capabilities of the current implementation.
 
 ## Contributing
 

data/example.rb

@@ -0,0 +1,90 @@
+require 'store'
+
+class Catalog 
+  attr_accessor :name, :products
+
+  def products
+    @products ||= []
+  end
+
+  def add_product(product)
+    products << product
+  end
+end
+
+class Product
+  attr_accessor :name, :price
+end
+
+class CatalogEntityMapper < Struct.new(:store, :catalog)
+  def mapped
+    {
+      'name' => catalog.name,
+      'products' => store.save(*catalog.products)
+    }
+  end
+end
+
+class ProductEntityMapper < Struct.new(:store, :product)
+  def mapped
+    {
+      'name' => product.name,
+      'price' => product.price
+    }
+  end
+end
+
+class CatalogDataMapper
+  def insert(data)
+    reference = :"catalog_#{rand 100}"
+    puts "catalog_insert[#{reference.inspect}] => #{data.inspect}"
+    reference
+  end
+
+  def update(reference, data)
+    puts "catalog_update[#{reference.inspect}] => #{data.inspect}"
+    reference
+  end
+end
+
+class ProductDataMapper
+  def insert(data)
+    reference = :"product_#{rand 100}"
+    puts "product_insert[#{reference.inspect}] => #{data.inspect}"
+    reference
+  end
+
+  def update(reference, data)
+    puts "product_update[#{reference.inspect}] => #{data.inspect}"
+    reference
+  end
+end
+
+
+entities = {
+  'Catalog' => Catalog,
+  'Product' => Product
+}
+
+data_mappers = {
+  'Catalog' => CatalogDataMapper.new,
+  'Product' => ProductDataMapper.new
+}
+
+entity_mappers = {
+  'Catalog' => CatalogEntityMapper,
+  'Product' => ProductEntityMapper
+}
+
+store = Store.new(entities, data_mappers, entity_mappers)
+
+catalog = store.build('Catalog', :name => 'Catalog 1')
+
+catalog.add_product store.build('Product', :name => 'Pickaxe', :price => 100)
+catalog.add_product store.build('Product', :name => 'Scredriver', :price => 400)
+
+store.save(catalog)
+
+catalog.products[0].price = 24
+
+store.save(catalog)

data/lib/store.rb

@@ -1,73 +1,107 @@
 require 'set'
 
 class Store
-  def initialize(mapping)
-    @mapping = mapping
+  def initialize(entity_classes, data_mapping, entity_mapping = {})
+    @entity_classes = entity_classes
+    @data_mapping = data_mapping
+    @entity_mapping = entity_mapping
     @existing_entities = Set.new
+    @entity_references = Hash.new
   end
 
-  def save(entity)
-    mapper = mapper_for_entity(entity)
+  def build(entity_class_name, attributes = {})
+    entity = @entity_classes[entity_class_name].new
 
-    if new_entity?(entity)
-      mapper.insert(entity)
-      mark_entities_as_existing([entity])
-    else
-      mapper.update(entity)
+    attributes.each do |attribute, value|
+      entity.public_send :"#{attribute}=", value
+    end
+
+    entity
+  end
+
+  def save(*entities)
+    entities.map do |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
     end
   end
 
   def remove(entity)
-    mapper = mapper_for_entity(entity)
+    data_mapper = data_mapper_for_entity(entity)
+
+    reference = find_entity_reference(entity)
+    data_mapper.delete(reference)
 
-    mapper.delete(entity)
-    mark_entity_as_remove(entity)
+    remove_entity_reference entity
   end
 
   def query(query)
-    mapper = mapper_for_query(query)
+    data_mapper = data_mapper_for_query(query)
 
-    entities = mapper.select(query) || []
-    mark_entities_as_existing(entities)
+    entities_with_references = data_mapper.select(query) || {}
 
-    entities
+    entities_with_references.map do |reference, entity|
+      save_entity_reference reference, entity
+      entity
+    end
   end
 
   private
-  def mapper_for_entity(entity)
+  def raise_unless_data_mapper_found(entity, data_mapper)
+    raise "No data_mapper for #{entity.inspect} found" unless data_mapper
+  end
+
+  def map_entity(entity)
+    entity_mapper = entity_mapper_for_entity(entity)
+    entity_mapper.new(self, entity).mapped
+  end
+
+  def entity_mapper_for_entity(entity)
     type = entity_type(entity)
-    mapper_for_type type
+    entity_mapper_for_type(type)
+  end
+
+  def entity_mapper_for_type(type)
+    @entity_mapping[type]
   end
 
   def entity_type(entity)
     entity_class = entity.class
-    entity_class.entity_type
+    entity_class.name
   end
 
-  def mapper_for_query(query)
-    type = query.target
-    mapper_for_type type
+  def data_mapper_for_entity(entity)
+    type = entity_type(entity)
+    data_mapper_for_type type
   end
 
-  def mapper_for_type(type)
-    @mapping[type]
+  def data_mapper_for_query(query)
+    type = query.target
+    data_mapper_for_type type
   end
 
-  def new_entity?(entity)
-    !existing_entity?(entity)
+  def data_mapper_for_type(type)
+    @data_mapping[type]
   end
 
-  def existing_entity?(entity)
-    @existing_entities.include? entity.object_id
+  def find_entity_reference(entity)
+    @entity_references[entity.object_id]
   end
 
-  def mark_entities_as_existing(entities)
-    entities.each do |entity|
-      @existing_entities << entity.object_id
-    end
+  def save_entity_reference(reference, entity)
+    @entity_references[entity.object_id] = reference
   end
 
-  def mark_entity_as_remove(entity)
-    @existing_entities.delete entity.object_id
+  def remove_entity_reference(entity)
+    @entity_references.delete entity.object_id
   end
+
 end

data/lib/store/version.rb

@@ -1,3 +1,3 @@
 class Store
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/helper.rb

@@ -1,6 +1,12 @@
+if ENV['coverage']
+  require 'simplecov'
+  SimpleCov.start
+end
+
 require 'minitest/autorun'
 require 'minitest/spec'
 
 require 'ostruct'
 
 require 'store'
+

data/spec/store_spec.rb

@@ -1,107 +1,235 @@
 require 'helper'
 
 describe 'store' do
-  let(:store)   { Store.new(mapping) }
-  let(:mapping) {
+  let(:store)           { Store.new({}, data_mapping, entity_mapping) }
+  let(:data_mapping)    {
     {
-      :entity1 => entity1_mapper
+      entity_class.name => data_mapper
     }
   }
-  let(:entity1_mapper) { MiniTest::Mock.new }
-
-  let(:entity_class)  { Struct.new(:email, :gender) do
-    def self.entity_type
-      :entity1
+  let(:entity_mapping)  {
+    {
+      entity_class.name => entity_mapper
+    }
+  }
+  let(:data_mapper)     { MiniTest::Mock.new }
+  let(:entity_mapper)   { Struct.new(:store, :entity) do
+    def mapped
+      {
+        'email' => entity.email,
+        'gender' => entity.gender
+      }
     end
   end }
 
-  let(:entity)  { entity_class.new(nil, nil) }
+  let(:entity_class)    { Struct.new(:email, :gender) }
+  let(:entity)          { entity_class.new("me@foo.bar", "w") }
+  let(:entity_hash)     { {'email' => entity.email, 'gender' => entity.gender} }
 
-  let(:query)   { OpenStruct.new(:target => :entity1) }
+  let(:query)           { OpenStruct.new(:target => entity_class.name) }
 
   it 'delegates save to insert' do
-    entity1_mapper.expect(:insert, nil, [entity])
+    data_mapper.expect(:insert, nil, [entity_hash])
     store.save(entity)
 
-    assert entity1_mapper.verify
+    assert data_mapper.verify
   end
 
   it 'delegates second save to update' do
-    entity1_mapper.expect(:insert, nil, [entity])
+    data_mapper.expect(:insert, :ref1, [entity_hash])
 
     store.save(entity)
 
-    entity1_mapper.expect(:update, nil, [entity])
+    data_mapper.expect(:update, nil, [:ref1, entity_hash])
 
     store.save(entity)
 
-    assert entity1_mapper.verify
+    assert data_mapper.verify
+  end
+
+  it 'fails save if data_mapper not found' do
+    entity = OpenStruct.new(:test => 42)
+    error = assert_raises RuntimeError do
+      store.save(entity)
+    end
+
+    assert_match(/no data_mapper .* found/i, error.message)
   end
 
   it 'delegates query to select' do
-    entity1_mapper.expect(:select, nil, [query])
+    data_mapper.expect(:select, nil, [query])
 
     store.query(query)
 
-    assert entity1_mapper.verify
+    assert data_mapper.verify
   end
 
   it 'returns query result' do
-    entity1_mapper.expect(:select, [:e1, :e2], [query])
+    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
-    entity1_mapper.expect(:select, nil, [query])
+    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'}
 
-    entity1_mapper.expect(:select, [e1, e2], [query])
+    data_mapper.expect(:select, {:ref1 => e1, :ref2 => e2}, [query])
     store.query(query)
 
-    entity1_mapper.expect(:update, nil, [e1])
+    data_mapper.expect(:update, nil, [:ref1, e1_hash])
     store.save(e1)
 
-    entity1_mapper.expect(:update, nil, [e2])
+    data_mapper.expect(:update, nil, [:ref2, e2_hash])
     store.save(e2)
 
-    entity1_mapper.expect(:insert, nil, [e3])
+    data_mapper.expect(:insert, :ref1, [e3_hash])
     store.save(e3)
 
-    assert entity1_mapper.verify
+    assert data_mapper.verify
   end
 
   it 'identifies entity as existent if changed' do
     entity.gender = 'm'
 
-    entity1_mapper.expect(:insert, nil, [entity])
+    data_mapper.expect(:insert, :ref1, [entity_hash])
     store.save(entity)
 
     entity.gender = 'w'
 
-    entity1_mapper.expect(:update, nil, [entity])
+    data_mapper.expect(:update, nil, [:ref1, entity_hash.merge('gender' => 'w')])
     store.save(entity)
   end
 
   it 'delegates remove to delete' do
-    entity1_mapper.expect(:delete, nil, [entity])
+    data_mapper.expect(:insert, :ref1, [entity_hash])
+    store.save(entity)
+
+    data_mapper.expect(:delete, nil, [:ref1])
     store.remove(entity)
   end
 
   it 'treats entity as new after delete' do
-    entity1_mapper.expect(:insert, nil, [entity])
+    data_mapper.expect(:insert, :ref22, [entity_hash])
     store.save(entity)
 
-    entity1_mapper.expect(:delete, nil, [entity])
+    data_mapper.expect(:delete, nil, [:ref22])
     store.remove(entity)
 
-    entity1_mapper.expect(:insert, nil, [entity])
+    data_mapper.expect(:insert, :ref23, [entity_hash])
     store.save(entity)
   end
 
+  describe 'building' do
+    Project = Struct.new(:name, :due_date)
+
+    let(:store)               { Store.new({'Project' => Project}, {}, {}) }
+
+    it 'should instanciate an empty object' do
+      project = store.build 'Project'
+
+      assert_nil project.name
+      assert_nil project.due_date
+    end
+
+    it 'should prepopulate attributes' do
+      due_date = Time.now
+      project = store.build 'Project', :name => 'foo', :due_date => due_date
+
+      assert_equal 'foo', project.name
+      assert_equal due_date, project.due_date
+    end
+  end
+
+  describe 'nesting' do
+    User = Struct.new(:name)
+    Group = Struct.new(:name, :users)
+
+    let(:store)               { Store.new({}, data_mapping, entity_mapping) }
+    let(:data_mapping)        do
+      {
+        'User'  => user_data_mapper,
+        'Group' => group_data_mapper
+      }
+    end
+    let(:entity_mapping)      do
+      {
+        'User'  => user_entity_mapper,
+        'Group' => group_entity_mapper
+      }
+    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
+        {
+          'name' => @entity.name
+        }
+      end
+    end
+    }
+    let(:group_entity_mapper)  { Class.new do
+      def initialize(store, entity)
+        @store = store
+        @entity = entity
+      end
+
+      def mapped
+        {
+          'name' => @entity.name,
+          'users' => @store.save(*@entity.users)
+        }
+      end
+    end
+    }
+
+    it 'should map saves for nested users' do
+      users = [
+        User.new('u1'),
+        User.new('u2')
+      ]
+      group = Group.new('g1', users)
+
+      group_data_mapper.expect :insert, nil, [{'name' => 'g1', 'users' => [:ref1, :ref2]}]
+      user_data_mapper.expect :insert, :ref1, [{'name' => 'u1'}]
+      user_data_mapper.expect :insert, :ref2, [{'name' => 'u2'}]
+
+      store.save(group)
+
+      assert group_data_mapper.verify
+      assert user_data_mapper.verify
+    end
+
+    it 'should map insert and update separated' do
+      users = [
+        User.new('u1'),
+        User.new('u2')
+      ]
+      group = Group.new('g1', users)
+
+      user_data_mapper.expect :insert, :uref1, [{'name' => 'u1'}]
+      store.save(users[0])
+
+      group_data_mapper.expect :insert, nil, [{'name' => 'g1', 'users' => [:ref1, :ref2]}]
+      user_data_mapper.expect :update, :ref1, [:uref1, {'name' => 'u1'}]
+      user_data_mapper.expect :insert, :ref2, [{'name' => 'u2'}]
+
+      store.save(group)
+
+      assert group_data_mapper.verify
+      assert user_data_mapper.verify
+    end
+  end
 end

data/store.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Jakob Holderbaum"]
   spec.email         = ["jakob@featurefabrik.de"]
   spec.summary       = %q{Repository Pattern and Data-Mapper Pattern}
-  spec.homepage      = ""
+  spec.homepage      = "https://github.com/holderbaum/store"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
@@ -19,4 +19,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "simplecov"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: store
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Jakob Holderbaum
@@ -38,6 +38,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - jakob@featurefabrik.de
@@ -45,16 +59,17 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .gitignore
 - Gemfile
 - README.md
 - Rakefile
+- example.rb
 - lib/store.rb
 - lib/store/version.rb
-- spec.rb
 - spec/helper.rb
 - spec/store_spec.rb
 - store.gemspec
-homepage: ''
+homepage: https://github.com/holderbaum/store
 licenses:
 - MIT
 metadata: {}

data/spec.rb

@@ -1,59 +0,0 @@
-class Store
-  def catalog
-    @catalog ||= CatalogStore.new
-  end
-
-  def product
-    @product ||= ProductStore.new
-  end
-end
-
-class CatalogStore
-  def build(attrs = {})
-    Catalog.new(attrs)
-  end
-
-  def save(catalog)
-  end
-end
-
-class ProductStore
-  def build(attrs = {})
-    Product.new(attrs)
-  end
-end
-
-
-class Entity
-  def initialize(attrs = {})
-    attrs.each do |attr, value|
-      self.public_send :"#{attr}=", value
-    end
-  end
-end
-
-class Catalog < Entity
-  attr_accessor :name, :products
-
-  def products
-    @products ||= []
-  end
-
-  def add_product(product)
-    products << product
-  end
-end
-
-class Product < Entity
-  attr_accessor :name, :price
-end
-
-
-catalog = store.catalog.build(:name => 'Catalog 1')
-
-catalog.add_product store.product.build(:name => 'Pickaxe', :price => 100)
-catalog.add_product store.product.build(:name => 'Scredriver', :price => 400)
-
-p catalog
-
-store.save(catalog)