rom 0.9.1 → 1.0.0.beta1

data/lib/rom/relation/class_interface.rb

@@ -16,9 +16,13 @@ module ROM
         super
 
         klass.extend ClassMacros
-        klass.extend Deprecations
         klass.defines :adapter
 
+        if respond_to?(:adapter) && adapter.nil?
+          raise MissingAdapterIdentifierError,
+            "relation class +#{self}+ is missing the adapter identifier"
+        end
+
         # Extend with functionality required by adapters *only* if this is a direct
         # descendant of an adapter-specific relation subclass
         return unless respond_to?(:adapter) && klass.superclass == ROM::Relation[adapter]
@@ -26,10 +30,7 @@ module ROM
         klass.class_eval do
           use :registry_reader
 
-          defines :gateway, :dataset, :register_as
-
-          deprecate_class_method :repository, :gateway
-          deprecate :repository, :gateway
+          defines :gateway, :dataset, :dataset_proc, :register_as
 
           gateway :default
 
@@ -44,6 +45,29 @@ module ROM
           # @api public
           attr_reader :name
 
+          # Set dataset name
+          #
+          # If a block is passed it will be evaluated in the context of the dataset
+          # to define the default dataset which will be injected into a relation
+          # when setting up relation registry
+          #
+          # @example
+          #   class Relations::Users < ROM::Relation[:memory]
+          #     dataset :users
+          #   end
+          #
+          #   class Users < ROM::Relation[:memory]
+          #     dataset { sort_by(:id) }
+          #   end
+          #
+          # @param [Symbol] value The name of the dataset
+          #
+          # @api public
+          def self.dataset(value = Undefined, &block)
+            dataset_proc(block) if block
+            super
+          end
+
           # Set or get name under which a relation will be registered
           #
           # This defaults to `dataset` or `default_name` for descendant relations
@@ -65,12 +89,6 @@ module ROM
             end
           end
 
-          # @api public
-          def self.exposed_relations(*args)
-            Deprecations.announce("#{self}.exposed_relations", 'this method has no effect anymore')
-            Set.new
-          end
-
           # @api private
           def initialize(dataset, options = EMPTY_HASH)
             @name = self.class.dataset
@@ -142,51 +160,20 @@ module ROM
       # @api private
       def default_name
         return unless name
-        Inflector.underscore(name).gsub('/', '_').to_sym
+        Inflector.underscore(name).tr('/', '_').to_sym
       end
 
-      # Build relation registry of specified descendant classes
-      #
-      # This is used by the setup
-      #
-      # @param [Hash] gateways
-      # @param [Array] descendants a list of relation descendants
-      #
-      # @return [Hash]
-      #
       # @api private
-      def registry(gateways, descendants)
-        registry = {}
-
-        descendants.each do |klass|
-          # 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)
-          dataset = gateway.dataset(klass.dataset)
-
-          relation = klass.new(dataset, __registry__: registry)
-
-          name = klass.register_as
-
-          if registry.key?(name)
-            raise RelationAlreadyDefinedError,
-              "Relation with `register_as #{name.inspect}` registered more " \
-              "than once"
-          end
-
-          registry[name] = relation
-        end
-
-        registry.each_value do |relation|
-          relation.class.finalize(registry, relation)
-        end
-
-        registry
+      def curried
+        Curried
       end
 
       # @api private
-      def curried
-        Curried
+      def view_methods
+        ancestor_methods = ancestors.reject { |klass| klass == self }
+          .map(&:instance_methods).flatten
+
+        instance_methods - ancestor_methods
       end
 
       # Hook to finalize a relation after its instance was created

data/lib/rom/setup.rb

@@ -1,38 +1,7 @@
-require 'rom/support/configurable'
-
-require 'rom/setup/finalize'
-require 'rom/support/deprecations'
+require 'rom/setup/auto_registration'
 
 module ROM
-  # Exposes DSL for defining relations, mappers and commands
-  #
-  # @api public
   class Setup
-    include Configurable
-
-    extend Deprecations
-    include Equalizer.new(:gateways, :container)
-
-    # @return [Hash] configured gateways
-    #
-    # @api private
-    attr_reader :gateways
-
-    # @attr_reader [Hash<Gateway=>Symbol>] gateway_map Environment gateway map
-    #
-    # @api private
-    attr_reader :gateway_map
-
-    # Deprecated accessor for gateways.
-    #
-    # @see gateways
-    deprecate :repositories, :gateways
-
-    # @return [Symbol] default (first) adapter
-    #
-    # @api private
-    attr_reader :default_adapter
-
     # @return [Array] registered relation subclasses
     #
     # @api private
@@ -48,99 +17,39 @@ module ROM
     # @api private
     attr_reader :command_classes
 
-    # @return [Conainer] finalized container after setup phase is over
-    #
-    # @api private
-    attr_reader :container
-    alias_method :env, :container
-
     # @api private
-    def initialize(gateways, options = {})
-      @gateways = gateways
-
-      @gateway_map = options.fetch(:gateway_map, {})
-      @default_adapter = options.fetch(:default_adapter, nil)
-
+    def initialize
       @relation_classes = []
       @command_classes = []
       @mapper_classes = []
-      @container = nil
-    end
-
-    # Finalize the setup
-    #
-    # @return [Container] frozen container with access to gateways,
-    #                relations, mappers and commands
-    #
-    # @api public
-    def finalize
-      raise EnvAlreadyFinalizedError if container
-
-      # initialize default configs for all gateways
-      gateways.each_key do |key|
-        gateway_config = config.gateways[key]
-
-        gateway_config.infer_relations = true unless gateway_config.key?(:infer_relations)
-      end
-
-      finalize = Finalize.new(
-        gateways: gateways,
-        gateway_map: gateway_map,
-        relation_classes: relation_classes,
-        command_classes: command_classes,
-        mappers: mapper_classes,
-        config: config.freeze
-      )
-
-      @container = finalize.run!
-    end
-
-    # Return gateway identified by name
-    #
-    # @return [Gateway]
-    #
-    # @api private
-    def [](name)
-      gateways.fetch(name)
     end
 
     # Relation sub-classes are being registered with this method during setup
     #
     # @api private
-    def register_relation(klass)
-      @relation_classes << klass
+    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(klass)
-      @mapper_classes << klass
+    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(klass)
-      @command_classes << klass
-    end
-
-    # Hook for respond_to? used internally
-    #
-    # @api private
-    def respond_to_missing?(name, _include_context = false)
-      gateways.key?(name)
+    def register_command(*klasses)
+      klasses.reduce(@command_classes, :<<)
     end
 
-    private
-
-    # Returns gateway if method is a name of a registered gateway
-    #
-    # @return [Gateway]
-    #
-    # @api private
-    def method_missing(name, *)
-      gateways.fetch(name) { super }
+    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,55 @@
+require 'pathname'
+
+require 'rom/support/constants'
+require 'rom/support/inflector'
+require 'rom/support/options'
+
+module ROM
+  class AutoRegistration
+    include Options
+
+    option :namespace, reader: true, type: [TrueClass, FalseClass], default: true
+
+    attr_reader :globs, :directory
+
+    def initialize(directory, options = EMPTY_HASH)
+      super
+      @directory = directory
+      @globs = Hash[[:relations, :commands, :mappers].map { |name|
+        [name, Pathname(directory).join("#{name}/**/*.rb")]
+      }]
+    end
+
+    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
+        Inflector.constantize(const_name(entity, file))
+      end
+    end
+
+    def const_name(entity, file)
+      name =
+        if namespace
+          file.gsub("#{directory.dirname}/", '')
+        else
+          file.gsub("#{directory}/#{entity}/", '')
+        end.gsub('.rb', '')
+
+      Inflector.camelize(name)
+    end
+  end
+end

data/lib/rom/setup/finalize.rb

@@ -2,159 +2,145 @@ require 'rom/relation'
 require 'rom/command'
 
 require 'rom/support/registry'
-require 'rom/relation_registry'
 require 'rom/command_registry'
 require 'rom/mapper_registry'
 
 require 'rom/container'
+require 'rom/setup/finalize/commands'
+require 'rom/setup/finalize/relations'
+require 'rom/setup/finalize/mappers'
+
+# temporary
+require 'rom/configuration_dsl/relation'
 
 module ROM
-  class Setup
-    # This giant builds an container using defined classes for core parts of 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, :datasets, :gateway_map,
+      :relation_classes, :mapper_classes, :mapper_objects, :command_classes, :config
+
+    # @api private
+    def initialize(options)
+      @gateways = options.fetch(:gateways)
+      @gateway_map = options.fetch(:gateway_map)
+
+      @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)
+
+      initialize_datasets
+    end
+
+    # Return adapter identifier for a given gateway object
     #
-    # It is used by the setup object after it's done gathering class definitions
+    # @return [Symbol]
     #
-    # @private
-    class Finalize
-      attr_reader :gateways, :repo_adapter, :datasets, :gateway_map,
-        :relation_classes, :mapper_classes, :mapper_objects, :command_classes, :config
-
-      # @api private
-      def initialize(options)
-        @gateways = options.fetch(:gateways)
-        @gateway_map = options.fetch(:gateway_map)
-
-        @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) || {}
+    # @api private
+    def adapter_for(gateway)
+      @gateway_map.fetch(gateways[gateway])
+    end
 
-        @config = options.fetch(:config)
+    # Run the finalization process
+    #
+    # This creates relations, mappers and commands
+    #
+    # @return [Container]
+    #
+    # @api private
+    def run!
+      infer_relations_relations
 
-        initialize_datasets
-      end
+      relations = load_relations
+      mappers = load_mappers
+      commands = load_commands(relations)
 
-      # Return adapter identifier for a given gateway object
-      #
-      # @return [Symbol]
-      #
-      # @api private
-      def adapter_for(gateway)
-        @gateway_map.fetch(gateways[gateway])
-      end
+      container = Container.new(gateways, relations, mappers, commands)
+      container.freeze
+      container
+    end
 
-      # Run the finalization process
-      #
-      # This creates relations, mappers and commands
-      #
-      # @return [Container]
-      #
-      # @api private
-      def run!
-        infer_relations_relations
-
-        relations = load_relations
-        mappers = load_mappers
-        commands = load_commands(relations)
-
-        Container.new(gateways, relations, mappers, commands)
-      end
+    private
 
-      private
-
-      # Infer all datasets using configured gateways
-      #
-      # Not all gateways can do that, by default an empty array is returned
-      #
-      # @return [Hash] gateway name => array with datasets map
-      #
-      # @api private
-      def initialize_datasets
-        @datasets = gateways.each_with_object({}) do |(key, gateway), h|
-          h[key] = gateway.schema if config.gateways[key][:infer_relations]
-        end
+    # Infer all datasets using configured gateways
+    #
+    # Not all gateways can do that, by default an empty array is returned
+    #
+    # @return [Hash] gateway name => array with datasets map
+    #
+    # @api private
+    def initialize_datasets
+      @datasets = gateways.each_with_object({}) do |(key, gateway), h|
+        infer_relations = config.gateways && config.gateways[key] && config.gateways[key][:infer_relations]
+        h[key] = gateway.schema if infer_relations
       end
+    end
 
-      # Build entire relation registry from all known relation subclasses
-      #
-      # This includes both classes created via DSL and explicit definitions
-      #
-      # @api private
-      def load_relations
-        relations = Relation.registry(gateways, relation_classes)
-        RelationRegistry.new(relations)
-      end
+    # Build entire relation registry from all known relation subclasses
+    #
+    # This includes both classes created via DSL and explicit definitions
+    #
+    # @api private
+    def load_relations
+      FinalizeRelations.new(gateways, relation_classes).run!
+    end
 
-      # @api private
-      def load_mappers
-        mapper_registry = Mapper.registry(mapper_classes).each_with_object({})
+    # @api private
+    def load_mappers
+      FinalizeMappers.new(mapper_classes, mapper_objects).run!
+    end
 
-        registry_hash = mapper_registry.each { |(relation, mappers), h|
-          h[relation] = MapperRegistry.new(mappers)
-        }
+    # 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).run!
+    end
 
-        mapper_objects.each do |relation, mappers|
-          if registry_hash.key?(relation)
-            mappers.each { |name, mapper| registry[name] = mapper }
+    # For every dataset infered from gateways we infer a relation
+    #
+    # Relations explicitly defined are being skipped
+    #
+    # @api private
+    def infer_relations_relations
+      datasets.each do |gateway, schema|
+        schema.each do |name|
+          if infer_relation?(gateway, name)
+            klass = ROM::ConfigurationDSL::Relation.build_class(name, adapter: adapter_for(gateway))
+            klass.gateway(gateway)
+            klass.dataset(name)
+            @relation_classes << klass
           else
-            registry_hash[relation] = MapperRegistry.new(mappers)
-          end
-        end
-
-        Registry.new(registry_hash)
-      end
-
-      # Build entire command registries
-      #
-      # This includes both classes created via DSL and explicit definitions
-      #
-      # @api private
-      def load_commands(relations)
-        registry = Command.registry(relations, gateways, command_classes)
-
-        commands = registry.each_with_object({}) do |(name, rel_commands), h|
-          h[name] = CommandRegistry.new(rel_commands)
-        end
-
-        Registry.new(commands)
-      end
-
-      # For every dataset infered from gateways we infer a relation
-      #
-      # Relations explicitly defined are being skipped
-      #
-      # @api private
-      def infer_relations_relations
-        datasets.each do |gateway, schema|
-          schema.each do |name|
-            if infer_relation?(gateway, name)
-              klass = Relation.build_class(name, adapter: adapter_for(gateway))
-              klass.gateway(gateway)
-              klass.dataset(name)
-            else
-              next
-            end
+            next
           end
         end
       end
+    end
 
-      def infer_relation?(gateway, name)
-        inferrable_relations(gateway).include?(name) && relation_classes.none? { |klass|
-          klass.dataset == name
-        }
-      end
+    def infer_relation?(gateway, name)
+      inferrable_relations(gateway).include?(name) && relation_classes.none? { |klass|
+        klass.dataset == name
+      }
+    end
 
-      def inferrable_relations(gateway)
-        gateway_config = config.gateways[gateway]
-        schema = gateways[gateway].schema
+    def inferrable_relations(gateway)
+      gateway_config = config.gateways[gateway]
+      schema = gateways[gateway].schema
 
-        allowed = gateway_config[:inferrable_relations] || schema
-        skipped = gateway_config[:not_inferrable_relations] || []
+      allowed = gateway_config[:inferrable_relations] || schema
+      skipped = gateway_config[:not_inferrable_relations] || []
 
-        schema & allowed - skipped
-      end
+      schema & allowed - skipped
     end
   end
 end