rom 0.9.1 → 1.0.0.beta1

data/lib/rom/constants.rb

@@ -15,23 +15,16 @@ module ROM
   RelationAlreadyDefinedError = Class.new(StandardError)
   NoRelationError = Class.new(StandardError)
   CommandError = Class.new(StandardError)
+  KeyMissing = Class.new(ROM::CommandError)
   TupleCountMismatchError = Class.new(CommandError)
   MapperMissingError = Class.new(StandardError)
   UnknownPluginError = Class.new(StandardError)
   UnsupportedRelationError = Class.new(StandardError)
+  MissingAdapterIdentifierError = Class.new(StandardError)
+
+  DuplicateConfigurationError = Class.new(StandardError)
+  DuplicateContainerError = Class.new(StandardError)  
 
   InvalidOptionValueError = Class.new(StandardError)
   InvalidOptionKeyError = Class.new(StandardError)
-
-  class CommandFailure < StandardError
-    attr_reader :command
-    attr_reader :original_error
-
-    def initialize(command, err)
-      super("command: #{command.inspect}; original message: #{err.message}")
-      @command = command
-      @original_error = err
-      set_backtrace(err.backtrace)
-    end
-  end
 end

data/lib/rom/container.rb

@@ -1,22 +1,21 @@
 require 'rom/relation/loaded'
 require 'rom/commands/graph'
-require 'rom/support/deprecations'
+require 'rom/commands/graph/builder'
+require 'rom/support/publisher'
 
 module ROM
   # Exposes defined gateways, relations and mappers
   #
   # @api public
   class Container
-    extend Deprecations
-    include Equalizer.new(:gateways, :relations, :mappers, :commands)
+    include ROM::Support::Publisher
+    include Dry::Equalizer(:gateways, :relations, :mappers, :commands)
 
     # @return [Hash] configured gateways
     #
     # @api public
     attr_reader :gateways
 
-    deprecate :repositories, :gateways
-
     # @return [RelationRegistry] relation registry
     #
     # @api private
@@ -38,7 +37,6 @@ module ROM
       @relations = relations
       @mappers = mappers
       @commands = commands
-      freeze
     end
 
     # Get lazy relation identified by its name
@@ -77,7 +75,6 @@ module ROM
         relation
       end
     end
-    deprecate :read, :relation, "For mapping append `.map_with(:your_mapper_name)`"
 
     # Returns commands registry for the given relation
     #
@@ -99,7 +96,7 @@ module ROM
     # @return [Command, Command::Graph]
     #
     # @api public
-    def command(options)
+    def command(options = nil)
       case options
       when Symbol
         name = options
@@ -117,9 +114,15 @@ module ROM
         else
           graph
         end
+      when nil
+        Commands::Graph::Builder.new(self)
       else
         raise ArgumentError, "#{self.class}#command accepts a symbol or an array"
       end
     end
+    
+    def disconnect
+      gateways.each_key(&:disconnect)
+    end
   end
 end

data/lib/rom/create_container.rb

@@ -0,0 +1,61 @@
+require 'rom/configuration'
+require 'rom/environment'
+require 'rom/setup'
+require 'rom/setup/finalize'
+
+module ROM
+  class CreateContainer
+    include ROM::Support::Publisher
+
+    attr_reader :container
+
+    def initialize(environment, setup)
+      @container = finalize(environment, setup)
+    end
+
+    private
+
+    def finalize(environment, setup)
+      environment.configure do |config|
+        environment.gateways.each_key do |key|
+          gateway_config = config.gateways[key]
+          gateway_config.infer_relations = true unless gateway_config.key?(:infer_relations)
+        end
+      end
+
+      finalize = Finalize.new(
+        gateways: environment.gateways,
+        gateway_map: environment.gateways_map,
+        relation_classes: setup.relation_classes,
+        command_classes: setup.command_classes,
+        mappers: setup.mapper_classes,
+        config: environment.config.dup.freeze
+      )
+
+      finalize.run!
+    end
+  end
+
+  class InlineCreateContainer < CreateContainer
+    def initialize(*args, &block)
+      case args.first
+      when Configuration
+        environment = args.first.environment
+        setup = args.first.setup
+      when Environment
+        environment = args.first
+        setup = args[1]
+      else
+        configuration = Configuration.new(*args, &block)
+        environment = configuration.environment
+        setup = configuration.setup
+      end
+
+      super(environment, setup)
+    end
+  end
+
+  def self.container(*args, &block)
+    InlineCreateContainer.new(*args, &block).container
+  end
+end

data/lib/rom/environment.rb

@@ -1,272 +1,58 @@
-require 'rom/setup'
-require 'rom/repository'
+require 'rom/support/configurable'
+require 'rom/gateway'
 
 module ROM
-  # Globally accessible public interface exposed via ROM module
+  # Core gateway configuration interface
   #
   # @api public
   class Environment
-    # An internal gateway => identifier map used by the setup
-    #
-    # @return [Hash]
-    #
-    # @api private
-    attr_reader :gateways
+    include Configurable
 
-    # Setup object created during setup phase
-    #
-    # This gets set to nil after setup is finalized
-    #
-    # @return [Setup]
-    #
-    # @api private
-    attr_reader :boot
+    attr_reader :gateways, :gateways_map
 
-    # Return ROM container configured by the setup
-    #
-    # @return [Container]
-    #
     # @api public
-    attr_reader :container
-    alias_method :env, :container
-
-    # @api private
-    def initialize
+    def initialize(*args)
       @gateways = {}
-    end
-
-    # @api private
-    def adapters
-      ROM.adapters
-    end
+      @gateways_map = {}
 
-    # @api private
-    def plugin_registry
-      ROM.plugin_registry
+      configure_gateways(*args) unless args.empty?
     end
 
-    # Apply a plugin to the environment
-    #
-    # @param [Mixed] The plugin identifier, usually a Symbol
-    # @param [Hash] Plugin options
-    #
-    # @api public
-    def use(plugin, options = {})
-      plugin_registry.environment.fetch(plugin).apply_to(self, options)
-    end
-
-    # Starts the setup process for relations, mappers and commands.
-    #
-    # @overload setup(type, *args)
-    #   Sets up a single-gateway environment given a gateway type provided
-    #   under the ROM umbrella. For custom gateways, create an instance and
-    #   pass it directly.
-    #
-    #   @param [Symbol] type
-    #   @param [Array] *args
-    #
-    # @overload setup(gateway)
-    #   @param [Gateway] gateway
-    #
-    # @overload setup(gateways)
-    #   Sets up multiple gateways.
-    #
-    #   @param [Hash{Symbol=>Symbol,Array}] gateways
-    #
-    # @return [Setup] boot object
-    #
-    # @example
-    #   # Use the in-memory adapter shipped with ROM as the default gateway.
-    #   rom = ROM::Environment.new
-    #   env = rom.setup(:memory, 'memory://test')
-    #   # Use `rom-sql` with an in-memory sqlite database as default gateway.
-    #   rom.setup(:sql, 'sqlite::memory')
-    #   # Registers a `default` and a `warehouse` gateway.
-    #   env = rom.setup(
-    #     default: [:sql, 'sqlite::memory'],
-    #     warehouse: [:sql, 'postgres://localhost/warehouse']
-    #   )
-    #
-    # @example A full environment
-    #
-    #   rom = ROM::Environment.new
-    #   rom.setup(:memory, 'memory://test')
-    #
-    #   rom.relation(:users) do
-    #     # ...
-    #   end
-    #
-    #   rom.mappers do
-    #     define(:users) do
-    #       # ...
-    #     end
-    #   end
-    #
-    #   rom.commands(:users) do
-    #     define(:create) do
-    #       # ...
-    #     end
-    #   end
-    #
-    #   rom.finalize # builds the container
-    #   rom.container # returns the container registry
-    #
-    # @api public
-    def setup(*args, &block)
-      config = setup_config(*args)
-      configured_gateways = setup_gateways(config)
-
-      default_adapter = gateways.fetch(
-        configured_gateways[:default], adapters.keys.first
-      )
+    private
 
-      @boot = Setup.new(configured_gateways,
-        gateway_map: gateways,
-        default_adapter: default_adapter
-      )
+    def configure_gateways(*args)
+      normalized_gateway_args = normalize_gateway_args(*args)
+      normalized_gateways = normalize_gateways(normalized_gateway_args)
 
-      config.each do |name, config_args|
-        options = config_args.is_a?(Array) && config_args.last
-        load_config(@boot.config.gateways[name], options) if options.is_a?(Hash)
-      end
+      @gateways, @gateways_map = normalized_gateways.values_at(:gateways, :map)
 
-      if block
-        use :auto_registration unless auto_registration?
-        @boot.instance_exec(&block)
-        finalize.container
-      else
-        @boot
+      normalized_gateway_args.each_with_object(config) do |(name, gateway_config), config|
+        options = gateway_config.is_a?(Array) && gateway_config.last
+        load_config(config.gateways[name], options) if options.is_a?(Hash)
       end
     end
 
-    # Check if auto-registration is enabled for this environment
-    #
-    # @api private
-    def auto_registration?
-      false
-    end
-
-    # Global relation setup DSL
-    #
-    # @example
-    #   rom = ROM::Environment.new
-    #   rom.setup(:memory)
-    #
-    #   rom.relation(:users) do
-    #     def by_name(name)
-    #       restrict(name: name)
-    #     end
-    #   end
-    #
-    # @api public
-    def relation(*args, &block)
-      boot.relation(*args, &block)
-    end
-
-    # Global commands setup DSL
-    #
-    # @example
-    #   rom = ROM::Environment.new
-    #   rom.setup(:memory)
-    #
-    #   rom.commands(:users) do
-    #     define(:create) do
-    #       # ..
-    #     end
-    #   end
-    #
-    # @api public
-    def commands(*args, &block)
-      boot.commands(*args, &block)
-    end
-
-    # Global mapper setup DSL
-    #
-    # @example
-    #   rom = ROM::Environment.new
-    #   rom.setup(:memory)
-    #
-    #   rom.mappers do
-    #     define(:uses) do
-    #       # ..
-    #     end
-    #   end
-    #
-    # @api public
-    def mappers(*args, &block)
-      boot.mappers(*args, &block)
-    end
-
-    # Finalize the setup and store default global container under
-    # ROM::Environmrnt#container
-    #
-    # @example
-    #   rom = ROM::Environment.new
-    #   rom.setup(:memory)
-    #   rom.finalize # => rom
-    #   rom.boot # => nil
-    #   rom.container # => the container
-    #
-    # @return [ROM]
-    #
-    # @api public
-    def finalize
-      @container = boot.finalize
-      self
-    ensure
-      @boot = nil
-    end
-
-    # Relation subclass registration during setup phase
-    #
-    # @api private
-    def register_relation(klass)
-      boot.register_relation(klass) if boot
-    end
-
-    # Mapper subclass registration during setup phase
-    #
-    # @api private
-    def register_mapper(klass)
-      boot.register_mapper(klass) if boot
-    end
-
-    # Command subclass registration during setup phase
-    #
-    # @api private
-    def register_command(klass)
-      boot.register_command(klass) if boot
-    end
-
-    # Return gateway config that was used to setup this environment's container
-    #
-    # @return [Configurable::Config]
-    #
-    # @api public
-    def config
-      boot.config
-    end
 
-    private
-
-    # Helper method to handle single- or multi-repo setup options
-    #
     # @api private
-    def setup_config(*args)
-      args.first.is_a?(Hash) ? args.first : { default: args }
+    def normalize_gateway_args(*args)
+      args.first.is_a?(Hash) ? args.first : {default: args}
     end
 
     # Build gateways using the setup interface
     #
     # @api private
-    def setup_gateways(config)
-      config.each_with_object({}) do |(name, spec), hash|
+    def normalize_gateways(gateways_config)
+      gateways_config.each_with_object({map: {}, gateways: {}}) do |(name, spec), hash|
         identifier, *args = Array(spec)
 
-        gateway = Gateway.setup(identifier, *(args.flatten))
-        hash[name] = gateway
+        if identifier.is_a?(Gateway)
+          gateway = identifier
+        else
+          gateway = Gateway.setup(identifier, *(args.flatten))
+          hash[:map][gateway] = identifier
+        end
 
-        gateways[gateway] = identifier unless identifier.is_a?(Gateway)
+        hash[:gateways][name] = gateway
       end
     end