rom 0.4.2 → 0.5.0

data/lib/rom/header/attribute.rb

@@ -0,0 +1,148 @@
+module ROM
+  class Header
+    # An attribute provides information about a specific attribute in a tuple
+    #
+    # This may include information about how an attribute should be renamed,
+    # or how its value should coerced.
+    #
+    # More complex attributes describe how an attribute should be transformed.
+    #
+    # @private
+    class Attribute
+      include Equalizer.new(:name, :key, :type)
+
+      # @return [Symbol] name of an attribute
+      #
+      # @api private
+      attr_reader :name
+
+      # @return [Symbol] key of an attribute that corresponds to tuple attribute
+      #
+      # @api private
+      attr_reader :key
+
+      # @return [Symbol] type identifier (defaults to :object)
+      #
+      # @api private
+      attr_reader :type
+
+      # @return [Hash] additional meta information
+      #
+      # @api private
+      attr_reader :meta
+
+      # Return attribute class for a give meta hash
+      #
+      # @param [Hash] hash with type information and optional transformation info
+      #
+      # @return [Class]
+      #
+      # @api private
+      def self.[](meta)
+        type = meta[:type]
+
+        if type.equal?(:hash)
+          meta[:wrap] ? Wrap : Hash
+        elsif type.equal?(:array)
+          meta[:group] ? Group : Array
+        else
+          self
+        end
+      end
+
+      # Coerce an array with attribute meta-data into an attribute object
+      #
+      # @param [Array<Symbol,Hash>] name/options pair
+      #
+      # @return [Attribute]
+      #
+      # @api private
+      def self.coerce(input)
+        name = input[0]
+        meta = (input[1] || {}).dup
+
+        meta[:type] ||= :object
+
+        if meta.key?(:header)
+          meta[:header] = Header.coerce(meta[:header], meta[:model])
+        end
+
+        self[meta].new(name, meta)
+      end
+
+      # @api private
+      def initialize(name, meta)
+        @name = name
+        @meta = meta
+        @key = meta.fetch(:from) { name }
+        @type = meta.fetch(:type)
+      end
+
+      # Return if an attribute has a specific type identifier
+      #
+      # @api private
+      def typed?
+        type != :object
+      end
+
+      # Return if an attribute should be aliased
+      #
+      # @api private
+      def aliased?
+        key != name
+      end
+
+      # Return :key-to-:name mapping hash
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def mapping
+        { key => name }
+      end
+    end
+
+    # Embedded attribute is a special attribute type that has a header
+    #
+    # This is the base of complex attributes like Hash or Group
+    #
+    # @private
+    class Embedded < Attribute
+      include Equalizer.new(:name, :key, :type, :header)
+
+      # return [Header] header of an attribute
+      #
+      # @api private
+      attr_reader :header
+
+      # @api private
+      def initialize(*)
+        super
+        @header = meta.fetch(:header)
+      end
+
+      # Return tuple keys from the header
+      #
+      # @return [Array<Symbol>]
+      #
+      # @api private
+      def tuple_keys
+        header.tuple_keys
+      end
+    end
+
+    # Array is an embedded attribute type
+    Array = Class.new(Embedded)
+
+    # Hash is an embedded attribute type
+    Hash = Class.new(Embedded)
+
+    # Wrap is a special type of Hash attribute that requires wrapping
+    # transformation
+    Wrap = Class.new(Hash)
+
+    # Group is a special type of Array attribute that requires grouping
+    # transformation
+    Group = Class.new(Array)
+  end
+end

data/lib/rom/mapper.rb

@@ -1,83 +1,62 @@
 module ROM
-
-  # @api private
+  # Mapper is a simple object that uses a transformer to load relations
+  #
+  # @private
   class Mapper
-    attr_reader :header, :model, :loader, :transformer
-
-    class Basic < Mapper
-      attr_reader :mapping
-
-      def initialize(*args)
-        super
-        @mapping = header.mapping
-      end
-
-      def load(tuple)
-        super(Hash[call(tuple)])
-      end
-
-      def call(tuple)
-        tuple.map { |key, value| [header.mapping[key], value] }
-      end
+    # @return [Object] transformer object built by a processor
+    #
+    # @api private
+    attr_reader :transformer
+
+    # @return [Header] header that was used to build the transformer
+    #
+    # @api private
+    attr_reader :header
+
+    # @return [Hash] registered processors
+    #
+    # @api private
+    def self.processors
+      @_processors ||= {}
     end
 
-    class Recursive < Basic
-      attr_reader :transformer
-
-      def initialize(*args)
-        super
-        @transformer = Transformer.build(header)
-      end
-
-      def process(relation)
-        transformer.call(relation.to_a).each { |tuple| yield(load(tuple)) }
-      end
-
-      def call(tuple, header = self.header)
-        mapping = header.mapping
-
-        tuple.map do |key, value|
-          case value
-          when Hash
-            [key, loader[Hash[call(value, header[key])], header[key].model]]
-          when Array
-            [key, value.map { |v| loader[Hash[call(v, header[key])], header[key].model] }]
-          else
-            [mapping[key], value]
-          end
-        end
-      end
+    # Register a processor class
+    #
+    # @return [Hash]
+    #
+    # @api private
+    def self.register_processor(processor)
+      name = processor.name.split('::').last.downcase.to_sym
+      processors.update(name => processor)
     end
 
-    def self.build(header, model)
-      klass =
-        if header.any? { |attribute| attribute.embedded? }
-          Recursive
-        elsif header.any? { |attribute| attribute.aliased? }
-          Basic
-        else
-          self
-        end
-
-      loader = Proc.new { |tuple, m| m ? m.new(tuple) : tuple }
-
-      klass.new(header, model, loader)
+    # Build a mapper using provided processor type
+    #
+    # @return [Mapper]
+    #
+    # @api private
+    def self.build(header, processor = :transproc)
+      new(processors.fetch(processor).build(header), header)
     end
 
-    def initialize(header, model, loader)
+    # @api private
+    def initialize(transformer, header)
+      @transformer = transformer
       @header = header
-      @model = model
-      @loader = loader
     end
 
-    def process(relation)
-      relation.each { |tuple| yield(load(tuple)) }
+    # @return [Class] optional model that is instantiated by a mapper
+    #
+    # @api private
+    def model
+      header.model
     end
 
-    def load(tuple)
-      loader[tuple, model]
+    # Process a relation using the transfomer
+    #
+    # @api private
+    def process(relation, &block)
+      transformer[relation.to_a].each(&block)
     end
-
   end
-
 end

data/lib/rom/mapper_builder.rb

@@ -1,105 +1,52 @@
-require 'rom/model_builder'
+require 'rom/mapper_builder/model_dsl'
+require 'rom/mapper_builder/mapper_dsl'
 
 module ROM
-
   # @api private
   class MapperBuilder
+    attr_reader :name, :root, :options, :prefix, :symbolize_keys, :dsl
 
-    class AttributeDSL
-      attr_reader :attributes, :model_class, :model_builder
-
-      def initialize
-        @attributes = []
-      end
-
-      def header
-        Header.coerce(attributes)
-      end
-
-      def model(options = nil)
-        if options.is_a?(Class)
-          @model_class = options
-        elsif options
-          @model_builder = ModelBuilder[options.fetch(:type) { :poro }].new(options)
-        end
-
-        if options
-          self
-        else
-          model_class || (model_builder && model_builder.call(header))
-        end
-      end
-
-      def attribute(name, options = {})
-        attributes << [name, options]
-      end
-    end
-
-    attr_reader :name, :root, :prefix,
-      :model_builder, :model_class, :attributes
+    DEFAULT_PROCESSOR = :transproc
 
     def initialize(name, root, options = {})
       @name = name
+      @options = options
       @root = root
       @prefix = options[:prefix]
+      @symbolize_keys = options[:symbolize_keys]
 
-      @attributes =
+      attributes =
         if options[:inherit_header]
           root.header.map { |attr| [prefix ? :"#{prefix}_#{attr}" : attr] }
         else
           []
         end
-    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
+      @dsl = MapperDSL.new(attributes, options)
 
-    def group(options, &block)
-      attribute_dsl(options, Array, &block)
+      @processor = DEFAULT_PROCESSOR
     end
 
-    def wrap(options, &block)
-      attribute_dsl(options, Hash, &block)
+    def processor(identifier = nil)
+      if identifier
+        @processor = identifier
+      else
+        @processor
+      end
     end
 
     def call
-      header = Header.coerce(attributes)
-
-      @model_class = model_builder.call(header) if model_builder
-
-      Mapper.build(header, model_class)
+      Mapper.build(dsl.header, processor)
     end
 
     private
 
-    def attribute_dsl(options, type, &block)
-      if block
-        dsl = AttributeDSL.new
-        dsl.instance_exec(&block)
-        attributes << [options, header: dsl.header, type: type, model: dsl.model]
+    def method_missing(name, *args, &block)
+      if dsl.respond_to?(name)
+        dsl.public_send(name, *args, &block)
       else
-        options.each do |name, header|
-          attributes << [name, header: header.zip, type: type]
-        end
+        super
       end
     end
-
   end
-
 end

data/lib/rom/mapper_builder/mapper_dsl.rb

@@ -0,0 +1,114 @@
+require 'rom/mapper_builder/model_dsl'
+
+module ROM
+  class MapperBuilder
+    # @api private
+    class MapperDSL
+      include ModelDSL
+
+      attr_reader :attributes, :options, :symbolize_keys, :prefix
+
+      def initialize(attributes, options)
+        @attributes = attributes
+        @options = options
+        @symbolize_keys = options[:symbolize_keys]
+        @prefix = options[:prefix]
+      end
+
+      def attribute(name, options = EMPTY_HASH)
+        with_attr_options(name, options) do |attr_options|
+          add_attribute(name, attr_options)
+        end
+      end
+
+      def exclude(*names)
+        names.each { |name| attributes.delete([name]) }
+      end
+
+      def embedded(name, options, &block)
+        with_attr_options(name) do |attr_options|
+          dsl = new(options, &block)
+
+          attr_options.update(options)
+
+          add_attribute(
+            name, { header: dsl.header, type: :array }.update(attr_options)
+          )
+        end
+      end
+
+      def wrap(*args, &block)
+        with_name_or_options(*args) do |name, options|
+          dsl(name, { type: :hash, wrap: true }.update(options), &block)
+        end
+      end
+
+      def group(*args, &block)
+        with_name_or_options(*args) do |name, options|
+          dsl(name, { type: :array, group: true }.update(options), &block)
+        end
+      end
+
+      def header
+        Header.coerce(attributes, model)
+      end
+
+      private
+
+      def with_attr_options(name, options = EMPTY_HASH)
+        attr_options = options.dup
+
+        attr_options[:from] ||= :"#{prefix}_#{name}" if prefix
+
+        if symbolize_keys
+          attr_options.update(from: attr_options.fetch(:from) { name }.to_s)
+        end
+
+        yield(attr_options)
+      end
+
+      def with_name_or_options(*args)
+        name, options =
+          if args.size > 1
+            args
+          else
+            [args.first, {}]
+          end
+
+        yield(name, options)
+      end
+
+      def dsl(name_or_attrs, options, &block)
+        if block
+          attributes_from_block(name_or_attrs, options, &block)
+        else
+          attributes_from_hash(name_or_attrs, options)
+        end
+      end
+
+      def attributes_from_block(name, options, &block)
+        dsl = new(options, &block)
+        add_attribute(name, options.update(header: dsl.header))
+      end
+
+      def attributes_from_hash(hash, options)
+        hash.each do |name, header|
+          with_attr_options(name, options) do |attr_options|
+            add_attribute(name, attr_options.update(header: header.zip))
+          end
+        end
+      end
+
+      def add_attribute(name, options)
+        exclude(name, name.to_s)
+        attributes << [name, options]
+      end
+
+      def new(options, &block)
+        dsl = self.class.new([], @options.merge(options))
+        dsl.instance_exec(&block)
+        dsl
+      end
+    end
+  end
+end