rom 0.1.2 → 0.2.0

data/config/yardstick.yml

@@ -0,0 +1,2 @@
+---
+threshold: 100

data/lib/rom.rb

@@ -1,6 +1,14 @@
-module ROM
-end
+# encoding: utf-8
 
-require 'rom-relation'
-require 'rom-mapper'
-require 'rom-session'
+require 'adamantium'
+require 'concord'
+require 'equalizer'
+require 'charlatan'
+require 'morpher'
+require 'axiom'
+require 'axiom-optimizer'
+
+require 'rom/environment'
+require 'rom/relation'
+require 'rom/mapper'
+require 'rom/session'

data/lib/rom/constants.rb

@@ -0,0 +1,16 @@
+module ROM
+  # Raised when the returned tuples are unexpectedly empty
+  NoTuplesError = Class.new(RuntimeError)
+
+  # Raised when the returned tuples are unexpectedly too many
+  ManyTuplesError = Class.new(RuntimeError)
+
+  # Represent an undefined argument
+  Undefined = Class.new.freeze
+
+  # An empty frozen Hash useful for parameter default values
+  EMPTY_HASH = {}.freeze
+
+  # An empty frozen Array useful for parameter default values
+  EMPTY_ARRAY = [].freeze
+end

data/lib/rom/environment.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+
+require 'rom/environment/builder'
+
+module ROM
+
+  # The environment configures repositories and loads schema with relations
+  #
+  class Environment
+    # @api private
+    attr_reader :repositories, :relations
+
+    # Return schema registry
+    #
+    # @return [Schema]
+    #
+    # @api public
+    attr_reader :schema
+
+    # Return mapper registry
+    #
+    # @return [Hash]
+    #
+    # @api public
+    attr_reader :mappers
+
+    # @api private
+    def initialize(repositories, schema, relations, mappers)
+      @repositories = repositories
+      @schema = schema
+      @relations = relations
+      @mappers = mappers
+    end
+
+    # Setup ROM environment
+    #
+    # @example
+    #
+    #   env = ROM::Environment.setup(test: 'memory://test') do
+    #     schema do
+    #       base_relation(:users) do
+    #         repository :test
+    #
+    #         attribute :id, Integer
+    #         attribute :name, String
+    #
+    #         key :id
+    #       end
+    #     end
+    #
+    #     mapping do
+    #       relation(:users) do
+    #         model User
+    #
+    #         map :id, :name
+    #       end
+    #     end
+    #
+    #   end
+    #
+    # @param [Environment, Hash<#to_sym, String>] config
+    #   an environment or a hash of adapter uri strings,
+    #   keyed by repository name
+    #
+    # @return [Environment::Builder]
+    #
+    # @api public
+    def self.setup(config, &block)
+      builder = Builder.call(config)
+
+      if block
+        builder.instance_eval(&block)
+        builder.finalize
+      else
+        builder
+      end
+    end
+
+    # Return registered relation
+    #
+    # @example
+    #
+    #   env[:users]
+    #
+    # @param [Symbol] relation name
+    #
+    # @return [Relation]
+    #
+    # @api public
+    def [](name)
+      relations[name]
+    end
+
+    # The repository with the given +name+
+    #
+    # @return [Repository]
+    #
+    # @api public
+    def repository(name)
+      repositories[name]
+    end
+
+  end # Environment
+
+end # ROM

data/lib/rom/environment/builder.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+require 'addressable/uri'
+
+require 'rom/environment'
+require 'rom/repository'
+require 'rom/schema/builder'
+require 'rom/mapper/builder'
+
+module ROM
+
+  # The environment configures repositories and loads schema with relations
+  #
+  class Environment
+
+    # Environment builder DSL
+    #
+    class Builder
+      attr_reader :repositories, :relations, :mappers
+
+      # @api private
+      def self.call(config)
+        repositories = config.each_with_object({}) { |(name, uri), hash|
+          hash[name.to_sym] = Repository.build(name, Addressable::URI.parse(uri))
+        }
+
+        new(repositories)
+      end
+
+      # @api private
+      def initialize(repositories)
+        @repositories = repositories
+        @relations = {}
+        @schema = Schema::Builder.build(repositories)
+        @mappers = Mapper::Builder.new(schema)
+      end
+
+      # @api private
+      def schema(&block)
+        @schema.call(&block) if block
+        @schema
+      end
+
+      # @api private
+      def mapping(&block)
+        mappers.call(&block)
+      end
+
+      # @api private
+      def [](name)
+        relations[name]
+      end
+
+      # @api private
+      def []=(name, relation)
+        relations[name] = relation
+      end
+
+      # @api private
+      def finalize
+        mappers.each do |name, mapper|
+          relations[name] = Relation.new(schema[name], mapper)
+        end
+
+        Environment.new(repositories, schema.finalize, relations, mappers.finalize)
+      end
+
+    end # Builder
+
+  end # Environment
+end # ROM

data/lib/rom/mapper.rb

@@ -0,0 +1,176 @@
+# encoding: utf-8
+
+require 'ostruct'
+
+require 'rom/constants'
+require 'rom/mapper/header'
+require 'rom/mapper/loader_builder'
+
+module ROM
+
+  # Mappers load tuples into objects and dump objects back into tuples
+  #
+  class Mapper
+    include Equalizer.new(:header, :options)
+
+    DEFAULT_LOADER = :load_instance_variables
+
+    attr_reader :header, :loader, :dumper, :model, :type, :options
+
+    # Build a mapper
+    #
+    # @example
+    #
+    #   User = Class.new { attr_reader :id, :name }
+    #
+    #   mapper = ROM::Mapper.build([[:id, from: :user_id], [:name, from: :user_name]], model: User)
+    #
+    #   user = mapper.load(user_id: 1, user_name: 'Jane')
+    #   # => #<User:0x007fee3b8bf2c8 @id=1, @name="Jane">
+    #
+    #   tuple = mapper.dump(user)
+    #   # => [1, "Jane"]
+    #
+    # @return [Mapper]
+    #
+    # @api public
+    def self.build(attributes, options = EMPTY_HASH)
+      defaults = { type: DEFAULT_LOADER, model: OpenStruct }.update(options)
+
+      header = Header.build(attributes)
+      loader = LoaderBuilder.call(header, defaults[:model], defaults[:type])
+
+      new(header, loader, defaults)
+    end
+
+    # @api private
+    def initialize(header, loader, options)
+      @header = header
+      @loader = loader
+      @dumper = loader.inverse
+      @model = options.fetch(:model)
+      @type = options.fetch(:type)
+      @options = options
+    end
+
+    # Retrieve identity from the given object
+    #
+    # @example
+    #
+    #   mapper.identity(user) # => [1]
+    #
+    # @param [Object]
+    #
+    # @return [Array]
+    #
+    # @api public
+    def identity(object)
+      header.keys.map { |key| object.send(key.name) }
+    end
+
+    # Return identity from the given tuple
+    #
+    # @example
+    #
+    #   mapper.identity_from_tuple({id: 1}) # => [1]
+    #
+    # @param [Axiom::Tuple,Hash]
+    #
+    # @return [Array]
+    #
+    # @api public
+    def identity_from_tuple(tuple)
+      header.keys.map { |key| tuple[key.name] }
+    end
+
+    # Build a new model instance
+    #
+    # @example
+    #
+    #   mapper = Mapper.build(header, User)
+    #   mapper.new_object(id: 1, name: 'Jane') # => #<User @id=1 @name="Jane">
+    #
+    # @api public
+    def new_object(*args, &block)
+      model.new(*args, &block)
+    end
+
+    # Load an object instance from the tuple
+    #
+    # @api public
+    def load(tuple)
+      loader.call(tuple)
+    end
+
+    # Dump an object into a tuple
+    #
+    # @api public
+    #
+    # TODO: it's not clear how a tuple should look like for grouped/wrapped
+    #       relation. the current implementation is temporary
+    def dump(object)
+      ary = dumper.call(object)
+
+      ary.each_with_object([]) do |(name, value), tuple|
+        attribute = header.detect { |attr| attr.tuple_key == name }
+
+        if attribute.respond_to?(:header)
+          names = attribute.header.attribute_names
+
+          if value.is_a?(Hash)
+            tuple << value.values_at(*names)
+          elsif value.is_a?(Array)
+            tuple << value.map { |v| v.values_at(*names) }
+          else
+            raise NotImplementedError
+          end
+        else
+          tuple << value
+        end
+      end
+    end
+
+    # TODO: this should map the wrapping hash into {Symbol => Mapper::Header}
+    #       otherwise header is coupled to mapper
+    #
+    # @api public
+    def wrap(other)
+      new(header.wrap(other))
+    end
+
+    # TODO: this should map the grouping hash into {Symbol => Mapper::Header}
+    #       otherwise header is coupled to mapper
+    #
+    # @api public
+    def group(other)
+      new(header.group(other))
+    end
+
+    # @api public
+    def join(other)
+      new(header.join(other.header))
+    end
+
+    # @api public
+    def project(names)
+      new(header.project(names))
+    end
+
+    # @api public
+    def rename(names)
+      new(header.rename(names))
+    end
+
+    # @api private
+    def attribute(type, name)
+      type.build(name, type: model, header: header, node: loader.node)
+    end
+
+    # @api private
+    def new(new_header)
+      self.class.build(new_header, options)
+    end
+
+  end # Mapper
+
+end # ROM

data/lib/rom/mapper/attribute.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+
+module ROM
+  class Mapper
+
+    # Represents a mapping attribute
+    #
+    # @private
+    class Attribute
+      include Adamantium, Concord::Public.new(:name, :options), Morpher::NodeHelpers
+
+      class EmbeddedValue < Attribute
+
+        # @api private
+        def to_ast
+          s(:key_transform, name, name, node)
+        end
+        memoize :to_ast
+
+        # @api private
+        def header
+          options.fetch(:header)
+        end
+        memoize :header
+
+        private
+
+        # @api private
+        def node
+          options.fetch(:node)
+        end
+        memoize :node
+      end
+
+      class EmbeddedCollection < Attribute
+
+        # @api private
+        def to_ast
+          s(:key_transform, name, name, s(:map, node))
+        end
+        memoize :to_ast
+
+        # @api private
+        def header
+          options.fetch(:header)
+        end
+        memoize :header
+
+        private
+
+        # @api private
+        def node
+          options.fetch(:node)
+        end
+        memoize :node
+      end
+
+      # @api private
+      def self.build(*args)
+        input = args.first
+
+        if input.kind_of?(self)
+          input
+        else
+          name, options = args
+          new(name, options || {})
+        end
+      end
+
+      # @api private
+      def to_ast
+        s(:block, s(:key_fetch, tuple_key), s(:key_dump, name))
+      end
+      memoize :to_ast
+
+      # @api private
+      def key?
+        options.fetch(:key, false)
+      end
+      memoize :key?
+
+      # @api private
+      def mapping
+        { tuple_key => name }
+      end
+      memoize :mapping
+
+      # @api private
+      def tuple_key
+        options[:from] || name
+      end
+      memoize :tuple_key
+
+      # @api private
+      def type
+        options[:type] || Object
+      end
+      memoize :type
+
+      # @api private
+      def rename(new_name)
+        self.class.new(new_name, options)
+      end
+
+    end # Attribute
+
+  end # Mapper
+end # ROM