rom 0.6.2 → 0.7.0

data/lib/rom/plugin.rb

@@ -0,0 +1,31 @@
+module ROM
+  # Plugin is a simple object used to store plugin configurations
+  #
+  # @private
+  class Plugin
+    # @return [Module] a module representing the plugin
+    #
+    # @api private
+    attr_reader :mod
+
+    # @return [Hash] configuration options
+    #
+    # @api private
+    attr_reader :options
+
+    # @api private
+    def initialize(mod, options)
+      @mod      = mod
+      @options  = options
+    end
+
+    # Apply this plugin to the provided class
+    #
+    # @param klass [Class]
+    #
+    # @api private
+    def apply_to(klass)
+      klass.send(:include, mod)
+    end
+  end
+end

data/lib/rom/plugin_registry.rb

@@ -0,0 +1,134 @@
+require 'rom/support/registry'
+
+module ROM
+  # Stores all registered plugins
+  #
+  # @api private
+  class PluginRegistry
+    # Internal registry for command plugins
+    #
+    # @return [InternalPluginRegistry]
+    #
+    # @api private
+    attr_reader :commands
+
+    # Internal registry for mapper plugins
+    #
+    # @return [InternalPluginRegistry]
+    #
+    # @api private
+    attr_reader :mappers
+
+    # Internal registry for relation plugins
+    #
+    # @return [InternalPluginRegistry]
+    #
+    # @api private
+    attr_reader :relations
+
+    # @api private
+    def initialize
+      @mappers = InternalPluginRegistry.new
+      @commands = InternalPluginRegistry.new
+      @relations = InternalPluginRegistry.new
+    end
+
+    # Register a plugin for future use
+    #
+    # @param [Symbol] name The registration name for the plugin
+    # @param [Module] mod The plugin to register
+    # @param [Hash] options optional configuration data
+    # @option options [Symbol] :type What type of plugin this is (command,
+    # relation or mapper)
+    # @option options [Symbol] :adapter (:default) which adapter this plugin
+    # applies to. Leave blank for all adapters
+    def register(name, mod, options = {})
+      type    = options.fetch(:type)
+      adapter = options.fetch(:adapter, :default)
+
+      plugins_for(type, adapter)[name] = Plugin.new(mod, options)
+    end
+
+    private
+
+    # Determine which specific registry to use
+    #
+    # @api private
+    def plugins_for(type, adapter)
+      case type
+      when :command   then commands.adapter(adapter)
+      when :mapper    then mappers.adapter(adapter)
+      when :relation  then relations.adapter(adapter)
+      end
+    end
+  end
+
+  # A registry storing specific plugins
+  #
+  # @api private
+  class AdapterPluginRegistry < Registry
+    # Assign a plugin to this adapter registry
+    #
+    # @param [Symbol] name The registered plugin name
+    # @param [Plugin] plugin The plugin to register
+    #
+    # @api private
+    def []=(name, plugin)
+      elements[name] = plugin
+    end
+
+    # Retrieve a registered plugin
+    #
+    # @param [Symbol] name The plugin to retrieve
+    #
+    # @return [Plugin]
+    #
+    # @api public
+    def [](name)
+      elements[name]
+    end
+  end
+
+  # Store a set of registries grouped by adapter
+  #
+  # @api private
+  class InternalPluginRegistry
+    # Return the existing registries
+    #
+    # @return [Hash]
+    #
+    # @api private
+    attr_reader :registries
+
+    # @api private
+    def initialize
+      @registries = Hash.new { |h, v| h[v] = AdapterPluginRegistry.new }
+    end
+
+    # Return the plugin registry for a specific adapter
+    #
+    # @param [Symbol] name The name of the adapter
+    #
+    # @return [AdapterRegistry]
+    #
+    # @api private
+    def adapter(name)
+      registries[name]
+    end
+
+    # Return the plugin for a given adapter
+    #
+    # @param [Symbol] name The name of the plugin
+    # @param [Symbol] adapter (:default) The name of the adapter used
+    #
+    # @raises [UnknownPluginError] if no plugin is found with the given name
+    #
+    # @api public
+    def fetch(name, adapter_name = :default)
+      adapter(adapter_name)[name] || adapter(:default)[name] ||
+        raise(UnknownPluginError, name)
+    end
+
+    alias [] fetch
+  end
+end

data/lib/rom/plugins/relation/registry_reader.rb

@@ -0,0 +1,30 @@
+module ROM
+  module Plugins
+    module Relation
+      # Allows relations to access all other relations through registry
+      #
+      # For now this plugin is always enabled
+      #
+      # @api public
+      module RegistryReader
+        # @api private
+        def self.included(klass)
+          super
+          klass.option :__registry__, type: Hash, default: EMPTY_HASH, reader: true
+        end
+
+        # @api private
+        def respond_to_missing?(name, _include_private = false)
+          __registry__.key?(name) || super
+        end
+
+        private
+
+        # @api private
+        def method_missing(name, *)
+          __registry__.fetch(name) { super }
+        end
+      end
+    end
+  end
+end

data/lib/rom/processor/transproc.rb

@@ -37,6 +37,11 @@ module ROM
       # Default no-op row_proc
       EMPTY_FN = -> tuple { tuple }.freeze
 
+      # Filter out empty tuples from an array
+      FILTER_EMPTY = Transproc(
+        -> arr { arr.reject { |row| row.values.all?(&:nil?) } }
+      )
+
       # Build a transproc function from the header
       #
       # @param [ROM::Header] header
@@ -63,6 +68,8 @@ module ROM
       # @api private
       def to_transproc
         compose(EMPTY_FN) do |ops|
+          combined = header.combined
+          ops << t(:combine, combined.map(&method(:combined_args))) if combined.any?
           ops << header.groups.map { |attr| visit_group(attr, true) }
           ops << t(:map_array, row_proc) if row_proc
         end
@@ -106,6 +113,22 @@ module ROM
         end
       end
 
+      # Visit combined attribute
+      #
+      # @api private
+      def visit_combined(attribute)
+        with_row_proc(attribute) do |row_proc|
+          array_proc =
+            if attribute.type == :hash
+              t(:map_array, row_proc) >> -> arr { arr.first }
+            else
+              t(:map_array, row_proc)
+            end
+
+          t(:map_value, attribute.name, array_proc)
+        end
+      end
+
       # Visit array attribute
       #
       # @param [Header::Attribute::Array] attribute
@@ -134,6 +157,23 @@ module ROM
         end
       end
 
+      # Visit unwrap attribute
+      #
+      # :unwrap transformation is added to handle unwrapping
+      #
+      # @param [Header::Attributes::Unwrap]
+      #
+      # @api private
+      def visit_unwrap(attribute)
+        name = attribute.name
+        keys = attribute.header.map(&:name)
+
+        compose do |ops|
+          ops << visit_hash(attribute)
+          ops << t(:unwrap, name, keys)
+        end
+      end
+
       # Visit group hash attribute
       #
       # :group transformation is added to handle grouping during preprocessing.
@@ -154,6 +194,7 @@ module ROM
 
           compose do |ops|
             ops << t(:group, name, keys)
+            ops << t(:map_array, t(:map_value, name, FILTER_EMPTY))
 
             ops << other.map { |attr|
               t(:map_array, t(:map_value, name, visit_group(attr, true)))
@@ -164,17 +205,42 @@ module ROM
         end
       end
 
+      # @api private
+      def combined_args(attribute)
+        other = attribute.header.combined
+
+        if other.any?
+          children = other.map(&method(:combined_args))
+          [attribute.name, attribute.meta[:keys], children]
+        else
+          [attribute.name, attribute.meta[:keys]]
+        end
+      end
+
       # Build row_proc
       #
       # This transproc function is applied to each row in a dataset
       #
       # @api private
       def initialize_row_proc
-        @row_proc = compose do |ops|
+        @row_proc = compose { |ops|
+          process_header_keys(ops)
+
           ops << t(:rename_keys, mapping) if header.aliased?
           ops << header.map { |attr| visit(attr) }
-          ops << t(-> tuple { model.new(tuple) }) if model
+          ops << t(:constructor_inject, model) if model
+        }
+      end
+
+      # Process row_proc header keys
+      #
+      # @api private
+      def process_header_keys(ops)
+        if header.reject_keys
+          all_keys = header.tuple_keys + header.non_primitives.map(&:key)
+          ops << t(:accept_keys, all_keys)
         end
+        ops
       end
 
       # Yield row proc for a given attribute if any
@@ -183,10 +249,19 @@ module ROM
       #
       # @api private
       def with_row_proc(attribute)
-        row_proc = new(attribute.header).row_proc
+        row_proc = row_proc_from(attribute)
         yield(row_proc) if row_proc
       end
 
+      # Build a row_proc from a given attribute
+      #
+      # This is used by embedded attribute visitors
+      #
+      # @api private
+      def row_proc_from(attribute)
+        new(attribute.header).row_proc
+      end
+
       # Return a new instance of the processor
       #
       # @api private

data/lib/rom/relation/class_interface.rb

@@ -1,5 +1,4 @@
 require 'set'
-require 'rom/relation/registry_reader'
 
 module ROM
   class Relation
@@ -17,7 +16,8 @@ module ROM
 
         klass.class_eval do
           extend ClassMacros
-          include RegistryReader
+
+          use :registry_reader
 
           defines :repository, :dataset, :register_as, :exposed_relations
 
@@ -120,6 +120,18 @@ module ROM
         end
       end
 
+      # Include a registered plugin in this relation class
+      #
+      # @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.relations.fetch(plugin, adapter).apply_to(self)
+      end
+
       # Return default relation name used for `register_as` setting
       #
       # @return [Symbol]

data/lib/rom/relation/composite.rb

@@ -1,39 +1,14 @@
 require 'rom/relation/loaded'
+require 'rom/relation/materializable'
+require 'rom/pipeline'
 
 module ROM
   class Relation
     # Left-to-right relation composition used for data-pipelining
     #
     # @api public
-    class Composite
-      include Equalizer.new(:left, :right)
-
-      # @return [Lazy,Curried,Composite,#call]
-      #
-      # @api private
-      attr_reader :left
-
-      # @return [Lazy,Curried,Composite,#call]
-      #
-      # @api private
-      attr_reader :right
-
-      # @api private
-      def initialize(left, right)
-        @left = left
-        @right = right
-      end
-
-      # Compose with another callable object
-      #
-      # @param [#call]
-      #
-      # @return [Composite]
-      #
-      # @api public
-      def >>(other)
-        self.class.new(self, other)
-      end
+    class Composite < Pipeline::Composite
+      include Materializable
 
       # Call the pipeline by passing results from left to right
       #
@@ -54,78 +29,15 @@ module ROM
       end
       alias_method :[], :call
 
-      # Coerce composite relation to an array
-      #
-      # @return [Array]
-      #
-      # @api public
-      def to_a
-        call.to_a
-      end
-      alias_method :to_ary, :to_a
-
-      # Delegate to loaded relation and return one object
-      #
-      # @return [Object]
-      #
-      # @see Loaded#one
-      #
-      # @api public
-      def one
-        call.one
-      end
-
-      # Delegate to loaded relation and return one object
-      #
-      # @return [Object]
-      #
-      # @see Loaded#one
-      #
-      # @api public
-      def one!
-        call.one!
-      end
-
-      # Yield composite relation objects
-      #
-      # @yield [Object]
-      #
-      # @api public
-      def each(&block)
-        return to_enum unless block
-        call.each { |object| yield(object) }
-      end
-
-      # Return first object from the called relation
-      #
-      # @return [Object]
-      #
-      # @api public
-      def first
-        call.first
-      end
-
-      # @api private
-      def respond_to_missing?(name, include_private = false)
-        left.respond_to?(name) || super
-      end
-
       private
 
-      # Allow calling methods on the left side object
+      # @api private
+      #
+      # @see Pipeline::Proxy#decorate?
       #
       # @api private
-      def method_missing(name, *args, &block)
-        if left.respond_to?(name)
-          response = left.__send__(name, *args, &block)
-          if response.is_a?(left.class)
-            self.class.new(response, right)
-          else
-            response
-          end
-        else
-          super
-        end
+      def decorate?(response)
+        super || response.is_a?(Graph)
       end
     end
   end