rom 0.1.2 → 0.2.0

data/lib/rom/repository.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+require 'rom/support/axiom/adapter'
+
+module ROM
+
+  # A repository with a given +name+ and +adapter+
+  #
+  # @api private
+  class Repository
+    include Concord.new(:name, :adapter, :relations)
+
+    # Build a repository with a given +name+ and +uri+
+    #
+    # @param [Symbol] name
+    #   the repository's name
+    #
+    # @param [Addressable::URI] uri
+    #   the uri for initializing the adapter
+    #
+    # @return [Repository]
+    #
+    # @api private
+    def self.build(name, uri, relations = {})
+      new(name, Axiom::Adapter.build(uri), relations)
+    end
+
+    # Return the relation identified by +name+
+    #
+    # @example
+    #
+    #   repo = Repository.coerce(:test, 'in_memory://test')
+    #   repo.register(:foo, [[:id, String], [:foo, String]])
+    #   repo[:foo]
+    #
+    #   # => <Axiom::Relation header=Axiom::Header ...>
+    #
+    # @param [Symbol] name
+    #   the name of the relation
+    #
+    # @return [Axiom::Relation]
+    #
+    # @raise [KeyError]
+    #
+    # @api public
+    def [](name)
+      relations.fetch(name)
+    end
+
+    # Register a relation with this repository
+    #
+    # @param [Axiom::Relation::Base] relation
+    #
+    # @return [Object] relation gateway
+    #
+    # @api public
+    def []=(name, relation)
+      relation =
+        if adapter.respond_to?(:gateway)
+          adapter.gateway(relation)
+        else
+          adapter[name] = relation
+          adapter[name]
+        end
+
+      relations[name] = relation
+    end
+
+  end # Repository
+
+end # ROM

data/lib/rom/schema.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module ROM
+
+  # ROM's relation schema
+  #
+  class Schema
+    include Concord.new(:relations), Adamantium::Flat
+
+    # Return a relation identified by name
+    #
+    # @param [Symbol] name of the relation
+    #
+    # @return [Relation]
+    def [](name)
+      relations.fetch(name)
+    end
+
+  end # Schema
+
+end # ROM

data/lib/rom/schema/builder.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require 'rom/schema'
+require 'rom/schema/definition'
+
+module ROM
+  class Schema
+
+    # Schema builder DSL
+    #
+    class Builder
+      include Concord.new(:definition), Adamantium::Flat
+
+      # Build a relation schema
+      #
+      # @example
+      #
+      #   Schema.build do
+      #     base_relation :users do
+      #       repository :test
+      #       attribute :id, :name
+      #     end
+      #   end
+      #
+      # @return [Schema]
+      #
+      # @api public
+      def self.build(repositories, &block)
+        new(Definition.new(repositories, &block))
+      end
+
+      # Return defined relation identified by name
+      #
+      # @example
+      #
+      #   schema[:users] # => #<Axiom::Relation::Base ..>
+      #
+      # @return [Axiom::Relation, Axiom::Relation::Base]
+      #
+      # @api public
+      def [](name)
+        definition[name]
+      end
+
+      # @api private
+      def call(&block)
+        definition.instance_eval(&block)
+        self
+      end
+
+      # @api private
+      def finalize
+        Schema.new(definition.relations)
+      end
+
+    end # Builder
+
+  end # Schema
+end # ROM

data/lib/rom/schema/definition.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+require 'rom/schema/definition/relation/base'
+
+module ROM
+  class Schema
+
+    # Builder object used by schema DSL to establish Axiom relations
+    #
+    # @private
+    class Definition
+      include Equalizer.new(:repositories, :relations)
+
+      attr_reader :repositories, :relations
+
+      # @api private
+      def initialize(repositories, &block)
+        @repositories = repositories
+        @relations    = {}
+        instance_eval(&block) if block
+      end
+
+      # Build a base relation
+      #
+      # @example
+      #
+      #   Schema.build do
+      #     base_relation :users do
+      #       # ...
+      #     end
+      #   end
+      #
+      # @return [Definition]
+      #
+      # @api private
+      def base_relation(name, &block)
+        builder    = Relation::Base.new(relations, &block)
+        repository = repositories.fetch(builder.repository)
+
+        repository[name] = builder.call(name)
+        relations[name]  = repository[name]
+      end
+
+      # Build a relation
+      #
+      # @example
+      #
+      #   Schema.build do
+      #     relation :users do
+      #       # ...
+      #     end
+      #   end
+      #
+      # @return [Definition]
+      #
+      # @api private
+      def relation(name, &block)
+        relations[name] = instance_eval(&block)
+      end
+
+      # Return relation identified by name
+      #
+      # @return [Axiom::Relation, Axiom::Relation::Base]
+      #
+      # @api private
+      def [](name)
+        relations[name]
+      end
+
+      private
+
+      # Method missing hook
+      #
+      # @return [Axiom::Relation, Axiom::Relation::Base]
+      #
+      # @api private
+      def method_missing(*args)
+        self[args.first] || super
+      end
+
+    end # Definition
+
+  end # Schema
+end # ROM

data/lib/rom/schema/definition/relation.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+module ROM
+  class Schema
+    class Definition
+
+      # Builder object for Axiom relation
+      #
+      # @private
+      class Relation
+        include Equalizer.new(:header, :keys)
+
+        attr_reader :registry
+
+        # @api private
+        def initialize(registry, &block)
+          @registry = registry
+          @header = []
+          @keys   = []
+          @wrappings = []
+          @groupings = []
+          instance_eval(&block)
+        end
+
+        # @api private
+        def call(name)
+          relation = Axiom::Relation::Base.new(name, build_header)
+
+          if @wrappings.any?
+            @wrappings.each { |wrapping| relation = relation.wrap(wrapping) }
+          end
+
+          if @groupings.any?
+            @groupings.each { |grouping| relation = relation.group(grouping) }
+          end
+
+          renames = @header.each_with_object({}) { |ary, mapping|
+            mapping[ary.first] = ary.last[:rename] if ary.last[:rename]
+          }
+
+          relation.rename(renames).optimize
+        end
+
+        # @api private
+        def attribute(name, type, options = {})
+          @header << [name, type, options]
+        end
+
+        # @api private
+        def wrap(wrapping)
+          @wrappings << wrapping
+        end
+
+        # @api private
+        def group(grouping)
+          @groupings << grouping
+        end
+
+        # @api private
+        def key(*attribute_names)
+          @keys.concat(attribute_names)
+        end
+
+        private
+
+        # @api private
+        def method_missing(*args)
+          registry[args.first] || super
+        end
+
+        # @api private
+        def build_header
+          Axiom::Relation::Header.coerce(@header, keys: @keys)
+        end
+
+      end # Relation
+
+    end # Definition
+  end # Schema
+end # ROM

data/lib/rom/schema/definition/relation/base.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'rom/schema/definition/relation'
+
+module ROM
+  class Schema
+    class Definition
+      class Relation
+
+        # Base relation builder object
+        #
+        class Base < self
+
+          def repository(name = Undefined)
+            if name == Undefined
+              @repository
+            else
+              @repository = name
+            end
+          end
+
+        end # Base
+
+      end # Relation
+    end # Definition
+  end # Schema
+end # ROM

data/lib/rom/session.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+
+require 'rom/session/environment'
+require 'rom/session/tracker'
+require 'rom/session/identity_map'
+require 'rom/session/relation'
+require 'rom/session/mapper'
+
+require 'rom/session/state'
+require 'rom/session/state/transient'
+require 'rom/session/state/persisted'
+require 'rom/session/state/created'
+require 'rom/session/state/updated'
+require 'rom/session/state/deleted'
+
+module ROM
+
+  # Extended ROM::Environment with session support
+  class Environment
+
+    # Start a new session for this environment
+    #
+    # @example
+    #  env.session do |session|
+    #    # ...
+    #  end
+    #
+    # @see Session.start
+    #
+    # @api public
+    def session(&block)
+      Session.start(self, &block)
+    end
+  end
+
+  # Session with IdentityMap and state-tracking functionality
+  #
+  # @example
+  #
+  #   env.session do |session|
+  #     user = session[:users].new(id: 1, name: 'Jane')
+  #
+  #     session[:users].save(user)
+  #
+  #     session.flush
+  #   end
+  #
+  # @api public
+  class Session
+    include Concord.new(:environment)
+
+    # Raised when an object is expected to be tracked and it's not
+    #
+    class ObjectNotTrackedError < StandardError
+      def initialize(identity)
+        super("Tracker doesn't include object with identity #{identity.inspect}")
+      end
+    end
+
+    # Start a new session
+    #
+    # @example
+    #
+    #   ROM::Session.start(env) do |session|
+    #     user = session[:users].new(name: 'Jane')
+    #     session[:users].save(user)
+    #     session[:users].flush
+    #   end
+    #
+    # @param [ROM::Environment] rom's environment
+    #
+    # @yieldparam [Session::Environment]
+    #
+    # @api public
+    def self.start(environment)
+      yield(new(Environment.build(environment)))
+    end
+
+    # Return a session relation identified by name
+    #
+    # @param [Symbol] relation name
+    #
+    # @return [Session::Relation]
+    #
+    # @api public
+    def [](relation_name)
+      environment[relation_name]
+    end
+
+    # Flush this session committing all the state changes
+    #
+    # @return [Session]
+    #
+    # @api public
+    def flush
+      environment.commit
+      self
+    end
+
+    # Return if there are any pending state changes
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def clean?
+      environment.clean?
+    end
+
+  end # Session
+
+end # ROM