rom-repository 0.0.1

data/lib/rom/repository/ext/relation/view_dsl.rb

@@ -0,0 +1,33 @@
+module ROM
+  module SQL
+    class Relation < ROM::Relation
+      # View DSL evaluator
+      #
+      # @api private
+      class ViewDSL
+        attr_reader :name
+
+        attr_reader :attributes
+
+        attr_reader :relation_block
+
+        def initialize(name, &block)
+          @name = name
+          instance_eval(&block)
+        end
+
+        def header(attributes)
+          @attributes = attributes
+        end
+
+        def relation(&block)
+          @relation_block = lambda(&block)
+        end
+
+        def call
+          [name, attributes, relation_block]
+        end
+      end
+    end
+  end
+end

data/lib/rom/repository/header_builder.rb

@@ -0,0 +1,63 @@
+require 'rom/header'
+
+require 'rom/repository/struct_builder'
+
+module ROM
+  class Repository < Gateway
+    # @api private
+    class HeaderBuilder
+      attr_reader :struct_builder
+
+      def self.new(struct_builder = StructBuilder.new)
+        super
+      end
+
+      def initialize(struct_builder)
+        @struct_builder = struct_builder
+      end
+
+      def call(ast)
+        Header.coerce(*visit(ast))
+      end
+      alias_method :[], :call
+
+      private
+
+      def visit(ast, *args)
+        __send__("visit_#{ast.first}", *(ast[1..ast.size-1] + args))
+      end
+
+      def visit_relation(*args)
+        name, header, meta = args
+
+        options = [
+          visit_header(header[1], meta),
+          model: struct_builder[meta.fetch(:base_name), header[1].map { |a| a[1] }]
+        ]
+
+        if meta[:combine_type]
+          type = meta[:combine_type] == :many ? :array : :hash
+          keys = meta.fetch(:keys)
+
+          [name, combine: true, type: type, keys: keys, header: Header.coerce(*options)]
+        elsif meta[:wrap]
+          [name, wrap: true, type: :hash, header: Header.coerce(*options)]
+        else
+          options
+        end
+      end
+
+      def visit_header(header, meta = {})
+        header.map { |attribute| visit(attribute, meta) }
+      end
+
+      def visit_attribute(name, meta = {})
+        if meta[:wrap]
+          [name, from: :"#{meta[:base_name]}_#{name}"]
+        else
+          [name]
+        end
+      end
+    end
+  end
+end

data/lib/rom/repository/loading_proxy.rb

@@ -0,0 +1,173 @@
+require 'rom/support/options'
+require 'rom/relation/materializable'
+
+require 'rom/repository/loading_proxy/combine'
+require 'rom/repository/loading_proxy/wrap'
+
+module ROM
+  class Repository < Gateway
+    # LoadingProxy decorates a relation and automatically generate mappers that
+    # will map raw tuples into structs
+    #
+    # @api public
+    class LoadingProxy
+      include Relation::Materializable
+      include Options
+
+      include LoadingProxy::Combine
+      include LoadingProxy::Wrap
+
+      option :name, reader: true, type: Symbol
+      option :mapper_builder, reader: true, default: proc { MapperBuilder.new }
+      option :meta, reader: true, type: Hash, default: EMPTY_HASH
+
+      # @attr_reader [ROM::Relation::Lazy] relation Decorated relation
+      attr_reader :relation
+
+      # @api private
+      def initialize(relation, options = {})
+        super
+        @relation = relation
+      end
+
+      # Materialize wrapped relation and send 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
+
+      # Map this relation with other mappers too
+      #
+      # @api public
+      def map_with(*names)
+        mappers = [mapper]+names.map { |name| relation.mappers[name] }
+        mappers.reduce(self) { |a, e| a >> e }
+      end
+      alias_method :as, :map_with
+
+      # Return AST for this relation
+      #
+      # @return [Array]
+      #
+      # @api private
+      def to_ast
+        attr_ast = columns.map { |name| [:attribute, name] }
+
+        node_ast = nodes.map(&:to_ast)
+        wrap_ast = wraps.map(&:to_ast)
+
+        wrap_attrs = wraps.flat_map { |wrap|
+          wrap.columns.map { |c| [:attribute, :"#{wrap.base_name}_#{c}"] }
+        }
+
+        meta = options[:meta].merge(base_name: relation.base_name)
+        meta.delete(:wraps)
+
+        [:relation, name, [:header, (attr_ast - wrap_attrs) + node_ast + wrap_ast], meta]
+      end
+
+      # Infer a mapper for the relation
+      #
+      # @return [ROM::Mapper]
+      #
+      # @api private
+      def mapper
+        mapper_builder[to_ast]
+      end
+
+      # @api private
+      def respond_to_missing?(name, include_private = false)
+        relation.respond_to?(name) || super
+      end
+
+      # Return new instance with new options
+      #
+      # @return [LoadingProxy]
+      #
+      # @api private
+      def with(new_options)
+        __new__(relation, new_options)
+      end
+
+      # Return if this relation is combined
+      #
+      # @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
+
+      # Return meta info for this relation
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def meta
+        options[:meta]
+      end
+
+      private
+
+      # Return a new instance with another relation and options
+      #
+      # @return [LoadingProxy]
+      #
+      # @api private
+      def __new__(relation, new_options = {})
+        self.class.new(relation, options.merge(new_options))
+      end
+
+      # Return all nodes that this relation combines
+      #
+      # @return [Array<LoadingProxy>]
+      #
+      # @api private
+      def nodes
+        relation.is_a?(Relation::Graph) ? relation.nodes : []
+      end
+
+      # Return all nodes that this relation wraps
+      #
+      # @return [Array<LoadingProxy>]
+      #
+      # @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)
+        if relation.respond_to?(meth)
+          result = relation.__send__(meth, *args)
+
+          if result.is_a?(Relation::Lazy) || result.is_a?(Relation::Graph) || result.is_a?(Relation::Composite)
+            __new__(result)
+          else
+            result
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,158 @@
+module ROM
+  class Repository < Gateway
+    class LoadingProxy
+      # Provides convenient methods for producing combined relations
+      #
+      # @api public
+      module Combine
+        # Combine with other relations
+        #
+        # @example
+        #   # combining many
+        #   users.combine(many: { tasks: [tasks, id: :task_id] })
+        #   users.combine(many: { tasks: [tasks.for_users, id: :task_id] })
+        #
+        #   # combining one
+        #   users.combine(one: { task: [tasks, id: :task_id] })
+        #
+        # @param [Hash] options
+        #
+        # @return [LoadingProxy]
+        #
+        # @api public
+        def combine(options)
+          combine_opts = options.each_with_object({}) do |(type, relations), result|
+            result[type] = relations.each_with_object({}) do |(name, (other, keys)), h|
+              h[name] = [
+                other.curried? ? other : other.combine_method(relation, keys), keys
+              ]
+            end
+          end
+
+          nodes = combine_opts.flat_map do |type, relations|
+            relations.map { |name, (relation, keys)|
+              relation.combined(name, keys, type)
+            }
+          end
+
+          __new__(relation.combine(*nodes))
+        end
+
+        # Shortcut for combining with parents which infers the join keys
+        #
+        # @example
+        #   tasks.combine_parents(one: users)
+        #
+        # @param [Hash] options
+        #
+        # @return [LoadingProxy]
+        #
+        # @api public
+        def combine_parents(options)
+          combine(options.each_with_object({}) { |(type, parents), h|
+            h[type] =
+              if parents.is_a?(Hash)
+                parents.each_with_object({}) { |(key, parent), r|
+                  r[key] = [parent, combine_keys(parent, :parent)]
+                }
+              else
+                (parents.is_a?(Array) ? parents : [parents])
+                  .each_with_object({}) { |parent, r|
+                  r[parent.combine_tuple_key(type)] = [
+                    parent, combine_keys(parent, :parent)
+                  ]
+                }
+              end
+          })
+        end
+
+        # Shortcut for combining with children which infers the join keys
+        #
+        # @example
+        #   users.combine_parents(many: tasks)
+        #
+        # @param [Hash] options
+        #
+        # @return [LoadingProxy]
+        #
+        # @api public
+        def combine_children(options)
+          combine(options.each_with_object({}) { |(type, children), h|
+            h[type] =
+              if children.is_a?(Hash)
+                children.each_with_object({}) { |(key, child), r|
+                  r[key] = [child, combine_keys(relation, :children)]
+                }
+              else
+                (children.is_a?(Array) ? children : [children])
+                  .each_with_object({}) { |child, r|
+                  r[child.combine_tuple_key(type)] = [
+                    child, combine_keys(relation, :children)
+                  ]
+                }
+              end
+          })
+        end
+
+        # Infer join keys for a given relation and association type
+        #
+        # @param [LoadingProxy] relation
+        # @param [Symbol] type The type can be either :parent or :children
+        #
+        # @return [Hash<Symbol=>Symbol>]
+        #
+        # @api private
+        def combine_keys(relation, type)
+          if type == :parent
+            { relation.foreign_key => relation.primary_key }
+          else
+            { relation.primary_key => relation.foreign_key }
+          end
+        end
+
+        # Infer relation for combine operation
+        #
+        # By default it uses `for_combine` which is implemented as SQL::Relation
+        # extension
+        #
+        # @return [LoadingProxy]
+        #
+        # @api private
+        def combine_method(other, keys)
+          custom_name = :"for_#{other.base_name}"
+
+          if relation.respond_to?(custom_name)
+            __send__(custom_name)
+          else
+            for_combine(keys)
+          end
+        end
+
+        # Infer key under which a combine relation will be loaded
+        #
+        # @return [Symbol]
+        #
+        # @api private
+        def combine_tuple_key(arity)
+          if arity == :one
+            Inflector.singularize(base_name).to_sym
+          else
+            base_name
+          end
+        end
+
+        # Return combine representation of a loading-proxy relation
+        #
+        # This will carry meta info used to produce a correct AST from a relation
+        # so that correct mapper can be generated
+        #
+        # @return [LoadingProxy]
+        #
+        # @api private
+        def combined(name, keys, type)
+          with(name: name, meta: { keys: keys, combine_type: type })
+        end
+      end
+    end
+  end
+end

data/lib/rom/repository/loading_proxy/wrap.rb

@@ -0,0 +1,60 @@
+module ROM
+  class Repository < Gateway
+    class LoadingProxy
+      # Provides convenient methods for producing wrapped relations
+      #
+      # @api public
+      module Wrap
+        # Wrap other relations
+        #
+        # @example
+        #   tasks.wrap(owner: [users, user_id: :id])
+        #
+        # @param [Hash] options
+        #
+        # @return [LoadingProxy]
+        #
+        # @api public
+        def wrap(options)
+          wraps = options.map { |(name, (relation, keys))|
+            relation.wrapped(name, keys)
+          }
+
+          relation = wraps.reduce(self) { |a, e|
+            a.relation.for_wrap(e.base_name, e.meta.fetch(:keys))
+          }
+
+          __new__(relation, meta: { wraps: wraps })
+        end
+
+        # Shortcut to wrap parents
+        #
+        # @example
+        #   tasks.wrap_parent(owner: users)
+        #
+        # @return [LoadingProxy]
+        #
+        # @api public
+        def wrap_parent(options)
+          wrap(
+            options.each_with_object({}) { |(name, parent), h|
+              h[name] = [parent, combine_keys(parent, :children)]
+            }
+          )
+        end
+
+        # Return a wrapped representation of a loading-proxy relation
+        #
+        # This will carry meta info used to produce a correct AST from a relation
+        # so that correct mapper can be generated
+        #
+        # @return [LoadingProxy]
+        #
+        # @api private
+        def wrapped(name, keys)
+          with(name: name, meta: { keys: keys, wrap: true })
+        end
+      end
+    end
+  end
+end