rom 0.5.0 → 0.6.0.beta1

data/lib/rom/setup/finalize.rb

@@ -1,125 +1,134 @@
-require 'rom/relation_builder'
-require 'rom/reader_builder'
+require 'rom/relation'
+require 'rom/mapper'
+require 'rom/reader'
+require 'rom/command'
+
+require 'rom/support/registry'
 require 'rom/command_registry'
+require 'rom/mapper_registry'
 
 require 'rom/env'
 
 module ROM
   class Setup
+    # This giant builds an environment 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 :repositories, :adapter_relation_map
+      attr_reader :repositories, :repo_adapter, :datasets,
+        :relation_classes, :mapper_classes, :command_classes
 
       # @api private
-      def initialize(repositories, schema, relations, mappers, commands)
+      def initialize(repositories, relation_classes, mapper_classes, command_classes)
         @repositories = repositories
-        @schema = schema
-        @relations = relations
-        @mappers = mappers
-        @commands = commands
-        @adapter_relation_map = {}
+        @repo_adapter_map = ROM.repositories
+        @relation_classes = relation_classes
+        @mapper_classes = mapper_classes
+        @command_classes = command_classes
+        initialize_datasets
       end
 
+      # Return adapter identifier for a given repository object
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      def adapter_for(repository)
+        @repo_adapter_map.fetch(repositories[repository])
+      end
+
+      # Run the finalization process
+      #
+      # This creates relations, mappers and commands
+      #
+      # @return [Env]
+      #
       # @api private
       def run!
-        schema = load_schema
-        relations = load_relations(schema)
+        infer_schema_relations
+
+        relations = load_relations
         readers = load_readers(relations)
         commands = load_commands(relations)
 
-        Env.new(repositories, schema, relations, readers, commands)
+        Env.new(repositories, relations, readers, commands)
       end
 
       private
 
+      # Infer all datasets using configured repositories
+      #
+      # Not all repositories can do that, by default an empty array is returned
+      #
+      # @return [Hash] repository name => array with datasets map
+      #
       # @api private
-      def load_schema
-        repositories.each_value do |repo|
-          (@schema[repo] ||= []).concat(repo.schema)
+      def initialize_datasets
+        @datasets = repositories.each_with_object({}) do |(key, repository), h|
+          h[key] = repository.schema
         end
-
-        base_relations = @schema.each_with_object({}) do |(repo, schema), h|
-          schema.each do |name, dataset, header|
-            adapter_relation_map[name] = repo.adapter
-            h[name] = Relation.new(dataset, header)
-          end
-        end
-
-        Schema.new(base_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(schema)
-        return RelationRegistry.new unless adapter_relation_map.any?
-
-        relations = {}
-        builder = RelationBuilder.new(schema, relations)
-
-        @relations.each do |name, block|
-          relations[name] = build_relation(name, builder, block)
-        end
-
-        (schema.elements.keys - relations.keys).each do |name|
-          relations[name] = build_relation(name, builder)
-        end
-
-        relations.each_value do |relation|
-          relation.class.finalize(relations, relation)
-        end
-
+      def load_relations
+        relations = Relation.registry(repositories, relation_classes)
         RelationRegistry.new(relations)
       end
 
-      # @api private
-      def build_relation(name, builder, block = nil)
-        adapter = adapter_relation_map[name]
-
-        relation = builder.call(name) do |klass|
-          adapter.extend_relation_class(klass)
-          methods = klass.public_instance_methods
-
-          klass.class_eval(&block) if block
-
-          klass.relation_methods = klass.public_instance_methods - methods
-        end
-
-        adapter.extend_relation_instance(relation)
-
-        relation
-      end
-
+      # Build entire reader and mapper registries
+      #
       # @api private
       def load_readers(relations)
-        return ReaderRegistry.new unless adapter_relation_map.any?
+        readers = {}
 
-        reader_builder = ReaderBuilder.new(relations)
+        Mapper.registry(mapper_classes).each do |name, mappers|
+          relation = relations[name]
+          methods = relation.exposed_relations
 
-        readers = @mappers.each_with_object({}) do |(name, options, block), h|
-          h[name] = reader_builder.call(name, options, &block)
+          readers[name] = Reader.build(
+            name, relation, MapperRegistry.new(mappers), methods
+          )
         end
 
         ReaderRegistry.new(readers)
       end
 
+      # Build entire command registries
+      #
+      # This includes both classes created via DSL and explicit definitions
+      #
+      # @api private
       def load_commands(relations)
-        return Registry.new unless relations.elements.any?
-
-        commands = @commands.each_with_object({}) do |(name, definitions), h|
-          adapter = adapter_relation_map[name]
-
-          rel_commands = {}
-
-          definitions.each do |command_name, definition|
-            rel_commands[command_name] = adapter.command(
-              command_name, relations[name], definition
-            )
-          end
+        registry = Command.registry(relations, repositories, 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 repositories we infer a relation
+      #
+      # Relations explicitly defined are being skipped
+      #
+      # @api private
+      def infer_schema_relations
+        datasets.each do |repository, schema|
+          schema.each do |name|
+            next if relation_classes.any? { |klass| klass.dataset == name }
+            klass = Relation.build_class(name, adapter: adapter_for(repository))
+            klass.repository(repository)
+            klass.dataset(name)
+          end
+        end
+      end
     end
   end
 end

data/lib/rom/setup_dsl/command.rb

@@ -0,0 +1,36 @@
+module ROM
+  # Setup DSL-specific command extensions
+  #
+  # @private
+  class Command
+    # Generate a command subclass
+    #
+    # This is used by Setup#commands DSL and its `define` block
+    #
+    # @api private
+    def self.build_class(name, relation, options = {}, &block)
+      type = options.fetch(:type) { name }
+      command_type = Inflector.classify(type)
+      adapter = options.fetch(:adapter)
+      parent = adapter_namespace(adapter).const_get(command_type)
+      class_name = generate_class_name(adapter, command_type, relation)
+
+      ClassBuilder.new(name: class_name, parent: parent).call do |klass|
+        klass.register_as(name)
+        klass.relation(relation)
+        klass.class_eval(&block) if block
+      end
+    end
+
+    # Create a command subclass name based on adapter, type and relation
+    #
+    # @api private
+    def self.generate_class_name(adapter, command_type, relation)
+      pieces = ['ROM']
+      pieces << Inflector.classify(adapter)
+      pieces << 'Commands'
+      pieces << "#{command_type}[#{Inflector.classify(relation)}s]"
+      pieces.join('::')
+    end
+  end
+end

data/lib/rom/setup_dsl/command_dsl.rb

@@ -0,0 +1,34 @@
+require 'rom/setup_dsl/command'
+
+module ROM
+  class Setup
+    # Command `define` DSL used by Setup#commands
+    #
+    # @private
+    class CommandDSL
+      attr_reader :relation, :adapter
+
+      # @api private
+      def initialize(relation, adapter = nil, &block)
+        @relation = relation
+        @adapter = adapter
+        instance_exec(&block)
+      end
+
+      # Define a command class
+      #
+      # @param [Symbol] name of the command
+      # @param [Hash] options
+      # @option options [Symbol] :type The type of the command
+      #
+      # @return [Class] generated class
+      #
+      # @api public
+      def define(name, options = {}, &block)
+        Command.build_class(
+          name, relation, { adapter: adapter }.merge(options), &block
+        )
+      end
+    end
+  end
+end

data/lib/rom/setup_dsl/mapper.rb

@@ -0,0 +1,32 @@
+module ROM
+  # Setup DSL-specific mapper extensions
+  #
+  # @private
+  class Mapper
+    # Generate a mapper subclass
+    #
+    # This is used by Setup#mappers DSL
+    #
+    # @api private
+    def self.build_class(name, options = {}, &block)
+      class_name = "ROM::Mapper[#{name}]"
+
+      parent = options[:parent]
+      inherit_header = options.fetch(:inherit_header) { Mapper.inherit_header }
+
+      parent_class =
+        if parent
+          ROM.boot.mapper_classes.detect { |klass| klass.relation == parent }
+        else
+          self
+        end
+
+      ClassBuilder.new(name: class_name, parent: parent_class).call do |klass|
+        klass.relation(name)
+        klass.inherit_header(inherit_header)
+
+        klass.class_eval(&block) if block
+      end
+    end
+  end
+end

data/lib/rom/setup_dsl/mapper_dsl.rb

@@ -0,0 +1,30 @@
+require 'rom/setup_dsl/mapper'
+
+module ROM
+  class Setup
+    # Mapper definition DSL used by Setup DSL
+    #
+    # @private
+    class MapperDSL
+      attr_reader :mappers
+
+      # @api private
+      def initialize(&block)
+        instance_exec(&block)
+      end
+
+      # Define a mapper class
+      #
+      # @param [Symbol] name of the mapper
+      # @param [Hash] options
+      #
+      # @return [Class]
+      #
+      # @api public
+      def define(name, options = {}, &block)
+        Mapper.build_class(name, options, &block)
+        self
+      end
+    end
+  end
+end

data/lib/rom/setup_dsl/relation.rb

@@ -0,0 +1,21 @@
+module ROM
+  # Setup DSL-specific relation extensions
+  #
+  # @private
+  class Relation
+    # Generate a relation subclass
+    #
+    # This is used by Setup#relation DSL
+    #
+    # @api private
+    def self.build_class(name, options = {})
+      class_name = "ROM::Relation[#{Inflector.camelize(name)}]"
+      adapter = options.fetch(:adapter)
+
+      ClassBuilder.new(name: class_name, parent: self[adapter]).call do |klass|
+        klass.repository(options.fetch(:repository) { :default })
+        klass.dataset(name)
+      end
+    end
+  end
+end

data/lib/rom/setup_dsl/setup.rb

@@ -0,0 +1,75 @@
+require 'rom/setup_dsl/relation'
+
+require 'rom/setup_dsl/mapper_dsl'
+require 'rom/setup_dsl/command_dsl'
+
+module ROM
+  # This extends Setup class with the DSL methods
+  #
+  # @api public
+  class Setup
+    # Relation definition DSL
+    #
+    # @example
+    #
+    #   setup.relation(:users) do
+    #     def names
+    #       project(:name)
+    #     end
+    #   end
+    #
+    # @api public
+    def relation(name, options = {}, &block)
+      klass_opts = { adapter: default_adapter }.merge(options)
+      klass = Relation.build_class(name, klass_opts)
+      klass.class_eval(&block) if block
+      klass
+    end
+
+    # Mapper definition DSL
+    #
+    # @example
+    #
+    #   setup.mappers do
+    #     define(:users) do
+    #       model name: 'User'
+    #     end
+    #
+    #     define(:names, parent: :users) do
+    #       exclude :id
+    #     end
+    #   end
+    #
+    # @api public
+    def mappers(&block)
+      MapperDSL.new(&block)
+    end
+
+    # Command definition DSL
+    #
+    # @example
+    #
+    #   setup.commands(:users) do
+    #     define(:create) do
+    #       input NewUserParams
+    #       validator NewUserValidator
+    #       result :one
+    #     end
+    #
+    #     define(:update) do
+    #       input UserParams
+    #       validator UserValidator
+    #       result :many
+    #     end
+    #
+    #     define(:delete) do
+    #       result :many
+    #     end
+    #   end
+    #
+    # @api public
+    def commands(name, &block)
+      CommandDSL.new(name, default_adapter, &block)
+    end
+  end
+end