rom-core 4.0.0.beta1

data/lib/rom/schema/dsl.rb

@@ -0,0 +1,164 @@
+require 'dry/equalizer'
+
+require 'rom/types'
+require 'rom/schema/attribute'
+require 'rom/schema/associations_dsl'
+
+module ROM
+  # Relation schema
+  #
+  # @api public
+  class Schema
+    # @api public
+    class DSL < BasicObject
+      KERNEL_METHODS = %i(extend method).freeze
+      KERNEL_METHODS.each { |m| define_method(m, ::Kernel.instance_method(m)) }
+
+      extend Initializer
+
+      param :relation
+
+      option :inferrer, default: -> { DEFAULT_INFERRER }
+
+      option :schema_class, default: -> { Schema }
+
+      option :attr_class, default: -> { Attribute }
+
+      option :adapter, default: -> { :default }
+
+      attr_reader :attributes, :plugins, :definition, :associations_dsl
+
+      # @api private
+      def initialize(*, &block)
+        super
+
+        @attributes = {}
+        @plugins = {}
+
+        @definition = block
+      end
+
+      # Defines a relation attribute with its type
+      #
+      # @see Relation.schema
+      #
+      # @api public
+      def attribute(name, type, options = EMPTY_HASH)
+        if attributes.key?(name)
+          ::Kernel.raise ::ROM::Schema::AttributeAlreadyDefinedError,
+                         "Attribute #{ name.inspect } already defined"
+        end
+
+        attributes[name] = build_type(name, type, options)
+      end
+
+      # Define associations for a relation
+      #
+      # @example
+      #   class Users < ROM::Relation[:sql]
+      #     schema(infer: true) do
+      #       associations do
+      #         has_many :tasks
+      #         has_many :posts
+      #         has_many :posts, as: :priority_posts, view: :prioritized
+      #         belongs_to :account
+      #       end
+      #     end
+      #   end
+      #
+      #   class Posts < ROM::Relation[:sql]
+      #     schema(infer: true) do
+      #       associations do
+      #         belongs_to :users, as: :author
+      #       end
+      #     end
+      #
+      #     view(:prioritized) do
+      #       where { priority <= 3 }
+      #     end
+      #   end
+      #
+      # @return [AssociationDSL]
+      #
+      # @api public
+      def associations(&block)
+        @associations_dsl = AssociationsDSL.new(relation, &block)
+      end
+
+      # Builds a type instance from a name, options and a base type
+      #
+      # @return [Dry::Types::Type] Type instance
+      #
+      # @api private
+      def build_type(name, type, options = EMPTY_HASH)
+        if options[:read]
+          type.meta(name: name, source: relation, read: options[:read])
+        else
+          type.meta(name: name, source: relation)
+        end
+      end
+
+      # Specify which key(s) should be the primary key
+      #
+      # @api public
+      def primary_key(*names)
+        names.each do |name|
+          attributes[name] = attributes[name].meta(primary_key: true)
+        end
+        self
+      end
+
+      # Enables for the schema
+      #
+      # @param [Symbol] plugin Plugin name
+      # @param [Hash] options Plugin options
+      #
+      # @api public
+      def use(plugin, options = ::ROM::EMPTY_HASH)
+        mod = ::ROM.plugin_registry.schemas.adapter(adapter).fetch(plugin)
+        app_plugin(mod, options)
+      end
+
+      # @api private
+      def app_plugin(plugin, options = ::ROM::EMPTY_HASH)
+        plugin_name = ::ROM.plugin_registry.schemas.adapter(adapter).plugin_name(plugin)
+        plugin.extend_dsl(self)
+        @plugins[plugin_name] = [plugin, plugin.config.to_hash.merge(options)]
+      end
+
+      # @api private
+      def call(&block)
+        instance_exec(&block) if block
+        instance_exec(&definition) if definition
+
+        schema_class.define(relation, opts) do |schema|
+          plugins.values.each { |(plugin, options)|
+            plugin.apply_to(schema, options)
+          }
+        end
+      end
+
+      # @api private
+      def plugin_options(plugin)
+        @plugins[plugin][1]
+      end
+
+      private
+
+      # Return schema opts
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def opts
+        opts = { attributes: attributes.values, inferrer: inferrer, attr_class: attr_class }
+
+        if associations_dsl
+          { **opts, associations: associations_dsl.call }
+        else
+          opts
+        end
+      end
+    end
+  end
+end

data/lib/rom/schema/inferrer.rb

@@ -0,0 +1,66 @@
+require 'dry/core/class_attributes'
+
+module ROM
+  class Schema
+    # @api private
+    class Inferrer
+      extend Dry::Core::ClassAttributes
+      extend Initializer
+
+      defines :attributes_inferrer, :attr_class
+
+      MissingAttributesError = Class.new(StandardError) do
+        def initialize(name, attributes)
+          super("missing attributes in #{name.inspect} schema: #{attributes.map(&:inspect).join(', ')}")
+        end
+      end
+
+      DEFAULT_ATTRIBUTES = [EMPTY_ARRAY, EMPTY_ARRAY].freeze
+
+      attributes_inferrer -> * { DEFAULT_ATTRIBUTES }
+
+      attr_class Attribute
+
+      include Dry::Equalizer(:options)
+
+      option :attr_class, default: -> { self.class.attr_class }
+
+      option :enabled, default: -> { true }
+
+      alias_method :enabled?, :enabled
+
+      option :attributes_inferrer, default: -> { self.class.attributes_inferrer }
+
+      # @api private
+      def call(schema, gateway)
+        if enabled?
+          inferred, missing = attributes_inferrer.(schema, gateway, options)
+        else
+          inferred, missing = DEFAULT_ATTRIBUTES
+        end
+
+        attributes = merge_attributes(schema.attributes, inferred)
+
+        check_all_attributes_defined(schema, attributes, missing)
+
+        { attributes: attributes }
+      end
+
+      # @api private
+      def check_all_attributes_defined(schema, all_known, not_inferred)
+        not_defined = not_inferred - all_known.map(&:name)
+
+        if not_defined.size > 0
+          raise MissingAttributesError.new(schema.name, not_defined)
+        end
+      end
+
+      # @api private
+      def merge_attributes(defined, inferred)
+        defined_names = defined.map(&:name)
+
+        defined + inferred.reject { |attr| defined_names.include?(attr.name) }
+      end
+    end
+  end
+end

data/lib/rom/schema_plugin.rb

@@ -0,0 +1,27 @@
+require 'rom/plugin_base'
+
+module ROM
+  # @api private
+  class SchemaPlugin < PluginBase
+    include Configurable
+
+    # Apply this plugin to the provided configuration
+    #
+    # @param [ROM::Schema] schema A schema instance for extension
+    # @param [Hash] options Extension options
+    #
+    # @api private
+    def apply_to(schema, options = EMPTY_HASH)
+      mod.apply(schema, options) if mod.respond_to?(:apply)
+    end
+
+    # Extends a DSL instance with a module provided by the plugin
+    #
+    # @param [ROM::Schema::DSL] dsl
+    #
+    # @api private
+    def extend_dsl(dsl)
+      dsl.extend(mod.const_get(:DSL)) if mod.const_defined?(:DSL)
+    end
+  end
+end

data/lib/rom/setup.rb

@@ -0,0 +1,68 @@
+require 'rom/setup/auto_registration'
+
+module ROM
+  class Setup
+    # @return [Array] registered relation subclasses
+    #
+    # @api private
+    attr_reader :relation_classes
+
+    # @return [Array] registered mapper subclasses
+    #
+    # @api private
+    attr_reader :mapper_classes
+
+    # @return [Array] registered command subclasses
+    #
+    # @api private
+    attr_reader :command_classes
+
+    # @api private
+    attr_reader :plugins
+
+    # @api private
+    attr_reader :notifications
+
+    # @api private
+    def initialize(notifications)
+      @relation_classes = []
+      @command_classes = []
+      @mapper_classes = []
+      @plugins = []
+      @notifications = notifications
+    end
+
+    # Relation sub-classes are being registered with this method during setup
+    #
+    # @api private
+    def register_relation(*klasses)
+      klasses.reduce(@relation_classes, :<<)
+    end
+
+    # Mapper sub-classes are being registered with this method during setup
+    #
+    # @api private
+    def register_mapper(*klasses)
+      klasses.reduce(@mapper_classes, :<<)
+    end
+
+    # Command sub-classes are being registered with this method during setup
+    #
+    # @api private
+    def register_command(*klasses)
+      klasses.reduce(@command_classes, :<<)
+    end
+
+    # @api private
+    def register_plugin(plugin)
+      plugins << plugin
+    end
+
+    def auto_registration(directory, options = {})
+      auto_registration = AutoRegistration.new(directory, options)
+      auto_registration.relations.map { |r| register_relation(r) }
+      auto_registration.commands.map { |r| register_command(r) }
+      auto_registration.mappers.map { |r| register_mapper(r) }
+    end
+  end
+end

data/lib/rom/setup/auto_registration.rb

@@ -0,0 +1,74 @@
+require 'pathname'
+
+require 'dry/core/inflector'
+
+require 'rom/types'
+require 'rom/initializer'
+require 'rom/setup/auto_registration_strategies/no_namespace'
+require 'rom/setup/auto_registration_strategies/with_namespace'
+require 'rom/setup/auto_registration_strategies/custom_namespace'
+
+module ROM
+  class AutoRegistration
+    extend Initializer
+
+    NamespaceType = Types::Strict::Bool | Types::Strict::String
+    PathnameType = Types.Constructor(Pathname, &Kernel.method(:Pathname))
+    DEFAULT_MAPPING = {
+      relations: :relations,
+      mappers: :mappers,
+      commands: :commands
+    }.freeze
+
+    param :directory, type: PathnameType
+
+    option :namespace, type: NamespaceType, default: -> { true }
+
+    option :component_dirs, type: Types::Strict::Hash, default: -> { DEFAULT_MAPPING }
+
+    option :globs, default: -> {
+      Hash[
+        component_dirs.map { |component, path|
+          [component, directory.join("#{path}/**/*.rb")]
+        }
+      ]
+    }
+
+    def relations
+      load_entities(:relations)
+    end
+
+    def commands
+      load_entities(:commands)
+    end
+
+    def mappers
+      load_entities(:mappers)
+    end
+
+    private
+
+    def load_entities(entity)
+      Dir[globs[entity]].map do |file|
+        require file
+        klass_name =
+          case namespace
+          when String
+            AutoRegistrationStrategies::CustomNamespace.new(
+              namespace: namespace, file: file, directory: directory
+            ).call
+          when TrueClass
+            AutoRegistrationStrategies::WithNamespace.new(
+              file: file, directory: directory
+            ).call
+          when FalseClass
+            AutoRegistrationStrategies::NoNamespace.new(
+              file: file, directory: directory, entity: component_dirs.fetch(entity)
+            ).call
+          end
+
+        Dry::Core::Inflector.constantize(klass_name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'rom/types'
+require 'rom/initializer'
+
+module ROM
+  module AutoRegistrationStrategies
+    class Base
+      extend Initializer
+
+      PathnameType = Types.Definition(Pathname).constrained(type: Pathname)
+
+      option :file, type: Types::Strict::String
+
+      EXTENSION_REGEX = /\.rb\z/
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'pathname'
+
+require 'dry/core/inflector'
+require 'rom/types'
+require 'rom/setup/auto_registration_strategies/base'
+
+module ROM
+  module AutoRegistrationStrategies
+    class CustomNamespace < Base
+      option :directory, type: PathnameType
+      option :namespace, type: Types::Strict::String
+
+      def call
+        potential = []
+        attempted = []
+
+        path_arr.reverse.each do |dir|
+          const_fragment = potential.unshift(
+            Dry::Core::Inflector.camelize(dir)
+          ).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}::#{Dry::Core::Inflector.camelize(filename)}"`
+        # so we can assume naming convention was not respected in required
+        # file.
+
+        raise NameError, name_error_message(attempted)
+      end
+
+      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
+
+      def filename
+        Pathname(file).basename('.rb')
+      end
+
+      def ns_const
+        @namespace_constant ||= Dry::Core::Inflector.constantize(namespace)
+      end
+
+      def path_arr
+        file_path << filename
+      end
+
+      def file_path
+        File.dirname(file).split("/") - directory.to_s.split("/")
+      end
+    end
+  end
+end