entity_mapper 0.0.1.pre.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: df11413fd5a7b625f093890dded86a87bbbc1e2646c331238bdb69c449d73862
+  data.tar.gz: 7090bf0693acf59e74bd14efe0cbc048011abd68d0d42d0f2509456804d7e167
+SHA512:
+  metadata.gz: 30412988950dfeac6f310dc1554d4387367c2301a837c9c6c5711b6307f3681edaf894964575660b04e09206348bde692d44967af0c7bf088b7ceccef7af1187
+  data.tar.gz: 8d44b370c5eba4a2f7228e3f200f8f08e9402fcf6efb9a9c59763c3244686ef3c3a054099f18bbcdb0041db1870b66c1231442389b960b729d1d357f32f4e700

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+spec/internal/db/combustion_test.sqlite
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.3.5
+before_install: gem install bundler -v 1.16.3

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in entity_mapper.gemspec
+gemspec
+gem 'pry'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Jan Jędrychowski
+
+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,187 @@
+# EntityMapper
+
+Entity Mapper gem is inspired by [.NET Entity Framework](https://docs.microsoft.com/en-us/ef/).
+
+It's a persistence/ORM tool that maps data to and from POROs (Plain Old Ruby Objects).
+
+Currently the only supported backend is ActiveRecord.
+
+The gem is under heavy development and not ready for production usage yet. API is very likely to change without any announcements.
+
+## Example
+
+### Setup
+
+Active Record:
+
+```ruby
+class Order < ApplicationRecord
+  has_many :order_items
+end
+
+class OrderItem < ApplicationRecord
+  belongs_to :order
+end
+ActiveRecord::Schema.define do
+  create_table "order_items", force: :cascade do |t|
+    t.string "name"
+    t.integer "price_value"
+    t.string "price_currency"
+    t.integer "quantity"
+    t.integer "order_id"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.index ["order_id"], name: "index_order_items_on_order_id"
+  end
+
+  create_table "orders", force: :cascade do |t|
+    t.string "name"
+    t.boolean "paid"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+  end
+end
+```
+
+Entities:
+
+```ruby
+module Entities
+  class Order
+    attr_accessor :name
+
+    def refund!
+      @paid = false
+    end
+
+    def paid?
+      @paid
+    end
+
+    def add_item(item)
+      items << item
+    end
+
+    def items
+      @items ||= []
+    end
+  end
+end
+
+module Entities
+  class OrderItem
+    attr_accessor :name, :quantity, :price
+
+    def initialize(name, quantity, price)
+      @name = name
+      @quantity = quantity
+      @price = price
+    end
+  end
+end
+
+module Entities
+  Currency = Struct.new(:name)
+end
+
+module Entities
+  class Price
+    attr_reader :value, :currency
+
+    def initialize(value, currency)
+      @value = value
+      @currency = currency
+    end
+  end
+end
+```
+
+Mapping:
+
+```ruby
+Mapping = EntityMapper.map do |m|
+  m.model Entities::Order
+
+  m.property(:name)
+  m.property(:paid)
+
+  m.has_many("items", ar_name: "order_items") do |item_model|
+    item_model.model Entities::OrderItem
+    item_model.property(:quantity)
+    item_model.property(:name)
+
+    item_model.has_one("price", ar_name: nil) do |price_model|
+      price_model.model Entities::Price
+      price_model.property(:value, :price_value)
+      price_model.has_one("currency", ar_name: nil) do |currency_model|
+        currency_model.model Entities::Currency
+        currency_model.property(:name, :price_currency, access: :method)
+      end
+    end
+  end
+end
+```
+
+### Reading
+
+Given persisted model:
+```ruby
+ar_order = ::Order.new(name: "test-name", paid: true)
+ar_order.order_items = [::OrderItem.new(name: "order-item", quantity: 3,  price_value: 3, price_currency: "USD")]
+ar_order.save!
+```
+
+```ruby
+EntityMapper::Transaction.call do |context|
+  mapped_entity = context.read(Mapping, ar_order)
+  pp mapped_entity
+end
+```
+
+Prints (newlines added for visibility):
+```
+#<TestEntities::Order:0x00007fcd5fdd5520 
+  @name="test-name",
+  @paid=true,
+  @items=[
+    #<TestEntities::OrderItem:0x00007fcd60283180
+       @quantity=3,
+       @name="order-item",
+       @price=#<TestEntities::Price:0x00007fcd60282e38 
+         @value=3,
+         @currency=#<struct TestEntities::Currency name="USD">
+       >
+    >
+  ]
+>
+```
+
+
+### Updating
+
+Given `ar_order` from the Reading section:
+
+```ruby
+EntityMapper::Transaction.call do |context|
+  mapped_entity = context.read(Mapping, ar_order)
+  
+  mapped_entity.items.first.quantity = 5
+  mapped_entity.refund!
+  mapped_entity.add_item TestEntities::OrderItem.new("Milk", 1, TestEntities::Price.new(3, TestEntities::Currency.new("USD")))
+end
+```
+
+This automatically persists changes. Sample SQL log:
+```sql
+  OrderItem Update (0.5ms)  UPDATE "order_items" SET "quantity" = ?, "updated_at" = ? WHERE "order_items"."id" = ?  [["quantity", 5], ["updated_at", "2019-07-06 21:25:48.392611"], ["id", 1]]
+  OrderItem Create (0.1ms)  INSERT INTO "order_items" ("name", "price_value", "price_currency", "quantity", "order_id", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?, ?, ?)  [["name", "Milk"], ["price_value", 3], ["price_currency", "USD"], ["quantity", 1], ["order_id", 1], ["created_at", "2019-07-06 21:25:48.396440"], ["updated_at", "2019-07-06 21:25:48.396440"]]
+  Order Update (0.1ms)  UPDATE "orders" SET "paid" = ?, "updated_at" = ? WHERE "orders"."id" = ?  [["paid", 0], ["updated_at", "2019-07-06 21:25:48.398639"], ["id", 1]]
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome!
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "entity_mapper"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/entity_mapper.gemspec

@@ -0,0 +1,32 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "entity_mapper/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "entity_mapper"
+  spec.version       = EntityMapper::VERSION
+  spec.authors       = ["Jan Jędrychowski"]
+  spec.email         = ["jan@jedrychowski.org"]
+
+  spec.summary       = "Map persisted data to and from POROs"
+  spec.description   = "Map persisted data to and from POROs"
+  spec.homepage      = "https://github.com/gogiel/entity_mapper"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "zeitwerk", "~> 2.1"
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "combustion", "~> 1.1"
+  spec.add_development_dependency "rspec-rails"
+  spec.add_development_dependency "rails", "~> 5.2.2"
+  spec.add_development_dependency "sqlite3"
+end

data/lib/entity_mapper.rb

@@ -0,0 +1,14 @@
+require "zeitwerk"
+require_relative "entity_mapper/zeitwerk_inflector"
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector = EntityMapper::ZeitwerkInfelctor.new(__FILE__)
+loader.setup
+
+module EntityMapper
+  def self.map
+    Mapping::Model.new.tap do |mapping|
+      yield Mapping::DSL.new(mapping)
+    end
+  end
+end

data/lib/entity_mapper/access_modes/factory.rb

@@ -0,0 +1,16 @@
+module EntityMapper
+  module AccessModes
+    class Factory
+      def self.call(access_mode, name)
+        case access_mode
+        when :instance_variable
+          AccessModes::InstanceVariable.new(name)
+        when :method
+          AccessModes::Method.new(name)
+        else
+          raise "Access mode #{access_mode} not supported."
+        end
+      end
+    end
+  end
+end

data/lib/entity_mapper/access_modes/instance_variable.rb

@@ -0,0 +1,17 @@
+module EntityMapper
+  module AccessModes
+    class InstanceVariable
+      def initialize(name)
+        @name = name
+      end
+
+      def read_from(object)
+        object.instance_variable_get("@#{@name}")
+      end
+
+      def write_to(object, value)
+        object.instance_variable_set("@#{@name}", value)
+      end
+    end
+  end
+end

data/lib/entity_mapper/access_modes/method.rb

@@ -0,0 +1,17 @@
+module EntityMapper
+  module AccessModes
+    class Method
+      def initialize(name)
+        @name = name
+      end
+
+      def read_from(object)
+        object.send(@name)
+      end
+
+      def write_to(object, value)
+        object.send("#{@name}=", value)
+      end
+    end
+  end
+end

data/lib/entity_mapper/active_record/ar_map.rb

@@ -0,0 +1,17 @@
+module EntityMapper
+  module ActiveRecord
+    class ArMap
+      def initialize
+        @map = {}
+      end
+
+      def add_entity(object, ar_model)
+        @map[object] = ar_model
+      end
+
+      def ar_object(object)
+        @map.fetch(object)
+      end
+    end
+  end
+end

data/lib/entity_mapper/active_record/default_build_strategy.rb

@@ -0,0 +1,13 @@
+module EntityMapper
+  module ActiveRecord
+    class DefaultBuildStrategy
+      def self.call(relation, parent_ar_object, _diff_snapshot)
+        if relation.collection?
+          parent_ar_object.send(relation.ar_name).new
+        else
+          parent_ar_object.send("build_#{relation.ar_name}")
+        end
+      end
+    end
+  end
+end

data/lib/entity_mapper/active_record/read.rb

@@ -0,0 +1,53 @@
+module EntityMapper
+  module ActiveRecord
+    class Read
+      def self.call(mapping, root)
+        new.call(mapping, root)
+      end
+
+      def call(mapping, root)
+        @ar_map = ArMap.new
+        [read(mapping, root), @ar_map]
+      end
+
+      private
+
+      def read(mapping, ar_model)
+        object = mapping.model_class.allocate
+
+        read_properties(mapping.properties, object, ar_model)
+        read_relations(mapping.relations, object, ar_model)
+
+        @ar_map.add_entity(object, ar_model)
+
+        object
+      end
+
+      def read_properties(properties, object, ar_model)
+        properties.each do |property|
+          property.write_to(object, ar_model.send(property.ar_name))
+        end
+      end
+
+      def read_relations(relations, object, ar_model)
+        relations.each do |relation|
+          result = if !relation.virtual?
+
+            if relation.collection?
+              ar_model.send(relation.ar_name).map do |ar_object|
+                read(relation.mapping, ar_object)
+              end
+            else
+              ar_object = ar_model.send(relation.ar_name)
+              read(relation.mapping, ar_object)
+            end
+          else
+            read(relation.mapping, ar_model)
+          end
+
+          relation.write_to(object, result)
+        end
+      end
+    end
+  end
+end

data/lib/entity_mapper/active_record/update.rb

@@ -0,0 +1,84 @@
+# TMP in propgress
+
+module EntityMapper
+  module ActiveRecord
+    class Update
+      # @param mapping [EntityMapper::Mapping]
+      # @param snapshot_diff [EntityMapper::ObjectDiffSnapshot]
+      # @param ar_root [ActiveRecord::Base]
+      # @param ar_map [EntityMapper::ArMap]
+      def self.call(mapping, snapshot_diff, ar_root, ar_map)
+        new(ar_map).call(mapping, snapshot_diff, ar_root)
+      end
+
+      def initialize(ar_map)
+        @ar_map = ar_map
+      end
+
+      def call(mapping, snapshot_diff, ar_root)
+        update(mapping, snapshot_diff, ar_root)
+      end
+
+      private
+
+      def update(mapping, snapshot_diff, ar_object)
+        if snapshot_diff.removed? # TODO - check if is virtual
+          ar_object.destroy
+        else
+          map_properties(mapping.properties, snapshot_diff.object, ar_object)
+          map_relations(mapping.relations, snapshot_diff, ar_object)
+          ar_object.tap &:save!
+        end
+      end
+
+      def map_properties(properties, object, ar_object)
+        properties.each do |property|
+          ar_object.send("#{property.ar_name}=", property.read_from(object))
+        end
+      end
+
+      def map_relations(relations, snapshot_diff, parent_ar_object)
+        relations.each do |relation|
+          relation_snapshot = snapshot_diff.relations_map[relation]
+
+          if relation.virtual?
+            if relation_snapshot.new?
+              # TODO support STI/polymporphism
+              update(relation.mapping, relation_snapshot, parent_ar_object)
+            elsif relation_snapshot.removed?
+              # TODO ??
+            else
+              update(relation.mapping, relation_snapshot, parent_ar_object)
+            end
+          else
+            if relation.collection?
+              relation_snapshot.each do |relation_item_diff_snapshot|
+                if relation_item_diff_snapshot.new?
+                  # TODO support STI/polymporphism
+                  ar_object = build(relation, parent_ar_object, relation_item_diff_snapshot)
+                  update(relation.mapping, relation_item_diff_snapshot, ar_object)
+                else
+                  ar_object = @ar_map.ar_object(relation_item_diff_snapshot.object)
+                  update(relation.mapping, relation_item_diff_snapshot, ar_object)
+                end
+              end
+            else
+              if relation_snapshot.new?
+                # TODO support STI/polymporphism
+                ar_object = build(relation, parent_ar_object, relation_item_diff_snapshot)
+                update(relation.mapping, relation_snapshot, ar_object)
+              else
+                ar_object = @ar_map.ar_object(relation_snapshot.object)
+                update(relation.mapping, relation_snapshot, ar_object)
+              end
+            end
+          end
+        end
+      end
+
+      def build(relation, parent_ar_object, relation_item_diff_snapshot)
+        relation.build_strategy.call(relation, parent_ar_object, relation_item_diff_snapshot)
+      end
+    end
+  end
+end

data/lib/entity_mapper/mapping/dsl.rb

@@ -0,0 +1,33 @@
+module EntityMapper
+  module Mapping
+    class DSL
+      def initialize(mapping)
+        @mapping = mapping
+      end
+
+      attr_reader :mapping
+
+      def model(klass)
+        mapping.model_class = klass
+      end
+
+      def property(name, ar_name = nil, **options)
+        mapping.add_property Property.new(name, ar_name || name, options)
+      end
+
+      def has_one(relation_name, ar_name:, **options)
+        inner_mapping = Mapping::Model.new.tap do |mapping|
+          yield DSL.new(mapping)
+        end
+        mapping.add_relation HasOneRelation.new(relation_name, ar_name, inner_mapping, options)
+      end
+
+      def has_many(relation_name, ar_name:, **options)
+        inner_mapping = Mapping::Model.new.tap do |mapping|
+          yield DSL.new(mapping)
+        end
+        mapping.add_relation HasManyRelation.new(relation_name, ar_name, inner_mapping, options)
+      end
+    end
+  end
+end

data/lib/entity_mapper/mapping/has_many_relation.rb

@@ -0,0 +1,9 @@
+module EntityMapper
+  module Mapping
+    class HasManyRelation < Relation
+      def collection?
+        true
+      end
+    end
+  end
+end

data/lib/entity_mapper/mapping/has_one_relation.rb

@@ -0,0 +1,5 @@
+module EntityMapper
+  module Mapping
+    HasOneRelation = Class.new(Relation)
+  end
+end

data/lib/entity_mapper/mapping/model.rb

@@ -0,0 +1,23 @@
+require 'set'
+
+module EntityMapper
+  module Mapping
+    class Model
+      attr_accessor :model_class
+      attr_reader :properties, :relations
+
+      def initialize(properties: Set.new, relations: Set.new)
+        @properties = properties
+        @relations = relations
+      end
+
+      def add_relation(relation)
+        @relations << relation
+      end
+
+      def add_property(property)
+        @properties << property
+      end
+    end
+  end
+end

data/lib/entity_mapper/mapping/property.rb

@@ -0,0 +1,27 @@
+module EntityMapper
+  module Mapping
+    class Property
+      attr_reader :ar_name, :name
+
+      def initialize(name, ar_name, options)
+        @ar_name = ar_name
+        @name = name
+        @access = options.fetch(:access, :instance_variable)
+      end
+
+      def read_from(object)
+        accessor.read_from(object)
+      end
+
+      def write_to(object, value)
+        accessor.write_to(object, value)
+      end
+
+      private
+
+      def accessor
+        @accessor ||= AccessModes::Factory.call(@access, @name)
+      end
+    end
+  end
+end

data/lib/entity_mapper/mapping/relation.rb

@@ -0,0 +1,21 @@
+module EntityMapper
+  module Mapping
+    class Relation < Property
+      attr_reader :mapping, :ar_name, :build_strategy
+
+      def initialize(name, ar_name, mapping, options)
+        super(name, ar_name, options)
+        @mapping = mapping
+        @build_strategy = options.fetch(:build_strategy, ActiveRecord::DefaultBuildStrategy)
+      end
+
+      def virtual?
+        ar_name.nil?
+      end
+
+      def collection?
+        false
+      end
+    end
+  end
+end

data/lib/entity_mapper/snapshot/object_snapshot.rb

@@ -0,0 +1,5 @@
+module EntityMapper
+  module Snapshot
+    ObjectSnapshot = Struct.new(:object, :properties_map, :relations_map)
+  end
+end

data/lib/entity_mapper/snapshot/take_snapshot.rb

@@ -0,0 +1,31 @@
+module EntityMapper
+  module Snapshot
+    class TakeSnapshot
+      def call(object, mapping)
+        ObjectSnapshot.new(
+          object,
+          properties_map(object, mapping.properties),
+          relations_map(object, mapping.relations)
+        )
+      end
+
+      def properties_map(object, properties)
+        properties.each_with_object({}) do |property, hash|
+          hash[property] = property.read_from(object)
+        end
+      end
+
+      def relations_map(object, relations)
+        relations.each_with_object({}) do |relation, hash|
+          relation_value = relation.read_from(object)
+
+          if relation_value
+            hash[relation] = relation.collection? ?
+              relation_value.map { |relation_object| call(relation_object, relation.mapping) } :
+              call(relation_value, relation.mapping)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/entity_mapper/snapshot_diff/calculate.rb

@@ -0,0 +1,78 @@
+module EntityMapper
+  module SnapshotDiff
+    class Calculate
+      def self.call(previous_snapshot, current_snapshot)
+        call(previous_snapshot, current_snapshot)
+      end
+
+      def call(previous_snapshot, current_snapshot)
+        state = diff_state(previous_snapshot, current_snapshot)
+
+        object = current_snapshot || previous_snapshot
+
+        ObjectDiffSnapshot.new(
+          object.object,
+          object.properties_map,
+          relations_map(previous_snapshot, current_snapshot),
+          state
+        )
+      end
+
+      def diff_state(previous_snapshot, current_snapshot)
+        if previous_snapshot.nil?
+          :new
+        elsif current_snapshot.nil?
+          :removed
+        elsif properties_changed?(previous_snapshot, current_snapshot)
+          :changed
+        else
+          :unchanged
+        end
+      end
+
+      def properties_changed?(previous_snapshot, current_snapshot)
+        current_snapshot.properties_map.any? do |property, value|
+          value != previous_snapshot.properties_map[property]
+        end
+      end
+
+      def relations_map(previous_snapshot, current_snapshot)
+        if previous_snapshot.nil?
+          current_snapshot.
+            relations_map.
+            each_with_object({}) do |(relation, relation_value), hash|
+            hash[relation] = relation.collection? ?
+              relation_value.map { |value| call(nil, value) } :
+              call(nil, relation_value)
+          end
+        elsif current_snapshot.nil?
+          previous_snapshot.
+            relations_map.
+            each_with_object({}) do |(relation, relation_value), hash|
+            hash[relation] = relation.collection? ?
+              relation_value.map { |value| call(value, nil) } :
+              call(relation_value, nil)
+          end
+        else
+          current_snapshot.
+            relations_map.
+            each_with_object({}) do |(relation, relation_value), hash|
+            previous_snapshot_relation = previous_snapshot.relations_map[relation]
+            hash[relation] = if relation.collection?
+              existing_items = relation_value.map { |value| call(find_previous_snapshot(previous_snapshot_relation, value), value) }
+              removed_items = previous_snapshot_relation.reject { |value| find_previous_snapshot(relation_value, value) }.map { |value| call(value, nil) }
+
+              existing_items + removed_items
+            else
+              call(previous_snapshot_relation, relation_value)
+            end
+          end
+        end
+      end
+
+      def find_previous_snapshot(previous_snapshot_relation, value)
+        previous_snapshot_relation.find { |v| v.object == value.object }
+      end
+    end
+  end
+end

data/lib/entity_mapper/snapshot_diff/object_diff_snapshot.rb

@@ -0,0 +1,17 @@
+module EntityMapper
+  module SnapshotDiff
+    ObjectDiffSnapshot = Struct.new(:object, :properties_map, :relations_map, :state) do
+      def new?
+        state == :new
+      end
+
+      def changed?
+        state == :changed
+      end
+
+      def removed?
+        state == :removed
+      end
+    end
+  end
+end

data/lib/entity_mapper/transaction.rb

@@ -0,0 +1,13 @@
+module EntityMapper
+  class Transaction
+    def self.call(mapping, &block)
+      new.call(mapping, &block)
+    end
+
+    def call(mapping)
+      context = Context.new(mapping)
+      yield context
+      context.save_changes
+    end
+  end
+end

data/lib/entity_mapper/transaction/context.rb

@@ -0,0 +1,21 @@
+module EntityMapper
+  class Transaction
+    class Context
+      def initialize(mapping)
+        @mapping = mapping
+        @tracked_aggregates = []
+      end
+
+      def read(active_record_object)
+        mapped_entity, ar_map = ActiveRecord::Read.call(@mapping, active_record_object)
+        @tracked_aggregates << TrackedAggregate.new(mapped_entity, ar_map, active_record_object, @mapping)
+
+        mapped_entity
+      end
+
+      def save_changes
+        @tracked_aggregates.each(&:save_changes)
+      end
+    end
+  end
+end

data/lib/entity_mapper/transaction/tracked_aggregate.rb

@@ -0,0 +1,27 @@
+module EntityMapper
+  class Transaction
+    class TrackedAggregate
+      def initialize(aggregate, ar_map, active_record_object, mapping)
+        @aggregate = aggregate
+        @ar_map = ar_map
+        @active_record_object = active_record_object
+        @mapping = mapping
+        @initial_snapshot = take_snapshot
+      end
+
+      def save_changes
+        ActiveRecord::Update.call(@mapping, snapshot_diff, @active_record_object, @ar_map)
+      end
+
+      private
+
+      def snapshot_diff
+        EntityMapper::SnapshotDiff::Calculate.new.call(@initial_snapshot, take_snapshot)
+      end
+
+      def take_snapshot
+        Snapshot::TakeSnapshot.new.call(@aggregate, @mapping)
+      end
+    end
+  end
+end

data/lib/entity_mapper/version.rb

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

data/lib/entity_mapper/zeitwerk_inflector.rb

@@ -0,0 +1,12 @@
+module EntityMapper
+  class ZeitwerkInfelctor < Zeitwerk::GemInflector
+    def camelize(basename, _abspath)
+      case basename
+      when "dsl"
+        "DSL"
+      else
+        super
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,189 @@
+--- !ruby/object:Gem::Specification
+name: entity_mapper
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre.alpha
+platform: ruby
+authors:
+- Jan Jędrychowski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: combustion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  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'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.2
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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: Map persisted data to and from POROs
+email:
+- jan@jedrychowski.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- entity_mapper.gemspec
+- lib/entity_mapper.rb
+- lib/entity_mapper/access_modes/factory.rb
+- lib/entity_mapper/access_modes/instance_variable.rb
+- lib/entity_mapper/access_modes/method.rb
+- lib/entity_mapper/active_record/ar_map.rb
+- lib/entity_mapper/active_record/default_build_strategy.rb
+- lib/entity_mapper/active_record/read.rb
+- lib/entity_mapper/active_record/update.rb
+- lib/entity_mapper/mapping/dsl.rb
+- lib/entity_mapper/mapping/has_many_relation.rb
+- lib/entity_mapper/mapping/has_one_relation.rb
+- lib/entity_mapper/mapping/model.rb
+- lib/entity_mapper/mapping/property.rb
+- lib/entity_mapper/mapping/relation.rb
+- lib/entity_mapper/snapshot/object_snapshot.rb
+- lib/entity_mapper/snapshot/take_snapshot.rb
+- lib/entity_mapper/snapshot_diff/calculate.rb
+- lib/entity_mapper/snapshot_diff/object_diff_snapshot.rb
+- lib/entity_mapper/transaction.rb
+- lib/entity_mapper/transaction/context.rb
+- lib/entity_mapper/transaction/tracked_aggregate.rb
+- lib/entity_mapper/version.rb
+- lib/entity_mapper/zeitwerk_inflector.rb
+homepage: https://github.com/gogiel/entity_mapper
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Map persisted data to and from POROs
+test_files: []