rom 0.2.0 → 0.3.0

data/lib/rom/boot/schema_dsl.rb

@@ -0,0 +1,27 @@
+require 'rom/boot/base_relation_dsl'
+
+module ROM
+  class Boot
+
+    class SchemaDSL
+      attr_reader :env, :schema
+
+      def initialize(env, schema = {})
+        @env = env
+        @schema = schema
+      end
+
+      def base_relation(name, &block)
+        dsl = BaseRelationDSL.new(env, name)
+        definition = dsl.call(&block)
+        (schema[dsl.repository] ||= []) << definition
+      end
+
+      def call
+        schema
+      end
+
+    end
+
+  end
+end

data/lib/rom/env.rb

@@ -0,0 +1,48 @@
+module ROM
+
+  # Exposes defined repositories, schema, relations and mappers
+  #
+  # @api public
+  class Env
+    include Adamantium::Flat
+
+    attr_reader :repositories, :schema, :relations, :mappers
+
+    # @api private
+    def initialize(repositories, schema, relations, mappers)
+      @repositories = repositories
+      @schema = schema
+      @relations = relations
+      @mappers = mappers
+    end
+
+    # Returns a reader with access to defined mappers
+    #
+    # @example
+    #
+    #   rom.read(:users).adults.to_a
+    #
+    # @api public
+    def read(name)
+      mappers[name]
+    end
+
+    # @api private
+    def [](name)
+      repositories.fetch(name)
+    end
+
+    # @api private
+    def respond_to_missing?(name, include_private = false)
+      repositories.key?(name)
+    end
+
+    private
+
+    # @api private
+    def method_missing(name, *args)
+      repositories.fetch(name)
+    end
+  end
+
+end

data/lib/rom/header.rb

@@ -0,0 +1,123 @@
+module ROM
+
+  # @api private
+  class Header
+    include Enumerable
+    include Equalizer.new(:attributes)
+
+    attr_reader :attributes
+
+    class Attribute
+      include Equalizer.new(:name, :key, :type)
+
+      attr_reader :name, :key, :meta
+
+      class Embedded < Attribute
+        include Equalizer.new(:name, :type, :model, :header)
+
+        def model
+          meta[:model]
+        end
+
+        def header
+          meta.fetch(:header)
+        end
+
+        def mapping
+          [name, header.mapping]
+        end
+
+        def embedded?
+          true
+        end
+
+      end
+
+      def self.[](type)
+        if type == Array || type == Hash
+          Embedded
+        else
+          self
+        end
+      end
+
+      def self.coerce(input)
+        if input.kind_of?(self)
+          input
+        else
+          name = input[0]
+          meta = (input[1] || {}).dup
+
+          meta[:type] ||= Object
+
+          if meta.key?(:header)
+            meta[:header] = Header.coerce(meta[:header])
+          end
+
+          self[meta[:type]].new(name, meta)
+        end
+      end
+
+      def initialize(name, meta = {})
+        @name = name
+        @meta = meta
+        @key = meta.fetch(:from) { name }
+      end
+
+      def type
+        meta.fetch(:type)
+      end
+
+      def aliased?
+        key != name
+      end
+
+      def embedded?
+        false
+      end
+
+      def mapping
+        [key, name]
+      end
+    end
+
+    def self.coerce(input)
+      if input.kind_of?(self)
+        input
+      else
+        attributes = input.each_with_object({}) { |pair, h|
+          h[pair.first] = Attribute.coerce(pair)
+        }
+
+        new(attributes)
+      end
+    end
+
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def each(&block)
+      return to_enum unless block
+      attributes.values.each(&block)
+    end
+
+    def keys
+      attributes.keys
+    end
+
+    def mapping
+      Hash[map(&:mapping)]
+    end
+
+    def values
+      attributes.values
+    end
+
+    def [](name)
+      attributes.fetch(name)
+    end
+
+  end
+
+end

data/lib/rom/mapper.rb

@@ -1,176 +1,61 @@
-# 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
-  #
+  # @api private
   class Mapper
-    include Equalizer.new(:header, :options)
-
-    DEFAULT_LOADER = :load_instance_variables
-
-    attr_reader :header, :loader, :dumper, :model, :type, :options
+    attr_reader :header, :model
 
-    # 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)
+    class Basic < Mapper
+      attr_reader :mapping
 
-      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
+      def initialize(header, model)
+        super
+        @mapping = header.mapping
+      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
+      def load(tuple, mapping = self.mapping)
+        model.new(Hash[call(tuple, mapping)])
+      end
 
-    # Load an object instance from the tuple
-    #
-    # @api public
-    def load(tuple)
-      loader.call(tuple)
+      def call(tuple, mapping = self.mapping)
+        tuple.map { |key, value| [mapping[key], value] }
+      end
     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) }
+    class Recursive < Basic
+      def call(tuple, mapping = self.mapping)
+        tuple.map do |key, value|
+          case value
+          when Hash  then [key, Hash[call(value, mapping[key])]]
+          when Array then [key, value.map { |v| Hash[call(v, mapping[key])] }]
           else
-            raise NotImplementedError
+            [mapping[key], value]
           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
+    def self.build(header, model)
+      klass =
+        if header.any? { |attribute| attribute.embedded? }
+          Recursive
+        elsif header.any? { |attribute| attribute.aliased? }
+          Basic
+        else
+          self
+        end
 
-    # @api public
-    def rename(names)
-      new(header.rename(names))
+      klass.new(header, model)
     end
 
-    # @api private
-    def attribute(type, name)
-      type.build(name, type: model, header: header, node: loader.node)
+    def initialize(header, model)
+      @header = header
+      @model = model
     end
 
-    # @api private
-    def new(new_header)
-      self.class.build(new_header, options)
+    def load(tuple)
+      model.new(tuple)
     end
 
-  end # Mapper
+  end
 
-end # ROM
+end

data/lib/rom/mapper_builder.rb

@@ -0,0 +1,85 @@
+require 'rom/model_builder'
+
+module ROM
+
+  # @api private
+  class MapperBuilder
+
+    class AttributeDSL
+      attr_reader :attributes
+
+      def initialize
+        @attributes = []
+      end
+
+      def header
+        Header.coerce(attributes)
+      end
+
+      def attribute(name, options)
+        attributes << [name, options]
+      end
+    end
+
+    attr_reader :name, :root, :prefix,
+      :model_builder, :model_class, :attributes
+
+    def initialize(name, root, options = {})
+      @name = name
+      @root = root
+      @prefix = options[:prefix]
+      @attributes = root.header.map { |attr| [prefix ? :"#{prefix}_#{attr}" : attr] }
+    end
+
+    def model(options)
+      if options.is_a?(Class)
+        @model_class = options
+      else
+        @model_builder = ModelBuilder[options.fetch(:type) { :poro }].new(options)
+      end
+
+      self
+    end
+
+    def attribute(name, options = {})
+      options[:from] = :"#{prefix}_#{name}" if prefix
+      attributes << [name, options]
+    end
+
+    def exclude(name)
+      attributes.delete([name])
+    end
+
+    def group(options, &block)
+      attribute_dsl(options, Array, &block)
+    end
+
+    def wrap(options, &block)
+      attribute_dsl(options, Hash, &block)
+    end
+
+    def call
+      header = Header.coerce(attributes)
+
+      @model_class = model_builder.call(header) if model_builder
+
+      Mapper.build(header, model_class)
+    end
+
+    private
+
+    def attribute_dsl(options, type, &block)
+      if block
+        dsl = AttributeDSL.new
+        dsl.instance_exec(&block)
+        attributes << [options, header: dsl.header, type: type]
+      else
+        options.each do |name, header|
+          attributes << [name, header: header.zip, type: type]
+        end
+      end
+    end
+
+  end
+
+end