rom 0.7.1 → 0.8.0

data/lib/rom/pipeline.rb

@@ -77,7 +77,8 @@ module ROM
 
       # @api private
       def initialize(left, right)
-        @left, @right = left, right
+        @left = left
+        @right = right
       end
 
       # Compose this composite with another object

data/lib/rom/processor/transproc.rb

@@ -70,8 +70,9 @@ module ROM
         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 << header.preprocessed.map { |attr| visit(attr, true) }
           ops << t(:map_array, row_proc) if row_proc
+          ops << header.postprocessed.map { |attr| visit(attr, true) }
         end
       end
 
@@ -82,11 +83,12 @@ module ROM
       # This forwards to a specialized visitor based on the attribute type
       #
       # @param [Header::Attribute] attribute
+      # @param [Array] args Allows to send `preprocess: true`
       #
       # @api private
-      def visit(attribute)
+      def visit(attribute, *args)
         type = attribute.class.name.split('::').last.downcase
-        send("visit_#{type}", attribute)
+        send("visit_#{type}", attribute, *args)
       end
 
       # Visit plain attribute
@@ -122,7 +124,7 @@ module ROM
       #
       # @api private
       def visit_combined(attribute)
-        with_row_proc(attribute) do |row_proc|
+        op = with_row_proc(attribute) do |row_proc|
           array_proc =
             if attribute.type == :hash
               t(:map_array, row_proc) >> -> arr { arr.first }
@@ -132,6 +134,12 @@ module ROM
 
           t(:map_value, attribute.name, array_proc)
         end
+
+        if op
+          op
+        elsif attribute.type == :hash
+          t(:map_value, attribute.name, -> arr { arr.first })
+        end
       end
 
       # Visit array attribute
@@ -171,7 +179,7 @@ module ROM
       # @api private
       def visit_unwrap(attribute)
         name = attribute.name
-        keys = attribute.header.map(&:name)
+        keys = attribute.pop_keys
 
         compose do |ops|
           ops << visit_hash(attribute)
@@ -194,27 +202,110 @@ module ROM
           name = attribute.name
           header = attribute.header
           keys = attribute.tuple_keys
-          fold = attribute.meta[:fold]
 
-          other = header.groups
+          others = header.preprocessed
 
           compose do |ops|
             ops << t(:group, name, keys)
             ops << t(:map_array, t(:map_value, name, FILTER_EMPTY))
+            ops << others.map { |attr|
+              t(:map_array, t(:map_value, name, visit(attr, true)))
+            }
+          end
+        else
+          visit_array(attribute)
+        end
+      end
 
-            if fold
-              ops << t(:map_array, t(:fold, name, keys.first))
-            else
-              ops << other.map { |attr|
-                t(:map_array, t(:map_value, name, visit_group(attr, true)))
-              }
-            end
+      # Visit ungroup attribute
+      #
+      # :ungroup transforation is added to handle ungrouping during preprocessing.
+      # Otherwise we simply use array visitor for the attribute.
+      #
+      # @param [Header::Attribute::Ungroup] attribute
+      # @param [Boolean] preprocess true if we are building a relation preprocessing
+      #                             function that is applied to the whole relation
+      #
+      # @api private
+      def visit_ungroup(attribute, preprocess = false)
+        if preprocess
+          name = attribute.name
+          header = attribute.header
+          keys = attribute.pop_keys
+
+          others = header.postprocessed
+
+          compose do |ops|
+            ops << others.map { |attr|
+              t(:map_array, t(:map_value, name, visit(attr, true)))
+            }
+            ops << t(:ungroup, name, keys)
           end
         else
           visit_array(attribute)
         end
       end
 
+      # Visit fold hash attribute
+      #
+      # :fold transformation is added to handle folding during preprocessing.
+      #
+      # @param [Header::Attribute::Fold] attribute
+      # @param [Boolean] preprocess true if we are building a relation preprocessing
+      #                             function that is applied to the whole relation
+      #
+      # @api private
+      def visit_fold(attribute, preprocess = false)
+        if preprocess
+          name = attribute.name
+          keys = attribute.tuple_keys
+
+          compose do |ops|
+            ops << t(:group, name, keys)
+            ops << t(:map_array, t(:map_value, name, FILTER_EMPTY))
+            ops << t(:map_array, t(:fold, name, keys.first))
+          end
+        end
+      end
+
+      # Visit unfold hash attribute
+      #
+      # :unfold transformation is added to handle unfolding during preprocessing.
+      #
+      # @param [Header::Attribute::Unfold] attribute
+      # @param [Boolean] preprocess true if we are building a relation preprocessing
+      #                             function that is applied to the whole relation
+      #
+      # @api private
+      def visit_unfold(attribute, preprocess = false)
+        if preprocess
+          name = attribute.name
+          header = attribute.header
+          keys = attribute.pop_keys
+          key = keys.first
+
+          others = header.postprocessed
+
+          compose do |ops|
+            ops << others.map { |attr|
+              t(:map_array, t(:map_value, name, visit(attr, true)))
+            }
+            ops << t(:map_array, t(:map_value, name, t(:insert_key, key)))
+            ops << t(:map_array, t(:reject_keys, [key] - [name]))
+            ops << t(:ungroup, name, [key])
+          end
+        end
+      end
+
+      # Visit excluded attribute
+      #
+      # @param [Header::Attribute::Exclude] attribute
+      #
+      # @api private
+      def visit_exclude(attribute)
+        t(:reject_keys, [attribute.name])
+      end
+
       # @api private
       def combined_args(attribute)
         other = attribute.header.combined

data/lib/rom/relation.rb

@@ -6,14 +6,14 @@ require 'rom/relation/curried'
 module ROM
   # Base relation class
   #
-  # Relation is a proxy for the dataset object provided by the repository. It
+  # Relation is a proxy for the dataset object provided by the gateway. It
   # forwards every method to the dataset, which is why the "native" interface of
-  # the underlying repository is available in the relation. This interface,
+  # the underlying gateway is available in the relation. This interface,
   # however, is considered private and should not be used outside of the
   # relation instance.
   #
   # ROM builds sub-classes of this class for every relation defined in the env
-  # for easy inspection and extensibility - every repository can provide extensions
+  # for easy inspection and extensibility - every gateway can provide extensions
   # for those sub-classes but there is always a vanilla relation instance stored
   # in the schema registry.
   #
@@ -26,7 +26,7 @@ module ROM
 
     # Dataset used by the relation
     #
-    # This object is provided by the repository during the setup
+    # This object is provided by the gateway during the setup
     #
     # @return [Object]
     #

data/lib/rom/relation/class_interface.rb

@@ -13,6 +13,7 @@ module ROM
         super
 
         klass.extend ClassMacros
+        klass.extend Deprecations
         klass.defines :adapter
 
         return if klass.superclass == ROM::Relation
@@ -20,9 +21,12 @@ module ROM
         klass.class_eval do
           use :registry_reader
 
-          defines :repository, :dataset, :register_as, :exposed_relations
+          defines :gateway, :dataset, :register_as, :exposed_relations
 
-          repository :default
+          deprecate_class_method :repository, :gateway
+          deprecate :repository, :gateway
+
+          gateway :default
 
           dataset(default_name)
           exposed_relations Set.new
@@ -76,13 +80,13 @@ module ROM
             super
           end
 
-          # Return name of the source repository of this relation
+          # Return name of the source gateway of this relation
           #
           # @return [Symbol]
           #
           # @api private
-          def repository
-            self.class.repository
+          def gateway
+            self.class.gateway
           end
         end
 
@@ -98,8 +102,10 @@ module ROM
       # @return [Class]
       #
       # @api public
-      def [](type)
-        ROM.adapters.fetch(type).const_get(:Relation)
+      def [](adapter)
+        ROM.adapters.fetch(adapter).const_get(:Relation)
+      rescue KeyError
+        raise AdapterNotPresentError.new(adapter, :relation)
       end
 
       # Dynamically define a method that will forward to the dataset and wrap
@@ -128,7 +134,7 @@ module ROM
       # @option options [Symbol] :adapter (:default) first adapter to check for plugin
       #
       # @api public
-      def use(plugin, options = {})
+      def use(plugin, _options = {})
         ROM.plugin_registry.relations.fetch(plugin, adapter).apply_to(self)
       end
 
@@ -146,20 +152,20 @@ module ROM
       #
       # This is used by the setup
       #
-      # @param [Hash] repositories
+      # @param [Hash] gateways
       # @param [Array] descendants a list of relation descendants
       #
       # @return [Hash]
       #
       # @api private
-      def registry(repositories, descendants)
+      def registry(gateways, descendants)
         registry = {}
 
         descendants.each do |klass|
           # TODO: raise a meaningful error here and add spec covering the case
-          #       where klass' repository points to non-existant repo
-          repository = repositories.fetch(klass.repository)
-          dataset = repository.dataset(klass.dataset)
+          #       where klass' gateway points to non-existant repo
+          gateway = gateways.fetch(klass.gateway)
+          dataset = gateway.dataset(klass.dataset)
 
           relation = klass.new(dataset, __registry__: registry)
 

data/lib/rom/relation/graph.rb

@@ -1,4 +1,5 @@
 require 'rom/relation/loaded'
+require 'rom/relation/composite'
 require 'rom/relation/materializable'
 require 'rom/pipeline'
 
@@ -48,12 +49,33 @@ module ROM
       alias_method :left, :root
       alias_method :right, :nodes
 
+      # @api private
+      def self.build(root, nodes)
+        if nodes.any? { |node| node.instance_of?(Composite) }
+          raise UnsupportedRelationError,
+            "Combining with composite relations is not supported"
+        else
+          new(root, nodes)
+        end
+      end
+
       # @api private
       def initialize(root, nodes)
         @root = root
         @nodes = nodes
       end
 
+      # Combine this graph with more nodes
+      #
+      # @param [Array<Relation::Lazy>]
+      #
+      # @return [Graph]
+      #
+      # @api public
+      def combine(*others)
+        self.class.new(root, nodes + others)
+      end
+
       # Materialize this relation graph
       #
       # @return [Loaded]

data/lib/rom/relation/lazy.rb

@@ -1,8 +1,10 @@
+require 'rom/pipeline'
+require 'rom/mapper_registry'
+
 require 'rom/relation/loaded'
 require 'rom/relation/composite'
 require 'rom/relation/graph'
 require 'rom/relation/materializable'
-require 'rom/pipeline'
 
 module ROM
   class Relation
@@ -34,7 +36,7 @@ module ROM
       include Materializable
       include Pipeline
 
-      option :mappers, reader: true, default: EMPTY_HASH
+      option :mappers, reader: true, default: proc { MapperRegistry.new }
 
       # @return [Relation]
       #
@@ -63,7 +65,7 @@ module ROM
       #
       # @api public
       def combine(*others)
-        Graph.new(self, others)
+        Graph.build(self, others)
       end
 
       # Build a relation pipeline using registered mappers

data/lib/rom/repository.rb

@@ -1,125 +1,16 @@
+require 'rom/gateway'
+
 module ROM
   # Abstract repository class
   #
+  # This is a transitional placeholder, deprecating the Repository class.
+  #
   # @api public
-  class Repository
-    # Return connection object
-    #
-    # @return [Object] type varies depending on the repository
-    #
-    # @api public
-    attr_reader :connection
-
-    # Setup a repository
-    #
-    # @overload setup(type, *args)
-    #   Sets up a single-repository given a repository type.
-    #   For custom repositories, create an instance and pass it directly.
-    #
-    #   @param [Symbol] type
-    #   @param [Array] *args
-    #
-    # @overload setup(repository)
-    #   @param [Repository] repository
-    #
-    # @return [Repository] a specific repository subclass
-    #
-    # @example
-    #   module SuperDB
-    #     class Repository < ROM::Repository
-    #       def initialize(options)
-    #       end
-    #     end
-    #   end
-    #
-    #   ROM.register_adapter(:super_db, SuperDB)
-    #
-    #   Repository.setup(:super_db, some: 'options')
-    #   # SuperDB::Repository.new(some: 'options') is called
-    #
-    #   # or alternatively
-    #   super_db = Repository.setup(SuperDB::Repository.new(some: 'options'))
-    #   Repository.setup(super_db)
-    #
-    # @api public
-    def self.setup(repository_or_scheme, *args)
-      case repository_or_scheme
-      when String
-        raise ArgumentError, <<-STRING.gsub(/^ {10}/, '')
-          URIs without an explicit scheme are not supported anymore.
-          See https://github.com/rom-rb/rom/blob/master/CHANGELOG.md
-        STRING
-      when Symbol
-        class_from_symbol(repository_or_scheme).new(*args)
-      else
-        if args.empty?
-          repository_or_scheme
-        else
-          raise ArgumentError, "Can't accept arguments when passing an instance"
-        end
-      end
-    end
-
-    # Get repository subclass for a specific adapter
-    #
-    # @param [Symbol] type adapter identifier
-    #
-    # @return [Class]
-    #
-    # @api private
-    def self.class_from_symbol(type)
-      begin
-        require "rom/#{type}"
-      rescue LoadError
-        raise AdapterLoadError, "Failed to load adapter rom/#{type}"
-      end
-
-      adapter = ROM.adapters.fetch(type)
-      adapter.const_get(:Repository)
-    end
-
-    # A generic interface for setting up a logger
-    #
-    # @api public
-    def use_logger(*)
-      # noop
-    end
-
-    # A generic interface for returning default logger
-    #
-    # @api public
-    def logger
-      # noop
-    end
-
-    # Extension hook for adding repository-specific behavior to a command class
-    #
-    # @param [Class] klass command class
-    # @param [Object] _dataset dataset that will be used with this command class
-    #
-    # @return [Class]
-    #
-    # @api public
-    def extend_command_class(klass, _dataset)
-      klass
-    end
-
-    # Schema inference hook
-    #
-    # Every repository that supports schema inference should implement this method
-    #
-    # @return [Array] array with datasets and their names
-    #
-    # @api private
-    def schema
-      []
-    end
-
-    # Disconnect is optional and it's a no-op by default
-    #
-    # @api public
-    def disconnect
-      # noop
+  class Repository < Gateway
+    def self.inherited(_klass)
+      ROM::Deprecations.announce "Inheriting from ROM::Repository is", <<-MSG
+        Please inherit from ROM::Gateway instead.
+      MSG
     end
   end
 end