rom-core 4.0.0.beta1

data/lib/rom/associations/many_to_many.rb

@@ -0,0 +1,81 @@
+require 'rom/types'
+require 'rom/associations/abstract'
+
+module ROM
+  module Associations
+    class ManyToMany < Abstract
+      attr_reader :join_relation
+
+      # @api private
+      def initialize(*)
+        super
+        @join_relation = relations[through]
+      end
+
+      # @api public
+      def call(*)
+        raise NotImplementedError
+      end
+
+      # @api public
+      def foreign_key
+        definition.foreign_key || join_relation.foreign_key(source.name)
+      end
+
+      # @api public
+      def through
+        definition.through
+      end
+
+      # @api private
+      def parent_combine_keys
+        target.associations[source.name].combine_keys.to_a.flatten(1)
+      end
+
+      # @api private
+      def associate(children, parent)
+        ((spk, sfk), (tfk, tpk)) = join_key_map
+
+        case parent
+        when Array
+          parent.map { |p| associate(children, p) }.flatten(1)
+        else
+          children.map { |tuple|
+            { sfk => tuple.fetch(spk), tfk => parent.fetch(tpk) }
+          }
+        end
+      end
+
+      protected
+
+      # @api protected
+      def source_key
+        source.primary_key
+      end
+
+      # @api protected
+      def target_key
+        foreign_key
+      end
+
+      # @api protected
+      def join_assoc
+        if join_relation.associations.key?(through.assoc_name)
+          join_relation.associations[through.assoc_name]
+        else
+          join_relation.associations[through.target]
+        end
+      end
+
+      # @api protected
+      def join_key_map
+        left = super
+        right = join_assoc.join_key_map
+
+        [left, right]
+      end
+
+      memoize :foreign_key, :join_assoc, :join_key_map
+    end
+  end
+end

data/lib/rom/associations/many_to_one.rb

@@ -0,0 +1,37 @@
+require 'rom/associations/abstract'
+
+module ROM
+  module Associations
+    class ManyToOne < Abstract
+      # @api public
+      def call(*)
+        raise NotImplementedError
+      end
+
+      # @api public
+      def foreign_key
+        definition.foreign_key || source.foreign_key(target.name)
+      end
+
+      # @api private
+      def associate(child, parent)
+        fk, pk = join_key_map
+        child.merge(fk => parent.fetch(pk))
+      end
+
+      protected
+
+      # @api protected
+      def source_key
+        foreign_key
+      end
+
+      # @api protected
+      def target_key
+        target.schema.primary_key_name
+      end
+
+      memoize :foreign_key
+    end
+  end
+end

data/lib/rom/associations/one_to_many.rb

@@ -0,0 +1,37 @@
+require 'rom/associations/abstract'
+
+module ROM
+  module Associations
+    class OneToMany < Abstract
+      # @api public
+      def call(*)
+        raise NotImplementedError
+      end
+
+      # @api public
+      def foreign_key
+        definition.foreign_key || target.foreign_key(source.name)
+      end
+
+      # @api private
+      def associate(child, parent)
+        pk, fk = join_key_map
+        child.merge(fk => parent.fetch(pk))
+      end
+
+      protected
+
+      # @api protected
+      def source_key
+        source.schema.primary_key_name
+      end
+
+      # @api protected
+      def target_key
+        foreign_key
+      end
+
+      memoize :foreign_key
+    end
+  end
+end

data/lib/rom/associations/one_to_one.rb

@@ -0,0 +1,8 @@
+require 'rom/associations/one_to_many'
+
+module ROM
+  module Associations
+    class OneToOne < OneToMany
+    end
+  end
+end

data/lib/rom/associations/one_to_one_through.rb

@@ -0,0 +1,8 @@
+require 'rom/associations/many_to_many'
+
+module ROM
+  module Associations
+    class OneToOneThrough < ManyToMany
+    end
+  end
+end

data/lib/rom/associations/through_identifier.rb

@@ -0,0 +1,39 @@
+require 'dry/core/inflector'
+
+module ROM
+  module Associations
+    # @api private
+    class ThroughIdentifier
+      # @api private
+      attr_reader :source
+
+      # @api private
+      attr_reader :target
+
+      # @api private
+      attr_reader :assoc_name
+
+      # @api private
+      def self.[](source, target, assoc_name = nil)
+        new(source, target, assoc_name || default_assoc_name(target))
+      end
+
+      # @api private
+      def self.default_assoc_name(relation)
+        Dry::Core::Inflector.singularize(relation).to_sym
+      end
+
+      # @api private
+      def initialize(source, target, assoc_name)
+        @source = source
+        @target = target
+        @assoc_name = assoc_name
+      end
+
+      # @api private
+      def to_sym
+        source
+      end
+    end
+  end
+end

data/lib/rom/auto_curry.rb

@@ -0,0 +1,55 @@
+module ROM
+  module AutoCurry
+    def self.extended(klass)
+      klass.define_singleton_method(:method_added) do |name|
+        return if auto_curry_busy?
+        auto_curry_guard { auto_curry(name) }
+        super(name)
+      end
+    end
+
+    def auto_curry_guard
+      @__auto_curry_busy__ = true
+      yield
+    ensure
+      @__auto_curry_busy__ = false
+    end
+
+    def auto_curry_busy?
+      @__auto_curry_busy__ ||= false
+    end
+
+    def auto_curried_methods
+      @__auto_curried_methods__ ||= []
+    end
+
+    def auto_curry(name, &block)
+      arity = instance_method(name).arity
+
+      return unless public_instance_methods.include?(name) && arity != 0
+
+      mod = Module.new
+
+      mod.module_eval do
+        define_method(name) do |*args, &mblock|
+          response =
+            if arity < 0 || arity == args.size
+              super(*args, &mblock)
+            else
+              self.class.curried.new(self, view: name, curry_args: args, arity: arity)
+            end
+
+          if block
+            response.instance_exec(&block)
+          else
+            response
+          end
+        end
+      end
+
+      auto_curried_methods << name
+
+      prepend(mod)
+    end
+  end
+end

data/lib/rom/cache.rb

@@ -0,0 +1,46 @@
+require 'concurrent/map'
+
+module ROM
+  # @api private
+  class Cache
+    attr_reader :objects
+
+    class Namespaced
+      attr_reader :cache
+
+      attr_reader :namespace
+
+      def initialize(cache, namespace)
+        @cache = cache
+        @namespace = namespace.to_sym
+      end
+
+      def [](key)
+        cache[[namespace, key].hash]
+      end
+
+      def fetch_or_store(*args, &block)
+        cache.fetch_or_store([namespace, args.hash].hash, &block)
+      end
+    end
+
+    # @api private
+    def initialize
+      @objects = Concurrent::Map.new
+      @namespaced = {}
+    end
+
+    def [](key)
+      cache[key]
+    end
+
+    # @api private
+    def fetch_or_store(*args, &block)
+      objects.fetch_or_store(args.hash, &block)
+    end
+
+    def namespaced(namespace)
+      @namespaced[namespace] ||= Namespaced.new(objects, namespace)
+    end
+  end
+end

data/lib/rom/command.rb

@@ -0,0 +1,488 @@
+require 'dry/core/deprecations'
+require 'dry/core/class_attributes'
+
+require 'rom/types'
+require 'rom/initializer'
+require 'rom/pipeline'
+
+require 'rom/commands/class_interface'
+require 'rom/commands/composite'
+require 'rom/commands/graph'
+require 'rom/commands/lazy'
+
+module ROM
+  # Abstract command class
+  #
+  # Provides a constructor accepting relation with options and basic behavior
+  # for calling, currying and composing commands.
+  #
+  # Typically command subclasses should inherit from specialized
+  # Create/Update/Delete, not this one.
+  #
+  # @abstract
+  #
+  # @api public
+  class Command
+    extend Initializer
+    include Dry::Equalizer(:relation, :options)
+    include Commands
+    include Pipeline::Operator
+
+    extend Dry::Core::ClassAttributes
+    extend ClassInterface
+
+    # @!method self.adapter
+    #   Get or set adapter identifier
+    #
+    #   @overload adapter
+    #     Get adapter identifier
+    #
+    #     @example
+    #       ROM::Memory::Commands::Create.adapter
+    #       # => :memory
+    #
+    #     @return [Symbol]
+    #
+    #   @overload adapter(identifier)
+    #     Set adapter identifier. This must always match actual adapter identifier
+    #     that was used to register an adapter.
+    #
+    #     @example
+    #       module MyAdapter
+    #         class CreateCommand < ROM::Commands::Memory::Create
+    #           adapter :my_adapter
+    #         end
+    #       end
+    #
+    # @api public
+    defines :adapter
+
+    # @!method self.relation
+    #   Get or set relation identifier
+    #
+    #   @overload relation
+    #     Get relation identifier
+    #
+    #     @example
+    #       class CreateUser < ROM::Commands::Create[:memory]
+    #         relation :users
+    #       end
+    #
+    #       CreateUser.relation
+    #       # => :users
+    #
+    #     @return [Symbol]
+    #
+    #   @overload relation(identifier)
+    #     Set relation identifier.
+    #
+    #     @example
+    #       class CreateUser < ROM::Commands::Create[:memory]
+    #         relation :users
+    #       end
+    #
+    # @api public
+    defines :relation
+
+    # @!method self.relation
+    #   Get or set result type
+    #
+    #   @overload result
+    #     Get result type
+    #
+    #     @example
+    #       class CreateUser < ROM::Commands::Create[:memory]
+    #         result :one
+    #       end
+    #
+    #       CreateUser.result
+    #       # => :one
+    #
+    #     @return [Symbol]
+    #
+    #   @overload relation(identifier)
+    #     Set result type
+    #
+    #     @example
+    #       class CreateUser < ROM::Commands::Create[:memory]
+    #         result :one
+    #       end
+    #
+    # @api public
+    defines :result
+
+    # @!method self.relation
+    #   Get or set input processing function. This is typically set during setup
+    #   to relation's input_schema
+    #
+    #   @overload input
+    #     Get input processing function
+    #
+    #     @example
+    #       class CreateUser < ROM::Commands::Create[:memory]
+    #         input -> tuple { .. }
+    #       end
+    #
+    #       CreateUser.input
+    #       # Your custom function
+    #
+    #     @return [Proc,#call]
+    #
+    #   @overload input(identifier)
+    #     Set input processing function
+    #
+    #     @example
+    #       class CreateUser < ROM::Commands::Create[:memory]
+    #         input -> tuple { .. }
+    #       end
+    #
+    # @api public
+    defines :input
+
+    # @!method self.register_as
+    #   Get or set identifier that should be used to register a command in a container
+    #
+    #   @overload register_as
+    #     Get registration identifier
+    #
+    #     @example
+    #       class CreateUser < ROM::Commands::Create[:memory]
+    #         register_as :create_user
+    #       end
+    #
+    #       CreateUser.register_as
+    #       # => :create_user
+    #
+    #     @return [Symbol]
+    #
+    #   @overload register_as(identifier)
+    #     Set registration identifier
+    #
+    #     @example
+    #       class CreateUser < ROM::Commands::Create[:memory]
+    #         register_as :create_user
+    #       end
+    #
+    # @api public
+    defines :register_as
+
+    # @!method self.restrictable
+    #   @overload restrictable
+    #     Check if a command class is restrictable
+    #
+    #     @example
+    #       class UpdateUser < ROM::Commands::Update[:memory]
+    #         restrictable true
+    #       end
+    #
+    #       CreateUser.restrictable
+    #       # => true
+    #
+    #     @return [FalseClass, TrueClass]
+    #
+    #   @overload restrictable(value)
+    #     Set if a command is restrictable
+    #
+    #     @example
+    #       class UpdateUser < ROM::Commands::Update[:memory]
+    #         restrictable true
+    #       end
+    #
+    # @api public
+    defines :restrictable
+
+    # @!attribute [r] relation
+    #   @return [Relation] Command's relation
+    param :relation
+
+    CommandType = Types::Strict::Symbol.enum(:create, :update, :delete)
+    Result = Types::Strict::Symbol.enum(:one, :many)
+
+    # @!attribute [r] type
+    #   @return [Symbol] The command type, one of :create, :update or :delete
+    option :type, type: CommandType, optional: true
+
+    # @!attribute [r] source
+    #   @return [Relation] The source relation
+    option :source, default: -> { relation }
+
+    # @!attribute [r] result
+    #   @return [Symbol] Result type, either :one or :many
+    option :result, type: Result
+
+    # @!attribute [r] input
+    #   @return [Proc, #call] Tuple processing function, typically uses Relation#input_schema
+    option :input
+
+    # @!attribute [r] curry_args
+    #   @return [Array] Curried args
+    option :curry_args, default: -> { EMPTY_ARRAY }
+
+    # @!attribute [r] before
+    #   @return [Array<Hash>] An array with before hooks configuration
+    option :before, Types::Coercible::Array, reader: false, default: -> { self.class.before }
+
+    # @!attribute [r] after
+    #   @return [Array<Hash>] An array with after hooks configuration
+    option :after, Types::Coercible::Array, reader: false, default: -> { self.class.after }
+
+    input Hash
+    result :many
+
+    # Return name of this command's relation
+    #
+    # @return [ROM::Relation::Name]
+    #
+    # @api public
+    def name
+      relation.name
+    end
+
+    # Return gateway of this command's relation
+    #
+    # @return [Symbol]
+    #
+    # @api public
+    def gateway
+      relation.gateway
+    end
+
+    # Execute the command
+    #
+    # @abstract
+    #
+    # @return [Array] an array with inserted tuples
+    #
+    # @api private
+    def execute(*)
+      raise(
+        NotImplementedError,
+        "#{self.class}##{__method__} must be implemented"
+      )
+    end
+
+    # Call the command and return one or many tuples
+    #
+    # This method will apply before/after hooks automatically
+    #
+    # @api public
+    def call(*args, &block)
+      tuples =
+        if hooks?
+          prepared =
+            if curried?
+              apply_hooks(before_hooks, *(curry_args + args))
+            else
+              apply_hooks(before_hooks, *args)
+            end
+
+          result = prepared ? execute(prepared, &block) : execute(&block)
+
+          if curried?
+            if args.size > 0
+              apply_hooks(after_hooks, result, *args)
+            elsif curry_args.size > 1
+              apply_hooks(after_hooks, result, curry_args[1])
+            else
+              apply_hooks(after_hooks, result)
+            end
+          else
+            apply_hooks(after_hooks, result, *args[1..args.size-1])
+          end
+        else
+          execute(*(curry_args + args), &block)
+        end
+
+      if one?
+        tuples.first
+      else
+        tuples
+      end
+    end
+    alias_method :[], :call
+
+    # Curry this command with provided args
+    #
+    # Curried command can be called without args. If argument is a graph input processor,
+    # lazy command will be returned, which is used for handling nested input hashes.
+    #
+    # @return [Command, Lazy]
+    #
+    # @api public
+    def curry(*args)
+      if curry_args.empty? && args.first.is_a?(Graph::InputEvaluator)
+        Lazy[self].new(self, *args)
+      else
+        self.class.build(relation, **options, curry_args: args)
+      end
+    end
+    alias_method :with, :curry
+
+    # Compose this command with other commands
+    #
+    # Composed commands can handle nested input
+    #
+    # @return [Command::Graph]
+    #
+    # @api public
+    def combine(*others)
+      Graph.new(self, others)
+    end
+
+    # Check if this command is curried
+    #
+    # @return [TrueClass, FalseClass]
+    #
+    # @api public
+    def curried?
+      curry_args.size > 0
+    end
+
+    # Return a new command with new options
+    #
+    # @param [Hash] new_opts A hash with new options
+    #
+    # @return [Command]
+    #
+    # @api public
+    def with_opts(new_opts)
+      self.class.new(relation, options.merge(new_opts))
+    end
+
+    # Return a new command with appended before hooks
+    #
+    # @param [Array<Hash>] hooks A list of before hooks configurations
+    #
+    # @return [Command]
+    #
+    # @api public
+    def before(*hooks)
+      self.class.new(relation, **options, before: before_hooks + hooks)
+    end
+
+    # Return a new command with appended after hooks
+    #
+    # @param [Array<Hash>] hooks A list of after hooks configurations
+    #
+    # @return [Command]
+    #
+    # @api public
+    def after(*hooks)
+      self.class.new(relation, **options, after: after_hooks + hooks)
+    end
+
+    # List of before hooks
+    #
+    # @return [Array]
+    #
+    # @api public
+    def before_hooks
+      options[:before]
+    end
+
+    # List of after hooks
+    #
+    # @return [Array]
+    #
+    # @api public
+    def after_hooks
+      options[:after]
+    end
+
+    # Return a new command with other source relation
+    #
+    # This can be used to restrict command with a specific relation
+    #
+    # @return [Command]
+    #
+    # @api public
+    def new(new_relation)
+      self.class.build(new_relation, **options, source: relation)
+    end
+
+    # Check if this command has any hooks
+    #
+    # @api private
+    def hooks?
+      before_hooks.size > 0 || after_hooks.size > 0
+    end
+
+    # Check if this command is lazy
+    #
+    # @return [false]
+    #
+    # @api private
+    def lazy?
+      false
+    end
+
+    # Check if this command is a graph
+    #
+    # @return [false]
+    #
+    # @api private
+    def graph?
+      false
+    end
+
+    # Check if this command returns a single tuple
+    #
+    # @return [TrueClass,FalseClass]
+    #
+    # @api private
+    def one?
+      result.equal?(:one)
+    end
+
+    # Check if this command returns many tuples
+    #
+    # @return [TrueClass,FalseClass]
+    #
+    # @api private
+    def many?
+      result.equal?(:many)
+    end
+
+    private
+
+    # Hook called by Pipeline to get composite class for commands
+    #
+    # @return [Class]
+    #
+    # @api private
+    def composite_class
+      Command::Composite
+    end
+
+    # Apply provided hooks
+    #
+    # Used by #call
+    #
+    # @return [Array<Hash>]
+    #
+    # @api private
+    def apply_hooks(hooks, tuples, *args)
+      hooks.reduce(tuples) do |a, e|
+        if e.is_a?(Hash)
+          hook_meth, hook_args = e.to_a.flatten(1)
+          __send__(hook_meth, a, *args, **hook_args)
+        else
+          __send__(e, a, *args)
+        end
+      end
+    end
+
+    # Pipes a dataset through command's relation
+    #
+    # @return [Array]
+    #
+    # @api private
+    def wrap_dataset(dataset)
+      if relation.is_a?(Relation::Composite)
+        relation.new(dataset).to_a
+      else
+        dataset
+      end
+    end
+  end
+end