rom 5.4.1 → 6.0.0.alpha1

data/lib/rom/commands/lazy.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "rom/commands/composite"
+require "rom/commands/graph"
+
+module ROM
+  module Commands
+    # Lazy command wraps another command and evaluates its input when called
+    #
+    # @api private
+    class Lazy
+      include Dry::Equalizer(:command, :evaluator)
+
+      # @attr_reader [Command] command The wrapped command
+      attr_reader :command
+
+      alias_method :unwrap, :command
+
+      # @attr_reader [Proc] evaluator The proc that will evaluate the input
+      attr_reader :evaluator
+
+      attr_reader :command_proc
+
+      # @api private
+      def self.[](command)
+        case command
+        when Commands::Create then Lazy::Create
+        when Commands::Update then Lazy::Update
+        when Commands::Delete then Lazy::Delete
+        else
+          self
+        end
+      end
+
+      # @api private
+      def initialize(command, evaluator, command_proc = nil)
+        @command = command
+        @evaluator = evaluator
+        @command_proc = command_proc || proc { |*| command }
+      end
+
+      # Evaluate command's input using the input proc and pass to command
+      #
+      # @return [Array,Hash]
+      #
+      # @api public
+      def call(*_args)
+        raise NotImplementedError
+      end
+
+      # Compose a lazy command with another one
+      #
+      # @see Commands::Abstract#>>
+      #
+      # @return [Composite]
+      #
+      # @api public
+      def >>(other)
+        Composite.new(self, other)
+      end
+
+      # Combine with other lazy commands
+      #
+      # @see Abstract#combine
+      #
+      # @return [Graph]
+      #
+      # @api public
+      def combine(*others)
+        Graph.new(self, others)
+      end
+
+      # @api private
+      def lazy?
+        true
+      end
+
+      # @api private
+      def respond_to_missing?(name, include_private = false)
+        super || command.respond_to?(name)
+      end
+
+      private
+
+      # @api private
+      def method_missing(name, *args, &block)
+        if command.respond_to?(name)
+          response = command.public_send(name, *args, &block)
+
+          if response.instance_of?(command.class)
+            self.class.new(response, evaluator, command_proc)
+          else
+            response
+          end
+        else
+          super
+        end
+      end
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    end
+  end
+end
+
+require "rom/commands/lazy/create"
+require "rom/commands/lazy/update"
+require "rom/commands/lazy/delete"

data/lib/rom/commands/update.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "rom/command"
+
+module ROM
+  module Commands
+    # Update command
+    #
+    # This command updates all tuples in its relation with new attributes
+    #
+    # @abstract
+    class Update < Command
+      config.restrictable = true
+    end
+  end
+end

data/lib/rom/commands.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "rom/commands/create"
+require "rom/commands/update"
+require "rom/commands/delete"

data/lib/rom/compat/auto_registration.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require "rom/support/inflector"
+
+require "rom/types"
+require "rom/initializer"
+
+require_relative "auto_registration_strategies/no_namespace"
+require_relative "auto_registration_strategies/with_namespace"
+require_relative "auto_registration_strategies/custom_namespace"
+
+module ROM
+  # AutoRegistration is used to load component files automatically from the provided directory path
+  #
+  # @api public
+  class AutoRegistration
+    extend Initializer
+
+    NamespaceType = Types::Strict::Bool | Types::Strict::String
+
+    PathnameType = Types.Constructor(Pathname, &Kernel.method(:Pathname))
+
+    InflectorType = Types.Strict(Dry::Inflector)
+
+    DEFAULT_MAPPING = {
+      relations: :relations,
+      mappers: :mappers,
+      commands: :commands
+    }.freeze
+
+    # @!attribute [r] directory
+    #   @return [Pathname] The root path
+    param :directory, type: PathnameType
+
+    # @!attribute [r] namespace
+    #   @return [Boolean,String]
+    #     The name of the top level namespace or true/false which
+    #     enables/disables default top level namespace inferred from the dir name
+    option :namespace, type: NamespaceType, default: -> { true }
+
+    # @!attribute [r] component_dirs
+    #   @return [Hash] component => dir-name map
+    option :component_dirs, type: Types::Strict::Hash, default: -> { DEFAULT_MAPPING }
+
+    # @!attribute [r] globs
+    #   @return [Hash] File globbing functions for each component dir
+    option :globs, default: lambda {
+      component_dirs.map { |component, path|
+        [component, directory.join("#{path}/**/*.rb")]
+      }.to_h
+    }
+
+    # @!attribute [r] inflector
+    #   @return [Dry::Inflector] String inflector
+    #   @api private
+    option :inflector, type: InflectorType, default: -> { Inflector }
+
+    # Load relation files
+    #
+    # @api private
+    def relations
+      load_entities(:relations)
+    end
+
+    # Load command files
+    #
+    # @api private
+    def commands
+      load_entities(:commands)
+    end
+
+    # Load mapper files
+    #
+    # @api private
+    def mappers
+      load_entities(:mappers)
+    end
+
+    private
+
+    # Load given component files
+    #
+    # @api private
+    def load_entities(entity)
+      Dir[globs[entity]].sort.map do |file|
+        require file
+        klass_name =
+          case namespace
+          when String
+            AutoRegistrationStrategies::CustomNamespace.new(
+              namespace: namespace,
+              file: file,
+              directory: directory,
+              inflector: inflector
+            ).call
+          when TrueClass
+            AutoRegistrationStrategies::WithNamespace.new(
+              file: file, directory: directory, inflector: inflector
+            ).call
+          when FalseClass
+            AutoRegistrationStrategies::NoNamespace.new(
+              file: file,
+              directory: directory,
+              entity: component_dirs.fetch(entity),
+              inflector: inflector
+            ).call
+          end
+
+        inflector.constantize(klass_name)
+      end
+    end
+  end
+end

data/lib/rom/compat/auto_registration_strategies/base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rom/types"
+require "rom/initializer"
+require "rom/support/inflector"
+
+module ROM
+  module AutoRegistrationStrategies
+    # Base class for registration strategies
+    #
+    # @api private
+    class Base
+      extend Initializer
+
+      PathnameType = Types.Instance(Pathname)
+
+      EXTENSION_REGEX = /\.rb\z/.freeze
+
+      # @!attribute [r] file
+      #   @return [String] Name of a component file
+      option :file, type: Types::Strict::String
+
+      # @!attribute [r] inflector
+      #   @return [Dry::Inflector] String inflector
+      #   @api private
+      option :inflector, reader: true, default: -> { Inflector }
+    end
+  end
+end

data/lib/rom/compat/auto_registration_strategies/custom_namespace.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require "rom/support/inflector"
+require "rom/types"
+
+require_relative "base"
+
+module ROM
+  module AutoRegistrationStrategies
+    # Custom namespace strategy loads components and assumes they are defined
+    # within the provided namespace
+    #
+    # @api private
+    class CustomNamespace < Base
+      # @!attribute [r] directory
+      #   @return [Pathname] The path to dir with components
+      option :directory, type: PathnameType
+
+      # @!attribute [r] namespace
+      #   @return [String] Name of a namespace
+      option :namespace, type: Types::Strict::String
+
+      # Loads components
+      #
+      # @api private
+      def call
+        parts = path_arr.map { |part| inflector.camelize(part) }
+        potential = parts.map.with_index do |_, i|
+          parts[(i - parts.size)..parts.size]
+        end
+        attempted = []
+
+        potential.map do |path|
+          const_fragment = path.join("::")
+
+          constant = "#{namespace}::#{const_fragment}"
+
+          return constant if ns_const.const_defined?(const_fragment)
+
+          attempted << constant
+        end
+
+        # If we have reached this point, its means constant is not defined and
+        # NameError will be thrown if we attempt to camelize something like:
+        # `"#{namespace}::#{Inflector.camelize(filename)}"`
+        # so we can assume naming convention was not respected in required
+        # file.
+
+        raise NameError, name_error_message(attempted)
+      end
+
+      private
+
+      # @api private
+      def name_error_message(attempted)
+        "required file does not define expected constant name; either " \
+          "register your constant explicitly of try following the path" \
+          "naming convention like:\n\n\t- #{attempted.join("\n\t- ")}\n"
+      end
+
+      # @api private
+      def filename
+        Pathname(file).basename(".rb")
+      end
+
+      # @api private
+      def ns_const
+        @namespace_constant ||= inflector.constantize(namespace)
+      end
+
+      # @api private
+      def path_arr
+        file_path << filename
+      end
+
+      # @api private
+      def file_path
+        File.dirname(file).split("/") - directory.to_s.split("/")
+      end
+    end
+  end
+end

data/lib/rom/compat/auto_registration_strategies/no_namespace.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require "rom/support/inflector"
+require "rom/types"
+require_relative "base"
+
+module ROM
+  module AutoRegistrationStrategies
+    # NoNamespace strategy assumes components are not defined within a namespace
+    #
+    # @api private
+    class NoNamespace < Base
+      # @!attribute [r] directory
+      #   @return [Pathname] The path to dir with components
+      option :directory, type: PathnameType
+
+      # @!attribute [r] entity
+      #   @return [Symbol] Component identifier
+      option :entity, type: Types::Strict::Symbol
+
+      # Load components
+      #
+      # @api private
+      def call
+        inflector.camelize(
+          file.sub(%r{^#{directory}/#{entity}/}, "").sub(EXTENSION_REGEX, "")
+        )
+      end
+    end
+  end
+end

data/lib/rom/compat/auto_registration_strategies/with_namespace.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require "rom/support/inflector"
+require_relative "base"
+
+module ROM
+  module AutoRegistrationStrategies
+    # WithNamespace strategy assumes components are defined within a namespace
+    # that matches top-level directory name.
+    #
+    # @api private
+    class WithNamespace < Base
+      # @!attribute [r] directory
+      #   @return [Pathname] The path to dir with components
+      option :directory, type: PathnameType
+
+      # Load components
+      #
+      # @api private
+      def call
+        inflector.camelize(
+          file.sub(%r{^#{directory.dirname}/}, "").sub(EXTENSION_REGEX, "")
+        )
+      end
+    end
+  end
+end

data/lib/rom/compat/command.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "dry/core/class_attributes"
+require "rom/command"
+
+module ROM
+  class Command
+    extend Dry::Core::ClassAttributes
+
+    module Restrictable
+      extend ROM::Notifications::Listener
+
+      subscribe("configuration.commands.class.before_build") do |event|
+        command = event[:command]
+        relation = event[:relation]
+        command.extend_for_relation(relation) if command.restrictable
+      end
+
+      # @api private
+      def create_class(relation: nil, **, &block)
+        klass = super
+        klass.extend_for_relation(relation) if relation && klass.restrictable
+        klass
+      end
+    end
+
+    class << self
+      prepend Restrictable
+      prepend SettingProxy
+
+      def setting_mapping
+        @setting_mapper ||= {
+          adapter: [:component, :adapter],
+          relation: [:component, %i[relation namespace]],
+          register_as: [:component, :id],
+          restrictable: [],
+          result: [],
+          input: []
+        }.freeze
+      end
+    end
+
+    # Extend a command class with relation view methods
+    #
+    # @param [Relation] relation
+    #
+    # @return [Class]
+    #
+    # @api public
+    # @deprecated
+    def self.extend_for_relation(relation)
+      include(relation_methods_mod(relation.class))
+    end
+
+    # @api private
+    def self.relation_methods_mod(relation_class)
+      Module.new do
+        relation_class.view_methods.each do |meth|
+          module_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{meth}(*args)
+              response = relation.public_send(:#{meth}, *args)
+
+              if response.is_a?(relation.class)
+                new(response)
+              else
+                response
+              end
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/rom/compat/components/dsl/schema.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "rom/relation/name"
+
+require "rom/components/dsl/schema"
+require "rom/compat/schema/dsl"
+
+module ROM
+  module Components
+    module DSL
+      # @private
+      #
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      class Schema < Core
+        mod = Module.new do
+          # @api private
+          def call
+            return super unless config.dsl_class || config.view
+
+            configure
+
+            if config.view
+              components.add(key, name: name, config: config, block: block)
+            else
+              dsl_config = backend.config
+              associations = dsl_config[:associations]
+
+              component = components.add(key, name: name, config: config.join(dsl_config, :right))
+
+              associations.each do |definition|
+                components.add(
+                  :associations,
+                  definition: definition,
+                  config: dsl_assoc_config.join({namespace: relation, **definition.to_h}, :right)
+                )
+              end
+
+              component
+            end
+          end
+
+          # @api public
+          #
+          # @deprecated
+          def associations(&block)
+            backend.associations(&block)
+          end
+
+          private
+
+          # @api private
+          def name
+            ROM::Relation::Name[relation, config.dataset]
+          end
+
+          # @api private
+          def dsl_assoc_config
+            provider.config.association.merge(adapter: adapter, inflector: inflector)
+          end
+
+          # @api private
+          def backend
+            @backend ||= config.dsl_class.new(
+              **config,
+              attributes: attributes,
+              inferrer: inferrer,
+              inflector: inflector,
+              plugins: config.plugins,
+              relation: name,
+              definition: block
+            )
+          end
+
+          # @api private
+          def configure
+            if !config.view && provider.config.component.type == :relation
+              provider.config.component.update(dataset: config.dataset) if config.dataset
+              provider.config.component.update(id: config.as) if config.as
+
+              if provider.config.component.id == :anonymous
+                provider.config.component.update(id: config.id)
+              end
+
+              if config.id.nil?
+                config.update(id: provider.config.component.id)
+              end
+
+              if config.relation.nil?
+                config.update(relation: provider.config.component.id)
+              end
+
+              if config.adapter.nil?
+                config.update(adapter: provider.config.component.adapter)
+              end
+            end
+
+            config.update(id: relation) if relation && (config.id.nil? || config.as)
+
+            if provider.config.component.type == :relation
+              provider.config.component.inherit!(config)
+            end
+
+            if config.view
+              config.join!({namespace: relation}, :right)
+            end
+
+            super
+          end
+
+          # @api private
+          def relation
+            config.relation || config.as || config.id
+          end
+
+          # @api private
+          def inferrer
+            config.inferrer.with(enabled: config.infer)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/PerceivedComplexity
+
+        prepend(mod)
+      end
+    end
+  end
+end