rom-core 4.0.0.beta1

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

@@ -0,0 +1,20 @@
+require 'pathname'
+
+require 'dry/core/inflector'
+require 'rom/types'
+require 'rom/setup/auto_registration_strategies/base'
+
+module ROM
+  module AutoRegistrationStrategies
+    class NoNamespace < Base
+      option :directory, type: PathnameType
+      option :entity, type: Types::Strict::Symbol
+
+      def call
+        Dry::Core::Inflector.camelize(
+          file.sub(/^#{directory}\/#{entity}\//, '').sub(EXTENSION_REGEX, '')
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'pathname'
+
+require 'dry/core/inflector'
+require 'rom/setup/auto_registration_strategies/base'
+
+module ROM
+  module AutoRegistrationStrategies
+    class WithNamespace < Base
+      option :directory, type: PathnameType
+
+      def call
+        Dry::Core::Inflector.camelize(
+          file.sub(/^#{directory.dirname}\//, '').sub(EXTENSION_REGEX, '')
+        )
+      end
+    end
+  end
+end

data/lib/rom/setup/finalize.rb

@@ -0,0 +1,103 @@
+require 'rom/relation'
+require 'rom/command'
+
+require 'rom/registry'
+require 'rom/command_registry'
+require 'rom/mapper_registry'
+
+require 'rom/container'
+require 'rom/setup/finalize/finalize_commands'
+require 'rom/setup/finalize/finalize_relations'
+require 'rom/setup/finalize/finalize_mappers'
+
+# temporary
+require 'rom/configuration_dsl/relation'
+
+module ROM
+  # This giant builds an container using defined classes for core parts of ROM
+  #
+  # It is used by the setup object after it's done gathering class definitions
+  #
+  # @private
+  class Finalize
+    attr_reader :gateways, :repo_adapter,
+                :relation_classes, :mapper_classes, :mapper_objects,
+                :command_classes, :plugins, :config, :notifications
+
+    # @api private
+    def initialize(options)
+      @gateways = options.fetch(:gateways)
+
+      @relation_classes = options.fetch(:relation_classes)
+      @command_classes = options.fetch(:command_classes)
+
+      mappers = options.fetch(:mappers, [])
+      @mapper_classes = mappers.select { |mapper| mapper.is_a?(Class) }
+      @mapper_objects = (mappers - @mapper_classes).reduce(:merge) || {}
+
+      @config = options.fetch(:config)
+      @notifications = options.fetch(:notifications)
+
+      @plugins = options.fetch(:plugins)
+    end
+
+    # Return adapter identifier for a given gateway object
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    def adapter_for(gateway)
+      gateways[gateway].adapter
+    end
+
+    # Run the finalization process
+    #
+    # This creates relations, mappers and commands
+    #
+    # @return [Container]
+    #
+    # @api private
+    def run!
+      mappers = load_mappers
+      relations = load_relations(mappers)
+      commands = load_commands(relations)
+
+      container = Container.new(gateways, relations, mappers, commands)
+      container.freeze
+      container
+    end
+
+    private
+
+    # Build entire relation registry from all known relation subclasses
+    #
+    # This includes both classes created via DSL and explicit definitions
+    #
+    # @api private
+    def load_relations(mappers)
+      global_plugins = plugins.select { |p| p.relation? || p.schema? }
+
+      FinalizeRelations.new(
+        gateways,
+        relation_classes,
+        mappers: mappers,
+        plugins: global_plugins,
+        notifications: notifications
+      ).run!
+    end
+
+    # @api private
+    def load_mappers
+      FinalizeMappers.new(mapper_classes, mapper_objects).run!
+    end
+
+    # Build entire command registries
+    #
+    # This includes both classes created via DSL and explicit definitions
+    #
+    # @api private
+    def load_commands(relations)
+      FinalizeCommands.new(relations, gateways, command_classes, notifications).run!
+    end
+  end
+end

data/lib/rom/setup/finalize/finalize_commands.rb

@@ -0,0 +1,60 @@
+require 'rom/registry'
+require 'rom/command_compiler'
+require 'rom/command_registry'
+
+module ROM
+  class Finalize
+    class FinalizeCommands
+      attr_reader :notifications
+
+      # Build command registry hash for provided relations
+      #
+      # @param [RelationRegistry] relations registry
+      # @param [Hash] gateways
+      # @param [Array] command_classes a list of command subclasses
+      #
+      # @api private
+      def initialize(relations, gateways, command_classes, notifications)
+        @relations = relations
+        @gateways = gateways
+        @command_classes = command_classes
+        @notifications = notifications
+      end
+
+      # @return [Hash]
+      #
+      # @api private
+      def run!
+        commands = @command_classes.map do |klass|
+          relation = @relations[klass.relation]
+          gateway = @gateways[relation.gateway]
+
+          notifications.trigger(
+            'configuration.commands.class.before_build',
+            command: klass, gateway: gateway, dataset: relation.dataset
+          )
+
+          klass.extend_for_relation(relation) if klass.restrictable
+
+          klass.build(relation)
+        end
+
+        registry = Registry.new({})
+        compiler = CommandCompiler.new(@gateways, @relations, registry, notifications)
+
+        @relations.each do |(name, relation)|
+          commands.
+            select { |c| c.relation.name == relation.name }.
+            each { |c| relation.commands.elements[c.class.register_as || c.class.default_name] = c }
+
+          relation.commands.set_compiler(compiler)
+          relation.commands.set_mappers(relation.mappers)
+
+          registry.elements[name] = relation.commands
+        end
+
+        registry
+      end
+    end
+  end
+end

data/lib/rom/setup/finalize/finalize_mappers.rb

@@ -0,0 +1,56 @@
+require 'rom/registry'
+
+module ROM
+  class Finalize
+    class FinalizeMappers
+      attr_reader :mapper_classes, :mapper_objects, :registry_hash
+
+      # @api private
+      def initialize(mapper_classes, mapper_objects)
+        @mapper_classes = mapper_classes
+        @mapper_objects = mapper_objects
+
+        check_duplicate_registered_mappers
+
+        @registry_hash = [@mapper_classes.map(&:base_relation) + @mapper_objects.keys].
+                           flatten.
+                           uniq.
+                           each_with_object({}) { |n, h| h[n] = {} }
+      end
+
+      # @api private
+      def run!
+        mappers = registry_hash.each_with_object({}) do |(relation_name, relation_mappers), h|
+          relation_mappers.update(build_mappers(relation_name))
+
+          if mapper_objects.key?(relation_name)
+            relation_mappers.update(mapper_objects[relation_name])
+          end
+
+          h[relation_name] = MapperRegistry.new(relation_mappers)
+        end
+
+        Registry.new(mappers)
+      end
+
+      private
+
+      def check_duplicate_registered_mappers
+        mappers_register_as = mapper_classes.map(&:register_as).compact
+        mappers_register_as.select { |register_as| mappers_register_as.count(register_as) > 1 }
+          .uniq
+          .each do |duplicated_mappers|
+            raise MapperAlreadyDefinedError,
+                  "Mapper with `register_as #{duplicated_mappers.inspect}` registered more " \
+                  "than once"
+          end
+      end
+
+      def build_mappers(relation_name)
+        mapper_classes.
+          select { |klass| klass.base_relation == relation_name }.
+          each_with_object({}) { |klass, h| h[klass.register_as || klass.relation] = klass.build  }
+      end
+    end
+  end
+end

data/lib/rom/setup/finalize/finalize_relations.rb

@@ -0,0 +1,135 @@
+require 'rom/constants'
+require 'rom/relation_registry'
+require 'rom/mapper_registry'
+
+module ROM
+  class Finalize
+    class FinalizeRelations
+      attr_reader :notifications
+
+      # Build relation registry of specified descendant classes
+      #
+      # This is used by the setup
+      #
+      # @param [Hash] gateways
+      # @param [Array] relation_classes a list of relation descendants
+      #
+      # @api private
+      def initialize(gateways, relation_classes, notifications:, mappers: nil, plugins: EMPTY_ARRAY)
+        @gateways = gateways
+        @relation_classes = relation_classes
+        @mappers = mappers
+        @plugins = plugins
+        @notifications = notifications
+      end
+
+      # @return [Hash]
+      #
+      # @api private
+      def run!
+        relation_registry = RelationRegistry.new do |registry, relations|
+          @relation_classes.each do |klass|
+            unless klass.adapter
+              raise MissingAdapterIdentifierError,
+                    "Relation class +#{klass}+ is missing the adapter identifier"
+            end
+
+            key = klass.relation_name.to_sym
+
+            if registry.key?(key)
+              raise RelationAlreadyDefinedError,
+                    "Relation with name #{key.inspect} registered more than once"
+            end
+
+            klass.use(:registry_reader, relation_names)
+
+            notifications.trigger('configuration.relations.class.ready', relation: klass)
+
+            relations[key] = build_relation(klass, registry)
+          end
+
+          registry.each do |_, relation|
+            notifications.trigger(
+              'configuration.relations.object.registered',
+              relation: relation, registry: registry
+            )
+          end
+        end
+
+        notifications.trigger(
+          'configuration.relations.registry.created', registry: relation_registry
+        )
+
+        relation_registry
+      end
+
+      # @return [ROM::Relation]
+      #
+      # @api private
+      def build_relation(klass, registry)
+        # TODO: raise a meaningful error here and add spec covering the case
+        #       where klass' gateway points to non-existant repo
+        gateway = @gateways.fetch(klass.gateway)
+
+        if klass.schema_proc && !klass.schema
+          plugins = schema_plugins
+
+          resolved_schema = klass.schema_proc.call do
+            plugins.each { |plugin| app_plugin(plugin) }
+          end
+
+          klass.set_schema!(resolved_schema)
+        end
+
+        notifications.trigger(
+          'configuration.relations.schema.allocated',
+          schema: klass.schema, gateway: gateway, registry: registry
+        )
+
+        relation_plugins.each do |plugin|
+          plugin.apply_to(klass)
+        end
+
+        notifications.trigger(
+          'configuration.relations.schema.set',
+          schema: resolved_schema, relation: klass, adapter: klass.adapter
+        )
+
+        schema = klass.schema
+        rel_key = schema.name.to_sym
+        dataset = gateway.dataset(schema.name.dataset).instance_exec(klass, &klass.dataset)
+
+        notifications.trigger(
+          'configuration.relations.dataset.allocated',
+          dataset: dataset, relation: klass, adapter: klass.adapter
+        )
+
+        mappers = @mappers.key?(rel_key) ? @mappers[rel_key] : MapperRegistry.new
+
+        options = { __registry__: registry, mappers: mappers, schema: schema, **plugin_options }
+
+        klass.new(dataset, options)
+      end
+
+      # @api private
+      def plugin_options
+        relation_plugins.map(&:config).map(&:to_hash).reduce(:merge) || EMPTY_HASH
+      end
+
+      # @api private
+      def relation_plugins
+        @plugins.select(&:relation?)
+      end
+
+      # @api private
+      def schema_plugins
+        @plugins.select(&:schema?)
+      end
+
+      # @api private
+      def relation_names
+        @relation_classes.map(&:relation_name).map(&:relation).uniq
+      end
+    end
+  end
+end

data/lib/rom/support/configurable.rb

@@ -0,0 +1,85 @@
+module ROM
+  # @api private
+  module Configurable
+    class Config
+      WRITER_REGEXP = /=$/.freeze
+
+      attr_reader :settings
+
+      # @api private
+      def initialize(settings = {})
+        @settings = settings
+      end
+
+      # @api public
+      def [](name)
+        public_send(name)
+      end
+
+      # @api private
+      def key?(name)
+        settings.key?(name)
+      end
+
+      def to_hash
+        settings
+      end
+
+      # @api private
+      def freeze
+        settings.each_value(&:freeze)
+        super
+      end
+
+      # @api private
+      def respond_to_missing?(_name, _include_private = false)
+        true
+      end
+
+      def dup
+        self.class.new(dup_settings(settings))
+      end
+
+      private
+
+      def dup_settings(settings)
+        settings.each_with_object({}) do |(key, value), new_settings|
+          if value.is_a?(self.class)
+            new_settings[key] = value.dup
+          else
+            new_settings[key] = value
+          end
+        end
+      end
+
+      # @api private
+      def method_missing(meth, *args, &_block)
+        return settings.fetch(meth, nil) if frozen?
+
+        name = meth.to_s
+        key = name.gsub(WRITER_REGEXP, '').to_sym
+
+        if writer?(name)
+          settings[key] = args.first
+        else
+          settings.fetch(key) { settings[key] = self.class.new }
+        end
+      end
+
+      # @api private
+      def writer?(name)
+        !WRITER_REGEXP.match(name).nil?
+      end
+    end
+
+    def config
+      @config ||= Config.new
+    end
+
+    # @api public
+    def configure
+      yield(config)
+      self
+    end
+  end
+end