entitymap 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in entity_map.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 Peter Vandenabeele (http://vandenabeele.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,155 @@
+# EntityMap
+
+The concept is to have an in-memory entity-relationsip model that has unique and
+unambiguous mapping of the (business) entities and the relationships between them,
+but still closely linked to the SQL concept of a foreign key as unambiguous
+implementation of a relationship between tables).
+
+In ActiveRecord, there is an IdentityMap being developed, but even with
+IdentityMap turned on, the belongs_to and has_many relationships between
+Parent and Child are not uniquely mapped to each_other. It is possible to
+have at the same time
+
+``
+daisy.children # => [#<Child:0x9275fe8 @name="Peter">]
+peter.mother # => #<Mother:0x964c518 @name="Maria">
+```
+If I am the child of Daisy, then she should be my mother, huh ...
+
+So, the focus is on unambiguous and easy use of the relationships
+in an ER model (Entity-Relationship model) where the reciprocity
+of the 2 directions of the relationship is guaranteed correct.
+
+Mapping this form of ER-model to a database as a persistence
+layer is a second priority, after establishing the correct
+Entity and Relationship behavior.
+
+## Feature wish list
+
+it "handles belongs_to - has_many atomically in 1 place"
+it "has identity_map for entities"
+it "can be persisted in 1 command"
+it "will check validations on _all_ entities before persisting"
+it "allows select list in a form to work cleverly"
+it "has 'live' scopes that are honored in memory"
+it "can be marshalled"
+it "works with a Plain Old Ruby Object"
+it "works with other ORMs (ActiveRecord, Sequel, Datamapper)"
+it "works with SimpleForm 2"
+it "works with JRuby"
+it "works in other languages (Java, ...) ?"
+
+## Usage Example
+
+I want to be able to do:
+
+```ruby
+class Parent
+  include EntityMap #(A)
+  entity_attributes :name #(B)
+end
+
+class Child
+  include EntityMap
+  entity_attributes :name, :grade
+end
+
+Child.relates_to Parent, :as => :mother #(B)
+Child.relates_to Parent, :as => :father #(C)
+
+daisy = Parent.new(:name => "Daisy")
+peter = Child.new(:name => "Peter")
+
+peter.mother = daisy #(D)
+
+peter.mother # => #<Parent:0x961af18 @name="Daisy"> #(E)
+daisy.mother_of # => [#<Child:0x9275fe8 @name="Peter">] #(F)
+
+peter.mother = nil #(G)
+
+peter.mother # => nil
+daisy.mother_of # => [] #(H)
+
+daisy.mother_of << peter #(I)
+
+daisy.mother_of # => [#<Child:0x9275fe8 @name="Peter">]
+peter.mother # => #<Parent:0x961af18 @name="Daisy"> #(J)
+
+maria = Parent.new(:name => "Maria") #(K)
+
+peter.mother = maria
+
+peter.mother # => #<Parent:0x964c518 @name="Maria">
+maria.mother_of # => [#<Child:0x9275fe8 @name="Peter">] #(L)
+daisy.mother_of # => [] #(M)
+
+peter.mother = daisy # back to reality
+
+frans = Parent.new(:name => "Frans")
+peter.father = frans
+
+jan = Child.new(:name => "Jan")
+jan.mother = maria
+jan.father = frans
+
+peter.father.father_of # => [#<Child:0x9275fe8 @name="Peter">, #<Child:0xa49e030 @name="Jan">] #(N)
+
+# adding an implementation of persistence
+
+class Child
+  # not sure if this is enough ActiveRecord
+  include ActiveRecord::Persistence
+  include ActiveRecord::FinderMethods
+end
+
+class Parent
+  # not sure if this is enough ActiveRecord
+  include ActiveRecord::Persistence
+  include ActiveRecord::FinderMethods
+end
+
+EntityMap.save # => true #(O)
+peter.id # => 1 #(P)
+jan.id # => 2
+new_peter = Child.find(1)
+peter.object_id == new_peter.object_id # => true #(Q)
+peter.ref == new_peter.ref # => true #(R)
+```
+
+## Example of the Parent-Child ambiguity in ActiveRecord (4.0.0.beta)
+
+```
+peterv@ASUS:~/b/github/rails/rails/new_app$ cat app/models/*
+class Child < ActiveRecord::Base
+  belongs_to :parent, :inverse_of => :children
+end
+class Parent < ActiveRecord::Base
+  has_many :children, :inverse_of => :parent
+end
+
+peterv@ASUS:~/b/github/rails/rails/new_app$ bundle exec rails c
+Loading development environment (Rails 4.0.0.beta)
+001:0> daisy = Parent.new(:name => "Daisy")
+=> #<Parent id: nil, name: "Daisy", created_at: nil, updated_at: nil>
+002:0> peter = Child.new(:name => "Peter")
+=> #<Child id: nil, name: "Peter", parent_id: nil, created_at: nil, updated_at: nil>
+003:0> peter.parent = daisy
+=> #<Parent id: nil, name: "Daisy", created_at: nil, updated_at: nil>
+004:0> daisy.children
+=> []
+005:0> daisy.children << peter
+=> [#<Child id: nil, name: "Peter", parent_id: nil, created_at: nil, updated_at: nil>]
+006:0> daisy.children
+=> [#<Child id: nil, name: "Peter", parent_id: nil, created_at: nil, updated_at: nil>]
+007:0> maria = Parent.new(:name => "Maria")
+=> #<Parent id: nil, name: "Maria", created_at: nil, updated_at: nil>
+009:0> peter.parent = maria
+=> #<Parent id: nil, name: "Maria", created_at: nil, updated_at: nil>
+010:0> maria.children
+=> []
+011:0> daisy.children
+=> [#<Child id: nil, name: "Peter", parent_id: nil, created_at: nil, updated_at: nil>]
+012:0> peter.parent
+=> #<Parent id: nil, name: "Maria", created_at: nil, updated_at: nil>
+013:0> # giving up ... my mother is "Maria", but I am child of "Daisy" ...
+```

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/entitymap.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "entity_map/version"
+
+Gem::Specification.new do |s|
+  s.name        = "entitymap"
+  s.version     = EntityMap::VERSION
+  s.authors     = ["Peter Vandenabeele"]
+  s.email       = ["peter@vandenabeele.com"]
+  s.homepage    = "http://github.com/petervandenabeele/entitymap"
+  s.summary     = %q{Mapping business entities and relations}
+  s.description = <<DESCRIPTION
+Mapping entities and relations atomically in memory during the
+processing of a business transaction.
+Persistance is executed later in 1 separate atomic transaction.
+DESCRIPTION
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "none for the moment"
+end

data/lib/entity_map/entity/class_methods.rb

@@ -0,0 +1,11 @@
+module EntityMap
+  class Entity
+
+    class << self
+      def object_ref(o)
+        o.object_id
+      end
+    end
+
+  end
+end

data/lib/entity_map/entity/methods.rb

@@ -0,0 +1,11 @@
+module EntityMap
+  class Entity
+
+    def ==(other)
+      Entity.object_ref(self) == Entity.object_ref(other)
+    end
+
+    alias :eql? :==
+
+  end
+end

data/lib/entity_map/entity/new.rb

@@ -0,0 +1,24 @@
+module EntityMap
+  class Entity
+
+    attr_reader :object, :entity_group
+
+    def initialize(object, entity_group)
+      raise "INTERNAL ERROR: Entity.new must have EntityGroup argument" unless EntityGroup === entity_group
+      @entity_group = entity_group
+      @object = object
+      insert_into_entity_hash
+    end
+
+  private
+
+    def insert_into_entity_hash
+      eh = @entity_group.instance_variable_get(:@entity_hash)
+      ref = Entity.object_ref(@object)
+      # object_ref should be unique in the hash
+      raise "INTERNAL ERROR: Second Entity for same object_ref is built" if eh[ref]
+      eh[ref] = self
+    end
+
+  end
+end

data/lib/entity_map/entity.rb

@@ -0,0 +1,3 @@
+require 'entity_map/entity/new'
+require 'entity_map/entity/methods'
+require 'entity_map/entity/class_methods'

data/lib/entity_map/entity_group/find.rb

@@ -0,0 +1,15 @@
+module EntityMap
+  class EntityGroup
+
+    def find(o)
+      @entity_hash[Entity.object_ref(o)]
+    end
+
+    class << self
+      def find(o)
+        single.find(o)
+      end
+    end
+
+  end
+end

data/lib/entity_map/entity_group/initialize.rb

@@ -0,0 +1,9 @@
+module EntityMap
+  class EntityGroup
+
+    def initialize
+      @entity_hash = {}
+    end
+
+  end
+end

data/lib/entity_map/entity_group/single.rb

@@ -0,0 +1,11 @@
+module EntityMap
+  class EntityGroup
+
+    class << self
+      def single
+        @single ||=EntityGroup.new
+      end
+    end
+
+  end
+end

data/lib/entity_map/entity_group.rb

@@ -0,0 +1,3 @@
+require 'entity_map/entity_group/initialize'
+require 'entity_map/entity_group/single'
+require 'entity_map/entity_group/find'

data/lib/entity_map/included.rb

@@ -0,0 +1,10 @@
+module EntityMap
+
+  attr_accessor :entity
+
+  def initialize
+    entity = Entity.new(self, EntityGroup.single)
+    super
+  end
+
+end

data/lib/entity_map/version.rb

@@ -0,0 +1,3 @@
+module EntityMap
+  VERSION = "0.0.1"
+end

data/lib/entity_map.rb

@@ -0,0 +1,4 @@
+require 'entity_map/version'
+require 'entity_map/entity_group'
+require 'entity_map/entity'
+require 'entity_map/included'

data/spec/entity/class_methods_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+module EntityMap
+
+  describe Entity, "class methods" do
+
+    it "object_ref is equal for same objects" do
+      s1 = "test"
+      Entity.object_ref(s1).should == Entity.object_ref(s1)
+    end
+
+    it "object_ref is different for different objects" do
+      s1 = "test"
+      s2 = "test"
+      Entity.object_ref(s1).should_not == Entity.object_ref(s2)
+    end
+
+  end
+
+end

data/spec/entity/include_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module EntityMap
+
+  describe Entity do
+
+    it "creates a new entity when an object in target class is created" do
+      class Test
+        include EntityMap
+      end
+
+      t = Test.new
+      EntityGroup.find(t).should_not be_nil
+    end
+
+    it "raises error when object with same object_ref would be added to hash" do
+      class Test
+        include EntityMap
+      end
+
+      t = Test.new
+      lambda {Entity.new(t, EntityGroup.single)}.should raise_error
+    end
+
+  end
+
+end

data/spec/entity/methods_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module EntityMap
+
+  describe Entity do
+
+    let(:random_object) {Object.new}
+    let(:entity_group) {EntityGroup.new}
+    let(:entity) {Entity.new(random_object, entity_group)}
+
+    it "== uses object_ref to check" do
+      entity.should == entity
+    end
+
+    it "eql uses object_ref to check" do
+      entity.eql?(entity).should be_true
+    end
+
+    it "different entity is not ==" do
+      entity_2=Entity.new("a", entity_group)
+      entity.should_not == entity_2
+    end
+
+  end
+
+end

data/spec/entity/new_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module EntityMap
+
+  describe Entity do
+
+    let(:random_object) {Object.new}
+    let(:entity_group) {EntityGroup.new}
+    let(:entity) {Entity.new(random_object, entity_group)}
+
+    it "new creates new entity" do
+      entity.should_not be_nil
+    end
+
+    it "is part of an EntityGroup" do
+      entity.entity_group.should_not be_nil
+    end
+
+    it "raises an exception when supplied entity_group is not correct" do
+      lambda {Entity.new(random_object,nil)}.should raise_error
+    end
+
+  end
+
+end

data/spec/entity_group/find_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module EntityMap
+
+  describe EntityGroup do
+
+    let(:object) {Object.new}
+
+    it "finds an entity in this group (INSTANCE)" do
+      entity = Entity.new(object,subject)
+      eh = subject.instance_variable_get(:@entity_hash)
+      eh[Entity.object_ref(object)] = entity
+      subject.find(object).should == entity
+    end
+
+    it "finds an entity in all groups (CLASS)" do
+      entity_group = EntityGroup.single
+      entity = Entity.new(object, entity_group)
+      eh = entity_group.instance_variable_get(:@entity_hash)
+      eh[Entity.object_ref(object)] = entity
+      EntityGroup.find(object).should == entity
+    end
+
+  end
+
+end

data/spec/entity_group/new_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+module EntityMap
+
+  describe EntityGroup do
+
+    it "new creates new entity_group" do
+      subject.should_not be_nil
+    end
+  end
+
+end

data/spec/entity_group/single_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module EntityMap
+
+  describe EntityGroup do
+
+    # in a later phase, multiple groups can exist
+    it "single returns an instance of EntityGroup" do
+      EntityGroup.single.should be_a(EntityGroup)
+    end
+
+    it "single returns a singleton instance of EntityGroup" do
+      eg_1 = EntityGroup.single
+      eg_2 = EntityGroup.single
+      eg_1.object_id.should == eg_2.object_id
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'entity_map'

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: entitymap
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Peter Vandenabeele
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &72628490 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *72628490
+description: ! 'Mapping entities and relations atomically in memory during the
+
+  processing of a business transaction.
+
+  Persistance is executed later in 1 separate atomic transaction.
+
+'
+email:
+- peter@vandenabeele.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- entitymap.gemspec
+- lib/entity_map.rb
+- lib/entity_map/entity.rb
+- lib/entity_map/entity/class_methods.rb
+- lib/entity_map/entity/methods.rb
+- lib/entity_map/entity/new.rb
+- lib/entity_map/entity_group.rb
+- lib/entity_map/entity_group/find.rb
+- lib/entity_map/entity_group/initialize.rb
+- lib/entity_map/entity_group/single.rb
+- lib/entity_map/included.rb
+- lib/entity_map/version.rb
+- spec/entity/class_methods_spec.rb
+- spec/entity/include_spec.rb
+- spec/entity/methods_spec.rb
+- spec/entity/new_spec.rb
+- spec/entity_group/find_spec.rb
+- spec/entity_group/new_spec.rb
+- spec/entity_group/single_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/petervandenabeele/entitymap
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Mapping business entities and relations
+test_files: []