rom-session 0.1.0

data/lib/rom/session/environment.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+module ROM
+  class Session
+
+    # Session-specific environment wrapping ROM's environment
+    #
+    # It works exactly the same as ROM::Environment except it returns
+    # session relations
+    #
+    # @api public
+    class Environment < ROM::Environment
+      include Proxy
+
+      attr_reader :environment, :tracker, :memory
+      private :environment, :tracker, :memory
+
+      # @api private
+      def self.build(environment, tracker = Tracker.new)
+        new(environment, tracker)
+      end
+
+      # @api private
+      def initialize(environment, tracker)
+        @environment = environment
+        @tracker     = tracker
+        initialize_memory
+      end
+
+      # Return a relation identified by name
+      #
+      # @param [Symbol] name of a relation
+      #
+      # @return [Session::Relation] rom's relation wrapped by session
+      #
+      # @api public
+      def [](name)
+        memory[name]
+      end
+
+      # @api private
+      def commit
+        tracker.commit
+      end
+
+      # @api private
+      def clean?
+        tracker.clean?
+      end
+
+      private
+
+      # @api private
+      def initialize_memory
+        @memory = Hash.new { |_, name| memory[name] = build_relation(name) }
+      end
+
+      # @api private
+      def build_relation(name)
+        Relation.build(environment[name], tracker)
+      end
+
+    end # Environment
+
+  end # Session
+end # ROM

data/lib/rom/session/identity_map.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module ROM
+  class Session
+
+    # @api private
+    class IdentityMap
+      include Concord.new(:objects)
+
+      class LoadedObject
+        include Concord::Public.new(:object, :tuple)
+      end
+
+      # @api private
+      def self.build(objects = {})
+        new(objects)
+      end
+
+      # @api private
+      def [](identity)
+        objects[identity]
+      end
+
+      # @api private
+      def fetch_object(identity, &block)
+        objects.fetch(identity, &block).object
+      end
+
+      # @api private
+      def fetch_tuple(identity)
+        self[identity].tuple
+      end
+
+      # @api private
+      def store(identity, object, tuple)
+        objects[identity] = LoadedObject.new(object, tuple)
+        self
+      end
+
+    end # IdentityMap
+
+  end # Session
+end # ROM

data/lib/rom/session/mapper.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module ROM
+  class Session
+
+    # @api private
+    class Mapper < ROM::Mapper
+      include Proxy, Concord::Public.new(:mapper, :tracker, :identity_map)
+
+      # @api private
+      def self.build(mapper, tracker)
+        new(mapper, tracker, IdentityMap.build)
+      end
+
+      # @api private
+      def dirty?(object)
+        identity_map.fetch_tuple(identity(object)) != dump(object)
+      end
+
+      # @api private
+      def load(tuple)
+        identity = mapper.identity_from_tuple(tuple)
+        identity_map.fetch_object(identity) { load_and_track(identity, tuple) }
+      end
+
+      # @api private
+      def store_in_identity_map(object)
+        identity_map.store(identity(object), object, dump(object))
+      end
+
+      private
+
+      # @api private
+      def load_and_track(identity, tuple)
+        object = mapper.load(tuple)
+        tracker.store_persisted(object, self)
+        identity_map.store(identity, object, tuple)[identity]
+      end
+
+    end # Mapper
+
+  end # Session
+end # ROM

data/lib/rom/session/relation.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+
+module ROM
+  class Session
+
+    # Adds session-specific functionality on top of ROM's relation.
+    #
+    # A session relation builds a queue of state changes that will be committed
+    # when a session is flushed.
+    #
+    # @api public
+    class Relation < ROM::Relation
+      include Proxy
+
+      attr_reader :relation, :tracker
+      private :relation, :tracker
+
+      # @api private
+      def self.build(relation, tracker)
+        mapper = Mapper.build(relation.mapper, tracker)
+        new(relation.inject_mapper(mapper), tracker)
+      end
+
+      # @api private
+      def initialize(relation, tracker)
+        @relation, @tracker = relation, tracker
+      end
+
+      # Transition an object into a saved state
+      #
+      # Transient object's state turns into Created
+      # Persisted object's state turns into Updated
+      #
+      # @param [Object] an object to be saved
+      #
+      # @return [Session::Relation]
+      #
+      # @api public
+      def save(object)
+        tracker.queue(state(object).save(relation))
+        self
+      end
+
+      # Transient an object into a deleted state
+      #
+      # @param [Object] an object to be deleted
+      #
+      # @return [Session::Relation]
+      #
+      # @api public
+      def delete(object)
+        tracker.queue(state(object).delete(relation))
+        self
+      end
+
+      # Return current state of the tracked object
+      #
+      # @param [Object] an object
+      #
+      # @return [Session::State]
+      #
+      # @api public
+      def state(object)
+        tracker.fetch(object)
+      end
+
+      # Return object's identity
+      #
+      # @param [Object] an object
+      #
+      # @return [Array]
+      #
+      # @api public
+      def identity(object)
+        mapper.identity(object)
+      end
+
+      # Start tracking an object within this session
+      #
+      # @param [Object] an object to be track
+      #
+      # @return [Session::Relation]
+      #
+      # @api public
+      def track(object)
+        tracker.store_transient(object, mapper)
+        self
+      end
+
+      # Build a new object instance and start tracking
+      #
+      # @return [Object]
+      #
+      # @api public
+      def new(*args, &block)
+        object = mapper.new_object(*args, &block)
+        track(object)
+        object
+      end
+
+      # Check if a tracked object is dirty
+      #
+      # @param [Object] an object
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def dirty?(object)
+        state(object).transient? || mapper.dirty?(object)
+      end
+
+      # Check if an object is being tracked
+      #
+      # @param [Object]
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def tracking?(object)
+        tracker.include?(object)
+      end
+
+    end # Relation
+
+  end # Session
+end # ROM

data/lib/rom/session/state.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module ROM
+  class Session
+
+    # @api private
+    class State
+      include Concord::Public.new(:object)
+
+      TransitionError = Class.new(StandardError)
+
+      # @api private
+      def save(*)
+        raise TransitionError, "cannot save object with #{self.class} state"
+      end
+
+      # @api private
+      def delete(*)
+        raise TransitionError, "cannot delete object with #{self.class} state"
+      end
+
+      # @api private
+      def transient?
+        instance_of?(Transient)
+      end
+
+      # @api private
+      def created?
+        instance_of?(Created)
+      end
+
+      # @api private
+      def persisted?
+        instance_of?(Persisted)
+      end
+
+      # @api private
+      def updated?
+        instance_of?(Updated)
+      end
+
+      # @api private
+      def deleted?
+        instance_of?(Deleted)
+      end
+
+    end # State
+
+  end # Session
+end # ROM

data/lib/rom/session/state/created.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module ROM
+  class Session
+    class State
+
+      # @api private
+      class Created < self
+        include Concord::Public.new(:object, :mapper, :relation), Adamantium::Flat
+
+        # @api private
+        def commit
+          relation.insert(object)
+          mapper.store_in_identity_map(object)
+          Persisted.new(object, mapper)
+        end
+
+      end # Created
+
+    end # State
+  end # Session
+end # ROM

data/lib/rom/session/state/deleted.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module ROM
+  class Session
+    class State
+
+      # @api private
+      class Deleted < self
+        include Concord::Public.new(:object, :relation), Adamantium::Flat
+
+        class Committed < State
+          include Adamantium
+        end
+
+        # @api private
+        def commit
+          relation.delete(object)
+          Committed.new(object)
+        end
+
+      end # Deleted
+
+    end # State
+  end # Session
+end # ROM

data/lib/rom/session/state/persisted.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module ROM
+  class Session
+    class State
+
+      # @api private
+      class Persisted < self
+        include Concord::Public.new(:object, :mapper)
+
+        # @api private
+        def save(relation)
+          if mapper.dirty?(object)
+            Updated.new(object, mapper, relation)
+          else
+            self
+          end
+        end
+
+        # @api private
+        def delete(relation)
+          Deleted.new(object, relation)
+        end
+
+      end # Persisted
+
+    end # State
+  end # Session
+end # ROM

data/lib/rom/session/state/transient.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module ROM
+  class Session
+    class State
+
+      # @api private
+      class Transient < self
+        include Concord::Public.new(:object, :mapper)
+
+        # @api private
+        def save(relation)
+          Created.new(object, mapper, relation)
+        end
+
+      end # Transient
+
+    end # State
+  end # Session
+end # ROM

data/lib/rom/session/state/updated.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module ROM
+  class Session
+    class State
+
+      # @api private
+      class Updated < self
+        include Adamantium::Flat
+        include Concord::Public.new(:object, :mapper, :relation)
+
+        # @api private
+        def commit
+          relation.update(object, original_tuple)
+          Persisted.new(object, mapper)
+        end
+
+        private
+
+        # @api private
+        def original_tuple
+          mapper.identity_map.fetch_tuple(mapper.identity(object))
+        end
+
+      end # Updated
+
+    end # State
+  end # Session
+end # ROM