rom-repository 0.2.0 → 0.3.0

data/lib/rom/repository/command_compiler.rb

@@ -0,0 +1,214 @@
+require 'concurrent/map'
+
+require 'rom/commands'
+require 'rom/repository/command_proxy'
+
+module ROM
+  class Repository
+    # Builds commands for relations.
+    #
+    # This class is used by repositories to automatically create commands for
+    # their relations. This is used both by `Repository#command` method and
+    # `commands` repository class macros.
+    #
+    # @api private
+    class CommandCompiler
+      SUPPORTED_TYPES = %i[create update delete].freeze
+
+      # Return a specific command type for a given adapter and relation AST
+      #
+      # This class holds its own registry where all generated commands are being
+      # stored
+      #
+      # CommandProxy is returned for complex command graphs as they expect root
+      # relation name to be present in the input, which we don't want to have
+      # in repositories. It might be worth looking into removing this requirement
+      # from rom core Command::Graph API.
+      #
+      # @param container [ROM::Container] container where relations are stored
+      # @param type [Symbol] The type of command
+      # @param adapter [Symbol] The adapter identifier
+      # @param ast [Array] The AST representation of a relation
+      # @param plugins [Array<Symbol>] A list of optional command plugins that should be used
+      #
+      # @return [Command, CommandProxy]
+      #
+      # @api private
+      def self.[](*args)
+        cache.fetch_or_store(args.hash) do
+          container, type, adapter, ast, plugins = 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)
+
+          command = ROM::Commands::Graph.build(registry, graph_opts)
+
+          if command.graph?
+            CommandProxy.new(command)
+          else
+            command.unwrap
+          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] adapter
+      #   @return [Symbol] The adapter identifier ie :sql or :http
+      attr_reader :adapter
+
+      # @!attribute [r] container
+      #   @return [ROM::Container] rom container with relations and gateways
+      attr_reader :container
+
+      # @!attribute [r] registry
+      #   @return [Hash] local registry where commands will be stored during compilation
+      attr_reader :registry
+
+      # @!attribute [r] plugins
+      #   @return [Array<Symbol>] a list of optional plugins that will be enabled for commands
+      attr_reader :plugins
+
+      # @api private
+      def initialize(type, adapter, container, registry, plugins)
+        @type = Commands.const_get(Inflector.classify(type))[adapter]
+        @registry = registry
+        @container = container
+        @plugins = Array(plugins)
+      end
+
+      # @api private
+      def visit(ast, *args)
+        name, node = ast
+        __send__(:"visit_#{name}", node, *args)
+      end
+
+      private
+
+      # @api private
+      def visit_relation(node, parent_relation = nil)
+        name, meta, header = node
+        other = visit(header, name)
+
+        mapping =
+          if meta[:combine_type] == :many
+            name
+          else
+            { Inflector.singularize(name).to_sym => name }
+          end
+
+        register_command(name, type, meta, parent_relation)
+
+        if other.size > 0
+          [mapping, [type, other]]
+        else
+          [mapping, type]
+        end
+      end
+
+      # @api private
+      def visit_header(node, *args)
+        node.map { |n| visit(n, *args) }.compact
+      end
+
+      # @api private
+      def visit_attribute(*args)
+        nil
+      end
+
+      # Build a command object for a specific relation
+      #
+      # The command will be prepared for handling associations if it's a combined
+      # relation. Additional plugins will be enabled if they are configured for
+      # this compiler.
+      #
+      # @param [Symbol] rel_name A relation identifier from the container registry
+      # @param [Symbol] type The command type
+      # @param [Hash] meta Meta information from relation AST
+      # @param [Symbol] parent_relation Optional parent relation identifier
+      #
+      # @return [ROM::Command]
+      #
+      # @api private
+      def register_command(rel_name, type, meta, parent_relation = nil)
+        relation = container.relations[rel_name]
+
+        type.create_class(rel_name, type) do |klass|
+          klass.result(meta.fetch(:combine_type, :one))
+
+          if meta[:combine_type]
+            setup_associates(klass, relation, meta, parent_relation)
+          end
+
+          finalize_command_class(klass, relation)
+
+          registry[rel_name][type] = klass.build(relation, input: relation.schema_hash)
+        end
+      end
+
+      # Sets up `associates` plugin for a given command class and relation
+      #
+      # @param [Class] klass The command class
+      # @param [Relation] relation The relation for the command
+      #
+      # @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 if relation.associations.key?(singular_name)
+          end
+
+        if assoc_name
+          klass.associates(assoc_name)
+        else
+          keys = meta[:keys].invert.to_a.flatten
+          klass.associates(parent_relation, key: keys)
+        end
+      end
+
+      # Setup a command class for a specific relation
+      #
+      # Every gateway may provide custom command extensions via
+      # `Gateway#extend_command_class`. Furthermore, restrictible commands like
+      # `Update` or `Delete` will be extended with relation view methods, so things
+      # like `delete_user.by_id(1).call` becomes available.
+      #
+      # @param [Class] klass The command class
+      # @param [Relation] relation The command relation
+      #
+      # @return [Class]
+      #
+      # @api private
+      def finalize_command_class(klass, relation)
+        # TODO: this is a copy-paste from rom's FinalizeCommands, we are missing
+        #       an interface!
+        gateway = container.gateways[relation.class.gateway]
+        gateway.extend_command_class(klass, relation.dataset)
+
+        klass.extend_for_relation(relation) if klass.restrictable
+
+        plugins.each { |plugin| klass.use(plugin) }
+      end
+    end
+  end
+end

data/lib/rom/repository/command_proxy.rb

@@ -0,0 +1,22 @@
+module ROM
+  class Repository
+    # TODO: look into making command graphs work without the root key in the input
+    #       so that we can get rid of this wrapper
+    class CommandProxy
+      attr_reader :command, :root
+
+      def initialize(command)
+        @command = command
+        @root = Inflector.singularize(command.name.relation).to_sym
+      end
+
+      def call(input)
+        command.call(root => input)
+      end
+
+      def >>(other)
+        self.class.new(command >> other)
+      end
+    end
+  end
+end

data/lib/rom/repository/header_builder.rb

@@ -1,5 +1,4 @@
 require 'rom/header'
-
 require 'rom/repository/struct_builder'
 
 module ROM
@@ -8,12 +7,8 @@ module ROM
     class HeaderBuilder
       attr_reader :struct_builder
 
-      def self.new(struct_builder = StructBuilder.new)
-        super
-      end
-
-      def initialize(struct_builder)
-        @struct_builder = struct_builder
+      def initialize
+        @struct_builder = StructBuilder.new
       end
 
       def call(ast)
@@ -23,18 +18,20 @@ module ROM
 
       private
 
-      def visit(ast, *args)
-        __send__("visit_#{ast.first}", *(ast[1..ast.size-1] + args))
+      def visit(node, *args)
+        name, node = node
+        __send__("visit_#{name}", node, *args)
       end
 
-      def visit_relation(*args)
-        name, header, meta = args
+      def visit_relation(node, meta = {})
+        relation_name, meta, header = node
+        name = meta[:combine_name] || relation_name
 
         model = meta.fetch(:model) do
-          struct_builder[meta.fetch(:base_name), header[1].map { |a| a[1] }]
+          struct_builder[meta.fetch(:dataset), header]
         end
 
-        options = [visit_header(header[1], meta), model: model]
+        options = [visit(header, meta), model: model]
 
         if meta[:combine_type]
           type = meta[:combine_type] == :many ? :array : :hash
@@ -48,13 +45,13 @@ module ROM
         end
       end
 
-      def visit_header(header, meta = {})
-        header.map { |attribute| visit(attribute, meta) }
+      def visit_header(node, meta = {})
+        node.map { |attribute| visit(attribute, meta) }
       end
 
       def visit_attribute(name, meta = {})
         if meta[:wrap]
-          [name, from: :"#{meta[:base_name]}_#{name}"]
+          [name, from: :"#{meta[:dataset]}_#{name}"]
         else
           [name]
         end

data/lib/rom/repository/mapper_builder.rb

@@ -1,28 +1,21 @@
+require 'rom/support/cache'
+require 'rom/mapper'
 require 'rom/repository/header_builder'
 
 module ROM
   class Repository
     # @api private
     class MapperBuilder
-      attr_reader :header_builder
-
-      attr_reader :registry
-
-      def self.registry
-        @__registry__ ||= {}
-      end
+      extend Cache
 
-      def self.new(header_builder = HeaderBuilder.new)
-        super
-      end
+      attr_reader :header_builder
 
-      def initialize(header_builder)
-        @header_builder = header_builder
-        @registry = self.class.registry
+      def initialize
+        @header_builder = HeaderBuilder.new
       end
 
       def call(ast)
-        registry[ast.hash] ||= Mapper.build(header_builder[ast])
+        fetch_or_store(ast) { Mapper.build(header_builder[ast]) }
       end
       alias_method :[], :call
     end

data/lib/rom/repository/{loading_proxy → relation_proxy}/wrap.rb

@@ -1,6 +1,6 @@
 module ROM
   class Repository
-    class LoadingProxy
+    class RelationProxy
       # Provides convenient methods for producing wrapped relations
       #
       # @api public
@@ -12,7 +12,7 @@ module ROM
         #
         # @param [Hash] options
         #
-        # @return [LoadingProxy]
+        # @return [RelationProxy]
         #
         # @api public
         def wrap(options)
@@ -21,7 +21,7 @@ module ROM
           }
 
           relation = wraps.reduce(self) { |a, e|
-            a.relation.for_wrap(e.meta.fetch(:keys), e.base_name)
+            a.relation.for_wrap(e.meta.fetch(:keys), e.base_name.relation)
           }
 
           __new__(relation, meta: { wraps: wraps })
@@ -32,13 +32,13 @@ module ROM
         # @example
         #   tasks.wrap_parent(owner: users)
         #
-        # @return [LoadingProxy]
+        # @return [RelationProxy]
         #
         # @api public
         def wrap_parent(options)
           wrap(
             options.each_with_object({}) { |(name, parent), h|
-              h[name] = [parent, combine_keys(parent, :children)]
+              h[name] = [parent, combine_keys(parent, relation, :children)]
             }
           )
         end
@@ -48,11 +48,11 @@ module ROM
         # This will carry meta info used to produce a correct AST from a relation
         # so that correct mapper can be generated
         #
-        # @return [LoadingProxy]
+        # @return [RelationProxy]
         #
         # @api private
         def wrapped(name, keys)
-          with(name: name, meta: { keys: keys, wrap: true })
+          with(name: name, meta: { keys: keys, wrap: true, combine_name: name })
         end
       end
     end

data/lib/rom/repository/relation_proxy.rb

@@ -0,0 +1,225 @@
+require 'rom/support/options'
+require 'rom/relation/materializable'
+
+require 'rom/repository/relation_proxy/combine'
+require 'rom/repository/relation_proxy/wrap'
+
+module ROM
+  class Repository
+    # RelationProxy decorates a relation and automatically generates mappers that
+    # will map raw tuples into rom structs
+    #
+    # Relation proxies are being registered within repositories so typically there's
+    # no need to instantiate them manually.
+    #
+    # @api public
+    class RelationProxy
+      include Options
+      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
+
+      # @!attribute [r] relation
+      #   @return [Relation, Relation::Composite, Relation::Graph, Relation::Curried] The decorated relation object
+      attr_reader :relation
+
+      # @!attribute [r] name
+      #   @return [ROM::Relation::Name] The relation name object
+      attr_reader :name
+
+      # @api private
+      def initialize(relation, options = {})
+        super
+        @relation = relation
+        @name = relation.name.with(options[:name])
+      end
+
+      # Materializes wrapped relation and sends it through a mapper
+      #
+      # For performance reasons a combined relation will skip mapping since
+      # we only care about extracting key values for combining
+      #
+      # @api public
+      def call(*args)
+        ((combine? || composite?) ? relation : (relation >> mapper)).call(*args)
+      end
+
+      # Maps the wrapped relation with other mappers available in the registry
+      #
+      # @param *names [Array<Symbol, Class>] Either a list of mapper identifiers
+      #                                      or a custom model class
+      #
+      # @return [RelationProxy] A new relation proxy with pipelined relation
+      #
+      # @api public
+      def map_with(*names)
+        if names.size == 1 && names[0].is_a?(Class)
+          with(meta: meta.merge(model: names[0]))
+        else
+          names.reduce(self) { |a, e| a >> relation.mappers[e] }
+        end
+      end
+      alias_method :as, :map_with
+
+      # Infers a mapper for the wrapped relation
+      #
+      # @return [ROM::Mapper]
+      #
+      # @api private
+      def mapper
+        mappers[to_ast]
+      end
+
+      # Returns a new instance with new options
+      #
+      # @param new_options [Hash]
+      #
+      # @return [RelationProxy]
+      #
+      # @api private
+      def with(new_options)
+        __new__(relation, new_options)
+      end
+
+      # Returns if this relation is combined aka a relation graph
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def combine?
+        meta[:combine_type]
+      end
+
+      # Return if this relation is a composite
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def composite?
+        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
+      def adapter
+        relation.class.adapter
+      end
+
+      # Returns AST for the wrapped relation
+      #
+      # @return [Array]
+      #
+      # @api private
+      def to_ast
+        @to_ast ||=
+          begin
+            attr_ast = (attributes - wraps_attributes).map { |name|
+              [:attribute, name]
+            }
+
+            meta = options[:meta].merge(dataset: base_name.dataset)
+            meta.delete(:wraps)
+
+            header = attr_ast + nodes_ast + wraps_ast
+
+            [:relation, [base_name.relation, meta, [:header, header]]]
+          end
+      end
+
+      # @api private
+      def respond_to_missing?(meth, _include_private = false)
+        relation.respond_to?(meth) || super
+      end
+
+      private
+
+      # @api private
+      def base_name
+        relation.base_name
+      end
+
+      # @api private
+      def wraps_attributes
+        @wrap_attributes ||= wraps.flat_map { |wrap|
+          prefix = wrap.base_name.dataset
+          wrap.attributes.map { |name| :"#{prefix}_#{name}" }
+        }
+      end
+
+      # @api private
+      def nodes_ast
+        @nodes_ast ||= nodes.map(&:to_ast)
+      end
+
+      # @api private
+      def wraps_ast
+        @wraps_ast ||= wraps.map(&:to_ast)
+      end
+
+      # Return a new instance with another relation and options
+      #
+      # @return [RelationProxy]
+      #
+      # @api private
+      def __new__(relation, new_options = EMPTY_HASH)
+        self.class.new(
+          relation, new_options.size > 0 ? options.merge(new_options) : options
+        )
+      end
+
+      # Return all nodes that this relation combines
+      #
+      # @return [Array<RelationProxy>]
+      #
+      # @api private
+      def nodes
+        relation.graph? ? relation.nodes : EMPTY_ARRAY
+      end
+
+      # Return all nodes that this relation wraps
+      #
+      # @return [Array<RelationProxy>]
+      #
+      # @api private
+      def wraps
+        meta.fetch(:wraps, [])
+      end
+
+      # Forward to relation and wrap it with proxy if response was a relation too
+      #
+      # TODO: this will be simplified once ROM::Relation has lazy-features built-in
+      #       and ROM::Lazy is gone
+      #
+      # @api private
+      def method_missing(meth, *args, &block)
+        if relation.respond_to?(meth)
+          result = relation.__send__(meth, *args, &block)
+
+          if result.kind_of?(Relation::Materializable) && !result.is_a?(Relation::Loaded)
+            __new__(result)
+          else
+            result
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end