rom-repository 0.3.1 → 1.0.0.beta1

data/lib/rom/repository/changeset/delete.rb

@@ -0,0 +1,15 @@
+module ROM
+  class Changeset
+    class Delete < Changeset
+      # @api private
+      def command
+        command_compiler.(command_type, relation, mapper: false)
+      end
+
+      # @api private
+      def default_command_type
+        :delete
+      end
+    end
+  end
+end

data/lib/rom/repository/changeset/pipe.rb

@@ -1,10 +1,13 @@
 require 'transproc/registry'
+require 'transproc/transformer'
 
 module ROM
   class Changeset
-    class Pipe
+    class Pipe < Transproc::Transformer
       extend Transproc::Registry
 
+      import Transproc::HashTransformations
+
       attr_reader :processor
 
       def self.add_timestamps(data)
@@ -16,15 +19,19 @@ module ROM
         data.merge(updated_at: Time.now)
       end
 
-      def initialize(processor = nil)
+      def initialize(processor = self.class.transproc)
         @processor = processor
       end
 
+      def [](name)
+        self.class[name]
+      end
+
       def >>(other)
         if processor
-          self.class.new(processor >> other)
+          Pipe.new(processor >> other)
         else
-          self.class.new(other)
+          Pipe.new(other)
         end
       end
 

data/lib/rom/repository/changeset/update.rb

@@ -71,12 +71,22 @@ module ROM
       def diff
         @diff ||=
           begin
-            new_tuple = data.to_a
+            new_tuple = __data__.to_a
             ori_tuple = original.to_a
 
             Hash[new_tuple - (new_tuple & ori_tuple)]
           end
       end
+
+      # @api private
+      def command
+        command_compiler.(command_type, relation, mapper: false).curry(to_h) if diff?
+      end
+
+      # @api private
+      def default_command_type
+        :update
+      end
     end
   end
 end

data/lib/rom/repository/command_compiler.rb

@@ -1,4 +1,5 @@
-require 'concurrent/map'
+require 'dry/core/inflector'
+require 'dry/core/cache'
 
 require 'rom/commands'
 require 'rom/repository/command_proxy'
@@ -13,7 +14,7 @@ module ROM
     #
     # @api private
     class CommandCompiler
-      SUPPORTED_TYPES = %i[create update delete].freeze
+      extend Dry::Core::Cache
 
       # Return a specific command type for a given adapter and relation AST
       #
@@ -35,38 +36,31 @@ module ROM
       #
       # @api private
       def self.[](*args)
-        cache.fetch_or_store(args.hash) do
-          container, type, adapter, ast, plugins = args
+        fetch_or_store(args.hash) do
+          container, type, adapter, ast, plugins, options = args
 
-          unless SUPPORTED_TYPES.include?(type)
-            raise ArgumentError, "#{type.inspect} is not a supported command type"
-          end
-
-          graph_opts = new(type, adapter, container, registry, plugins).visit(ast)
+          graph_opts = new(type, adapter, container, registry, plugins, options).visit(ast)
 
           command = ROM::Commands::Graph.build(registry, graph_opts)
 
           if command.graph?
             CommandProxy.new(command)
-          else
+          elsif command.lazy?
             command.unwrap
+          else
+            command
           end
         end
       end
 
-      # @api private
-      def self.cache
-        @__cache__ ||= Concurrent::Map.new
-      end
-
       # @api private
       def self.registry
         @__registry__ ||= Hash.new { |h, k| h[k] = {} }
       end
 
-      # @!attribute [r] type
-      #   @return [Symbol] The command type
-      attr_reader :type
+      # @!attribute [r] id
+      #   @return [Symbol] The command type registry identifier
+      attr_reader :id
 
       # @!attribute [r] adapter
       #   @return [Symbol] The adapter identifier ie :sql or :http
@@ -84,12 +78,25 @@ module ROM
       #   @return [Array<Symbol>] a list of optional plugins that will be enabled for commands
       attr_reader :plugins
 
+      # @!attribute [r] options
+      #   @return [Hash] Additional command options
+      attr_reader :options
+
       # @api private
-      def initialize(type, adapter, container, registry, plugins)
-        @type = Commands.const_get(Inflector.classify(type))[adapter]
+      def initialize(id, adapter, container, registry, plugins, options)
+        @id = id
+        @adapter = adapter
         @registry = registry
         @container = container
         @plugins = Array(plugins)
+        @options = options
+      end
+
+      # @api private
+      def type
+        @_type ||= Commands.const_get(Dry::Core::Inflector.classify(id))[adapter]
+      rescue NameError
+        nil
       end
 
       # @api private
@@ -109,15 +116,20 @@ module ROM
           if meta[:combine_type] == :many
             name
           else
-            { Inflector.singularize(name).to_sym => name }
+            { Dry::Core::Inflector.singularize(name).to_sym => name }
           end
 
-        register_command(name, type, meta, parent_relation)
+        if type
+          register_command(name, type, meta, parent_relation)
 
-        if other.size > 0
-          [mapping, [type, other]]
+          if other.size > 0
+            [mapping, [type, other]]
+          else
+            [mapping, type]
+          end
         else
-          [mapping, type]
+          registry[name][id] = container.commands[name][id].with(options)
+          [mapping, id]
         end
       end
 
@@ -149,7 +161,7 @@ module ROM
         relation = container.relations[rel_name]
 
         type.create_class(rel_name, type) do |klass|
-          klass.result(meta.fetch(:combine_type, :one))
+          klass.result(meta.fetch(:combine_type, result))
 
           if meta[:combine_type]
             setup_associates(klass, relation, meta, parent_relation)
@@ -161,6 +173,15 @@ module ROM
         end
       end
 
+      # Return default result type
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      def result
+        options.fetch(:result, :one)
+      end
+
       # Sets up `associates` plugin for a given command class and relation
       #
       # @param [Class] klass The command class
@@ -168,13 +189,11 @@ module ROM
       #
       # @api private
       def setup_associates(klass, relation, meta, parent_relation)
-        klass.use(:associates)
-
         assoc_name =
           if relation.associations.key?(parent_relation)
             parent_relation
           else
-            singular_name = Inflector.singularize(parent_relation).to_sym
+            singular_name = Dry::Core::Inflector.singularize(parent_relation).to_sym
             singular_name if relation.associations.key?(singular_name)
           end
 
@@ -207,7 +226,9 @@ module ROM
 
         klass.extend_for_relation(relation) if klass.restrictable
 
-        plugins.each { |plugin| klass.use(plugin) }
+        plugins.each do |plugin|
+          klass.use(plugin)
+        end
       end
     end
   end

data/lib/rom/repository/command_proxy.rb

@@ -1,3 +1,5 @@
+require 'dry/core/inflector'
+
 module ROM
   class Repository
     # TODO: look into making command graphs work without the root key in the input
@@ -7,7 +9,7 @@ module ROM
 
       def initialize(command)
         @command = command
-        @root = Inflector.singularize(command.name.relation).to_sym
+        @root = Dry::Core::Inflector.singularize(command.name.relation).to_sym
       end
 
       def call(input)

data/lib/rom/repository/header_builder.rb

@@ -49,11 +49,11 @@ module ROM
         node.map { |attribute| visit(attribute, meta) }
       end
 
-      def visit_attribute(name, meta = {})
+      def visit_attribute(attr, meta = {})
         if meta[:wrap]
-          [name, from: :"#{meta[:dataset]}_#{name}"]
+          [attr.name, from: attr.alias]
         else
-          [name]
+          [attr.name]
         end
       end
     end

data/lib/rom/repository/mapper_builder.rb

@@ -1,4 +1,4 @@
-require 'rom/support/cache'
+require 'dry/core/cache'
 require 'rom/mapper'
 require 'rom/repository/header_builder'
 
@@ -6,7 +6,7 @@ module ROM
   class Repository
     # @api private
     class MapperBuilder
-      extend Cache
+      extend Dry::Core::Cache
 
       attr_reader :header_builder
 

data/lib/rom/repository/relation_proxy.rb

@@ -1,4 +1,4 @@
-require 'rom/support/options'
+require 'rom/initializer'
 require 'rom/relation/materializable'
 
 require 'rom/repository/relation_proxy/combine'
@@ -14,30 +14,30 @@ module ROM
     #
     # @api public
     class RelationProxy
-      include Options
+      extend Initializer
       include Relation::Materializable
 
       include RelationProxy::Combine
       include RelationProxy::Wrap
 
-      option :name, type: Symbol
-      option :mappers, reader: true, default: proc { MapperBuilder.new }
-      option :meta, reader: true, type: Hash, default: EMPTY_HASH
-      option :registry, type: RelationRegistry, default: proc { RelationRegistry.new }, reader: true
+      RelationRegistryType = Types.Definition(RelationRegistry).constrained(type: RelationRegistry)
 
       # @!attribute [r] relation
       #   @return [Relation, Relation::Composite, Relation::Graph, Relation::Curried] The decorated relation object
-      attr_reader :relation
+      param :relation
 
-      # @!attribute [r] name
-      #   @return [ROM::Relation::Name] The relation name object
-      attr_reader :name
+      option :name, type:  Types::Strict::Symbol
+      option :mappers, reader: true, default: proc { MapperBuilder.new }
+      option :meta, reader: true, default: proc { EMPTY_HASH }
+      option :registry, type: RelationRegistryType, default: proc { RelationRegistry.new }, reader: true
 
-      # @api private
-      def initialize(relation, options = {})
-        super
-        @relation = relation
-        @name = relation.name.with(options[:name])
+      # Relation name
+      #
+      # @return [ROM::Relation::Name]
+      #
+      # @api public
+      def name
+        @name == Dry::Initializer::UNDEFINED ? relation.name : relation.name.with(@name)
       end
 
       # Materializes wrapped relation and sends it through a mapper
@@ -105,15 +105,6 @@ module ROM
         relation.is_a?(Relation::Composite)
       end
 
-      # Returns meta info for the wrapped relation
-      #
-      # @return [Hash]
-      #
-      # @api private
-      def meta
-        options[:meta]
-      end
-
       # @return [Symbol] The wrapped relation's adapter identifier ie :sql or :http
       #
       # @api private
@@ -129,11 +120,9 @@ module ROM
       def to_ast
         @to_ast ||=
           begin
-            attr_ast = (attributes - wraps_attributes).map { |name|
-              [:attribute, name]
-            }
+            attr_ast = schema.map { |attr| [:attribute, attr] }
 
-            meta = options[:meta].merge(dataset: base_name.dataset)
+            meta = self.meta.merge(dataset: base_name.dataset)
             meta.delete(:wraps)
 
             header = attr_ast + nodes_ast + wraps_ast
@@ -147,19 +136,21 @@ module ROM
         relation.respond_to?(meth) || super
       end
 
+      # @api public
+      def inspect
+        %(#<#{relation.class} name=#{name} dataset=#{dataset.inspect}>)
+      end
+
       private
 
       # @api private
-      def base_name
-        relation.base_name
+      def schema
+        meta[:wrap] ? relation.schema.wrap.qualified : relation.schema.reject(&:wrapped?)
       end
 
       # @api private
-      def wraps_attributes
-        @wrap_attributes ||= wraps.flat_map { |wrap|
-          prefix = wrap.base_name.dataset
-          wrap.attributes.map { |name| :"#{prefix}_#{name}" }
-        }
+      def base_name
+        relation.base_name
       end
 
       # @api private

data/lib/rom/repository/relation_proxy/combine.rb

@@ -1,3 +1,5 @@
+require 'dry/core/inflector'
+
 module ROM
   class Repository
     class RelationProxy
@@ -56,12 +58,30 @@ module ROM
 
           combine_opts = Hash.new { |h, k| h[k] = {} }
 
-          options.each do |(type, relations)|
-            if relations
-              combine_opts[type] = combine_opts_from_relations(relations)
+          options.each do |key, value|
+            if key == :one || key == :many
+              if value.is_a?(Hash)
+                value.each do |name, spec|
+                  if spec.is_a?(Array)
+                    combine_opts[key][name] = spec
+                  else
+                    _, (curried, keys) = combine_opts_from_relations(spec).to_a[0]
+                    combine_opts[key][name] = [curried, keys]
+                  end
+                end
+              else
+                _, (curried, keys) = combine_opts_from_relations(value).to_a[0]
+                combine_opts[key][curried.combine_tuple_key(key)] = [curried, keys]
+              end
             else
-              result, curried, keys = combine_opts_for_assoc(type)
-              combine_opts[result][type] = [curried, keys]
+              if value.is_a?(Array)
+                curried = combine_from_assoc(key, registry[key]).combine(*value)
+                result, _, keys = combine_opts_for_assoc(key)
+                combine_opts[result][key] = [curried, keys]
+              else
+                result, curried, keys = combine_opts_for_assoc(key, value)
+                combine_opts[result][key] = [curried, keys]
+              end
             end
           end
 
@@ -97,18 +117,21 @@ module ROM
               when Hash
                 parents.each_with_object({}) { |(name, parent), r|
                   keys = combine_keys(parent, relation, :parent)
-                  r[name] = [parent, keys]
+                  curried = combine_from_assoc_with_fallback(name, parent, keys)
+                  r[name] = [curried, keys]
                 }
               when Array
                 parents.each_with_object({}) { |parent, r|
-                  tuple_key = parent.combine_tuple_key(type)
                   keys = combine_keys(parent, relation, :parent)
-                  r[tuple_key] = [parent, keys]
+                  tuple_key = parent.combine_tuple_key(type)
+                  curried = combine_from_assoc_with_fallback(parent.name, parent, keys)
+                  r[tuple_key] = [curried, keys]
                 }
               else
-                tuple_key = parents.combine_tuple_key(type)
                 keys = combine_keys(parents, relation, :parent)
-                { tuple_key => [parents, keys] }
+                tuple_key = parents.combine_tuple_key(type)
+                curried = combine_from_assoc_with_fallback(parents.name, parents, keys)
+                { tuple_key => [curried, keys] }
               end
           end
 
@@ -138,18 +161,21 @@ module ROM
               when Hash
                 children.each_with_object({}) { |(name, child), r|
                   keys = combine_keys(relation, child, :children)
-                  r[name] = [child, keys]
+                  curried = combine_from_assoc_with_fallback(name, child, keys)
+                  r[name] = [curried, keys]
                 }
               when Array
-                parents.each_with_object({}) { |child, r|
-                  tuple_key = parent.combine_tuple_key(type)
+                children.each_with_object({}) { |child, r|
                   keys = combine_keys(relation, child, :children)
-                  r[tuple_key] = [parent, keys]
+                  tuple_key = child.combine_tuple_key(type)
+                  curried = combine_from_assoc_with_fallback(child.name, child, keys)
+                  r[tuple_key] = [curried, keys]
                 }
               else
-                tuple_key = children.combine_tuple_key(type)
                 keys = combine_keys(relation, children, :children)
-                { tuple_key => [children, keys] }
+                curried = combine_from_assoc_with_fallback(children.name, children, keys)
+                tuple_key = children.combine_tuple_key(type)
+                { tuple_key => [curried, keys] }
               end
           end
 
@@ -185,15 +211,19 @@ module ROM
         # and this mapping is used by `combine` to build a full relation graph
         #
         # @api private
-        def combine_opts_from_relations(relations)
-          relations.each_with_object({}) do |(name, (other, keys)), h|
-            h[name] =
-              if other.curried?
-                [other, keys]
-              else
-                rel = combine_from_assoc(name, other) { other.combine_method(relation, keys) }
-                [rel, keys]
-              end
+        def combine_opts_from_relations(*relations)
+          relations.each_with_object({}) do |spec, h|
+            # We assume it's a child relation
+            keys = combine_keys(relation, spec, :children)
+            rel = combine_from_assoc_with_fallback(spec.name, spec, keys)
+            h[spec.name.relation] = [rel, keys]
+          end
+        end
+
+        # @api private
+        def combine_from_assoc_with_fallback(name, other, keys)
+          combine_from_assoc(name, other) do
+            other.combine_method(relation, keys)
           end
         end
 
@@ -205,6 +235,7 @@ module ROM
         #
         # @api private
         def combine_from_assoc(name, other, &fallback)
+          return other if other.curried?
           associations.try(name) { |assoc| other.for_combine(assoc) } or fallback.call
         end
 
@@ -214,9 +245,10 @@ module ROM
         # This is used when a flat list of association names was passed to `combine`
         #
         # @api private
-        def combine_opts_for_assoc(name)
+        def combine_opts_for_assoc(name, opts = nil)
           assoc = relation.associations[name]
           curried = registry[assoc.target.relation].for_combine(assoc)
+          curried = curried.combine(opts) unless opts.nil?
           keys = assoc.combine_keys(__registry__)
           [assoc.result, curried, keys]
         end
@@ -258,7 +290,7 @@ module ROM
         # @api private
         def combine_tuple_key(result)
           if result == :one
-            Inflector.singularize(base_name.relation).to_sym
+            Dry::Core::Inflector.singularize(base_name.relation).to_sym
           else
             base_name.relation
           end