rom 0.2.0 → 0.3.0

data/lib/rom/mapper/header.rb

@@ -1,103 +0,0 @@
-# encoding: utf-8
-
-require 'rom/mapper/attribute'
-
-module ROM
-  class Mapper
-
-    # Mapper header wrapping axiom header and providing mapping information
-    #
-    # @private
-    class Header
-      include Enumerable, Concord.new(:attributes), Adamantium, Morpher::NodeHelpers
-
-      # Build a header
-      #
-      # @api private
-      def self.build(input)
-        if input.is_a?(self)
-          input
-        else
-          new(input.map { |args| Attribute.build(*args) })
-        end
-      end
-
-      # Return attribute mapping
-      #
-      # @api private
-      def mapping
-        each_with_object({}) { |attribute, hash| hash.update(attribute.mapping) }
-      end
-      memoize :mapping
-
-      # Return all key attributes
-      #
-      # @return [Array<Attribute>]
-      #
-      # @api public
-      def keys
-        select(&:key?)
-      end
-      memoize :keys
-
-      def to_ast
-        s(:hash_transform, *map(&:to_ast))
-      end
-      memoize :to_ast
-
-      # Return attribute with the given name
-      #
-      # @return [Attribute]
-      #
-      # @api public
-      def [](name)
-        detect { |attribute| attribute.name == name } || raise(KeyError)
-      end
-
-      # Return attribute names
-      #
-      # @api private
-      def attribute_names
-        map(&:name)
-      end
-
-      # Iterate over attributes
-      #
-      # @api private
-      def each(&block)
-        return to_enum unless block_given?
-        attributes.each(&block)
-        self
-      end
-
-      # TODO: this should receive a hash with header objects already
-      def wrap(other)
-        new_attributes = other.map { |name, mapper| mapper.attribute(Attribute::EmbeddedValue, name) }
-        self.class.new((attributes + new_attributes).uniq)
-      end
-
-      # TODO: this should receive a hash with header objects already
-      def group(other)
-        new_attributes = other.map { |name, mapper| mapper.attribute(Attribute::EmbeddedCollection, name) }
-        self.class.new((attributes + new_attributes).uniq)
-      end
-
-      # @api private
-      def join(other)
-        self.class.new((attributes + other.attributes).uniq)
-      end
-
-      # @api private
-      def project(names)
-        self.class.new(select { |attribute| names.include?(attribute.tuple_key) })
-      end
-
-      # @api private
-      def rename(names)
-        self.class.new(map { |attribute| names[attribute.name] ? attribute.rename(names[attribute.name]) : attribute })
-      end
-
-    end # Header
-
-  end # Mapper
-end # ROM

data/lib/rom/mapper/loader_builder.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-
-module ROM
-  class Mapper
-
-    # Abstract loader class
-    #
-    # @private
-    class LoaderBuilder
-      extend Morpher::NodeHelpers
-
-      def self.call(header, model, type)
-        param =
-          if type == :load_attribute_hash
-            s(:param, model)
-          else
-            s(:param, model, *header.attribute_names)
-          end
-
-        Morpher.compile(s(:block, header.to_ast, s(type, param)))
-      end
-
-    end # Loader
-
-  end # Mapper
-end # ROM

data/lib/rom/schema.rb

@@ -1,21 +0,0 @@
-# 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

@@ -1,59 +0,0 @@
-# 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

@@ -1,84 +0,0 @@
-# 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

@@ -1,80 +0,0 @@
-# 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

@@ -1,27 +0,0 @@
-# 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

@@ -1,111 +0,0 @@
-# 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