rom 0.6.2 → 0.7.0

data/lib/rom/header.rb

@@ -1,3 +1,6 @@
+require 'equalizer'
+
+require 'rom/support/options'
 require 'rom/header/attribute'
 
 module ROM
@@ -9,15 +12,18 @@ module ROM
   # @private
   class Header
     include Enumerable
+    include Options
     include Equalizer.new(:attributes, :model)
 
-    # @api private
-    attr_reader :attributes
-
     # @return [Class] optional model associated with a header
     #
     # @api private
-    attr_reader :model
+    option :model, reader: true
+
+    option :reject_keys, reader: true, default: false
+
+    # @api private
+    attr_reader :attributes
 
     # @return [Hash] attribute key/name mapping for all primitive attributes
     #
@@ -38,7 +44,7 @@ module ROM
     # @return [Header]
     #
     # @api private
-    def self.coerce(input, model = nil)
+    def self.coerce(input, options = {})
       if input.instance_of?(self)
         input
       else
@@ -46,14 +52,14 @@ module ROM
           h[pair.first] = Attribute.coerce(pair)
         }
 
-        new(attributes, model)
+        new(attributes, options)
       end
     end
 
     # @api private
-    def initialize(attributes, model = nil)
+    def initialize(attributes, options = {})
+      super
       @attributes = attributes
-      @model = model
       initialize_mapping
       initialize_tuple_keys
     end
@@ -110,6 +116,11 @@ module ROM
       by_type(Wrap)
     end
 
+    # @api private
+    def combined
+      by_type(Combined)
+    end
+
     # Return all primitive attributes (no Group and Wrap)
     #
     # @return [Array<Attribute>]

data/lib/rom/header/attribute.rb

@@ -41,7 +41,11 @@ module ROM
       def self.[](meta)
         type = meta[:type]
 
-        if type.equal?(:hash)
+        if meta[:combine]
+          Combined
+        elsif meta[:unwrap]
+          Unwrap
+        elsif type.equal?(:hash)
           meta[:wrap] ? Wrap : Hash
         elsif type.equal?(:array)
           meta[:group] ? Group : Array
@@ -64,7 +68,7 @@ module ROM
         meta[:type] ||= :object
 
         if meta.key?(:header)
-          meta[:header] = Header.coerce(meta[:header], meta[:model])
+          meta[:header] = Header.coerce(meta[:header], model: meta[:model])
         end
 
         self[meta].new(name, meta)
@@ -137,10 +141,18 @@ module ROM
     # Hash is an embedded attribute type
     Hash = Class.new(Embedded)
 
+    # Combined is an embedded attribute type describing combination of multiple
+    # relations
+    Combined = Class.new(Embedded)
+
     # Wrap is a special type of Hash attribute that requires wrapping
     # transformation
     Wrap = Class.new(Hash)
 
+    # Unwrap is a special type of Hash attribute that requires unwrapping
+    # transformation
+    Unwrap = Class.new(Hash)
+
     # Group is a special type of Array attribute that requires grouping
     # transformation
     Group = Class.new(Array)

data/lib/rom/lint/enumerable_dataset.rb

@@ -33,7 +33,9 @@ module ROM
       # @api public
       def lint_each
         result = []
-        dataset.each { |tuple| result << tuple }
+        dataset.each do |tuple|
+          result << tuple
+        end
         return if result == data
 
         complain "#{dataset.class}#each must yield tuples"

data/lib/rom/lint/repository.rb

@@ -22,6 +22,11 @@ module ROM
       # @api public
       attr_reader :uri
 
+      # Repository instance used in lint tests
+      #
+      # @api private
+      attr_reader :repository_instance
+
       # Create a repository linter
       #
       # @param [Symbol] identifier
@@ -66,11 +71,6 @@ module ROM
 
       private
 
-      # Repository instance
-      #
-      # @api private
-      attr_reader :repository_instance
-
       # Setup repository instance
       #
       # @api private

data/lib/rom/mapper.rb

@@ -9,9 +9,10 @@ module ROM
     include Equalizer.new(:transformer, :header)
 
     defines :relation, :register_as, :symbolize_keys,
-      :prefix, :prefix_separator, :inherit_header
+      :prefix, :prefix_separator, :inherit_header, :reject_keys
 
     inherit_header true
+    reject_keys false
     prefix_separator '_'.freeze
 
     # @return [Object] transformer object built by a processor

data/lib/rom/mapper/attribute_dsl.rb

@@ -8,11 +8,14 @@ module ROM
     # This class is private even though its methods are exposed by mappers.
     # Typically it's not meant to be used directly.
     #
-    # @private
+    # TODO: break this madness down into smaller pieces
+    #
+    # @api private
     class AttributeDSL
       include ModelDSL
 
-      attr_reader :attributes, :options, :symbolize_keys, :prefix, :prefix_separator
+      attr_reader :attributes, :options, :symbolize_keys, :prefix,
+        :prefix_separator, :reject_keys
 
       # @param [Array] attributes accumulator array
       # @param [Hash] options
@@ -24,6 +27,7 @@ module ROM
         @symbolize_keys = options.fetch(:symbolize_keys)
         @prefix = options.fetch(:prefix)
         @prefix_separator = options.fetch(:prefix_separator)
+        @reject_keys = options.fetch(:reject_keys)
       end
 
       # Define a mapping attribute with its options
@@ -80,13 +84,19 @@ module ROM
       # @api public
       def embedded(name, options, &block)
         with_attr_options(name) do |attr_options|
-          dsl = new(options, &block)
-
-          attr_options.update(options)
+          mapper = options[:mapper]
 
-          add_attribute(
-            name, { header: dsl.header, type: :array }.update(attr_options)
-          )
+          if mapper
+            attributes_from_mapper(
+              mapper, name, { type: :array }.update(attr_options)
+            )
+          else
+            dsl = new(options, &block)
+            attr_options.update(options)
+            add_attribute(
+              name, { header: dsl.header, type: :array }.update(attr_options)
+            )
+          end
         end
       end
 
@@ -110,8 +120,20 @@ module ROM
       #
       # @api public
       def wrap(*args, &block)
+        with_name_or_options(*args) do |name, options, mapper|
+          wrap_options = { type: :hash, wrap: true }.update(options)
+
+          if mapper
+            attributes_from_mapper(mapper, name, wrap_options)
+          else
+            dsl(name, wrap_options, &block)
+          end
+        end
+      end
+
+      def unwrap(*args, &block)
         with_name_or_options(*args) do |name, options|
-          dsl(name, { type: :hash, wrap: true }.update(options), &block)
+          dsl(name, { type: :hash, unwrap: true }.update(options), &block)
         end
       end
 
@@ -133,18 +155,56 @@ module ROM
       #
       # @api public
       def group(*args, &block)
-        with_name_or_options(*args) do |name, options|
-          dsl(name, { type: :array, group: true }.update(options), &block)
+        with_name_or_options(*args) do |name, options, mapper|
+          group_options = { type: :array, group: true }.update(options)
+
+          if mapper
+            attributes_from_mapper(mapper, name, group_options)
+          else
+            dsl(name, group_options, &block)
+          end
         end
       end
 
+      # Define an embedded combined attribute that requires "combine" transformation
+      #
+      # Typically this can be used to process results of eager-loading
+      #
+      # @example
+      #   dsl = AttributeDSL.new([])
+      #
+      #   dsl.combine(:tags, user_id: :id) do
+      #     model Tag
+      #
+      #     attribute :name
+      #   end
+      #
+      # @param [Symbol] name
+      # @param [Hash] options
+      #   @option options [Hash] :on The "join keys"
+      #   @option options [Symbol] :type The type, either :array (default) or :hash
+      #
+      # @api public
+      def combine(name, options, &block)
+        dsl = new(options, &block)
+
+        attr_opts = {
+          type: options.fetch(:type, :array),
+          keys: options.fetch(:on),
+          combine: true,
+          header: dsl.header,
+        }
+
+        add_attribute(name, attr_opts)
+      end
+
       # Generate a header from attribute definitions
       #
       # @return [Header]
       #
       # @api private
       def header
-        Header.coerce(attributes, model)
+        Header.coerce(attributes, model: model, reject_keys: reject_keys)
       end
 
       private
@@ -175,7 +235,7 @@ module ROM
             [args.first, {}]
           end
 
-        yield(name, options)
+        yield(name, options, options[:mapper])
       end
 
       # Create another instance of the dsl for nested definitions
@@ -217,6 +277,19 @@ module ROM
         end
       end
 
+      # Infer mapper header for an embedded attribute
+      #
+      # @api private
+      def attributes_from_mapper(mapper, name, options)
+        if mapper.is_a?(Class)
+          add_attribute(name, { header: mapper.header }.update(options))
+        else
+          raise(
+            ArgumentError, ":mapper must be a class #{mapper.inspect}"
+          )
+        end
+      end
+
       # Add a new attribute and make sure it overrides previous definition
       #
       # @api private

data/lib/rom/mapper/dsl.rb

@@ -27,6 +27,19 @@ module ROM
           klass.instance_variable_set('@dsl', nil)
         end
 
+        # include a registered plugin in this mapper
+        #
+        # @param [Symbol] plugin
+        # @param [Hash] options
+        # @option options [Symbol] :adapter (:default) first adapter to check for plugin
+        #
+        # @api public
+        def use(plugin, options = {})
+          adapter = options.fetch(:adapter, :default)
+
+          ROM.plugin_registry.mappers.fetch(plugin, adapter).apply_to(self)
+        end
+
         # Return base_relation used for creating mapper registry
         #
         # This is used to "gather" mappers under same root name
@@ -52,6 +65,11 @@ module ROM
           @header ||= dsl.header
         end
 
+        # @api private
+        def respond_to_missing?(name, _include_private = false)
+          dsl.respond_to?(name) || super
+        end
+
         private
 
         # Return default Attribute DSL options based on settings of the mapper
@@ -61,7 +79,8 @@ module ROM
         def options
           { prefix: prefix,
             prefix_separator: prefix_separator,
-            symbolize_keys: symbolize_keys }
+            symbolize_keys: symbolize_keys,
+            reject_keys: reject_keys }
         end
 
         # Return default attributes that might have been inherited from the

data/lib/rom/memory/commands.rb

@@ -37,7 +37,9 @@ module ROM
         # @see ROM::Commands::Delete#execute
         def execute
           tuples = target.to_a
-          tuples.each { |tuple| relation.delete(tuple) }
+          tuples.each do |tuple|
+            relation.delete(tuple)
+          end
           tuples
         end
       end

data/lib/rom/memory/dataset.rb

@@ -23,7 +23,7 @@ module ROM
           join_map[tuple].map { |other| tuple.merge(other) }
         }
 
-        self.class.new(tuples, row_proc)
+        self.class.new(tuples, options)
       end
 
       # Restrict a dataset

data/lib/rom/memory/relation.rb

@@ -10,7 +10,7 @@ module ROM
     class Relation < ROM::Relation
       include Enumerable
 
-      forward :join, :project, :restrict, :order
+      forward :take, :join, :project, :restrict, :order
 
       # Insert tuples into the relation
       #

data/lib/rom/pipeline.rb

@@ -0,0 +1,91 @@
+module ROM
+  # Data pipeline common interface
+  #
+  # @api private
+  module Pipeline
+    # Compose two relation with a left-to-right composition
+    #
+    # @example
+    #   users.by_name('Jane') >> tasks.for_users
+    #
+    # @param [Relation] other The right relation
+    #
+    # @return [Relation::Composite]
+    #
+    # @api public
+    def >>(other)
+      Relation::Composite.new(self, other)
+    end
+
+    # Send data through specified mappers
+    #
+    # @return [Relation::Composite]
+    #
+    # @api public
+    def map_with(*names)
+      [self, *names.map { |name| mappers[name] }]
+        .reduce { |a, e| Relation::Composite.new(a, e) }
+    end
+    alias_method :as, :map_with
+
+    # Forwards messages to the left side of a pipeline
+    #
+    # @api private
+    module Proxy
+      # @api private
+      def respond_to_missing?(name, include_private = false)
+        left.respond_to?(name) || super
+      end
+
+      private
+
+      # Check if response from method missing should be decorated
+      #
+      # @api private
+      def decorate?(response)
+        response.is_a?(left.class)
+      end
+
+      # @api private
+      def method_missing(name, *args, &block)
+        if left.respond_to?(name)
+          response = left.__send__(name, *args, &block)
+
+          if decorate?(response)
+            self.class.new(response, right)
+          else
+            response
+          end
+        else
+          super
+        end
+      end
+    end
+
+    # Base composite class with left-to-right pipeline behavior
+    #
+    # @api private
+    class Composite
+      include Equalizer.new(:left, :right)
+      include Proxy
+
+      # @api private
+      attr_reader :left
+
+      # @api private
+      attr_reader :right
+
+      # @api private
+      def initialize(left, right)
+        @left, @right = left, right
+      end
+
+      # Compose this composite with another object
+      #
+      # @api public
+      def >>(other)
+        self.class.new(self, other)
+      end
+    end
+  end
+end