rom 2.0.2 → 5.2.5

data/lib/rom/container.rb

@@ -1,231 +0,0 @@
-require 'rom/relation/loaded'
-require 'rom/commands/graph'
-require 'rom/commands/graph/builder'
-require 'rom/support/publisher'
-
-module ROM
-  # ROM container is an isolated environment with no global state where all
-  # components are registered. Container objects provide access to your
-  # relations, commands and mappers. ROM containers are usually configured and
-  # handled via framework integrations, although it is easy to use them
-  # standalone.
-  #
-  # There are 3 types of container setup:
-  #
-  # * in-line setup - a simple block-based configuration which allows configuring
-  #   all components and gives you back a container instance. This type is suitable
-  #   for small scripts, or in some cases rake tasks
-  # * multi-step setup - this type requires creating a configuration object,
-  #   registering component classes (ie relation classes) and passing the config
-  #   to container builder function. This type is suitable when your environment
-  #   is not typical and you need full control over component registration
-  # * multi-step setup with auto-registration - same as multi-step but allows
-  #   you to configure auto-registration mechanism which will register component
-  #   classes for you, based on dir/file naming conventions. This is the most
-  #   common type of setup that's used by framework integrations
-  #
-  # @example in-line setup
-  #   rom = ROM.container(:sql, 'sqlite::memory') do |config|
-  #     config.default.create_table :users do
-  #       primary_key :id
-  #       column :name, String, null: false
-  #     end
-  #
-  #     config.relation(:users) do
-  #       schema(infer: true)
-  #
-  #       def by_name(name)
-  #         where(name: name)
-  #       end
-  #     end
-  #   end
-  #
-  #   rom.relations[:users].insert(name: "Jane")
-  #
-  #   rom.relations[:users].by_name("Jane").to_a
-  #   # [{:id=>1, :name=>"Jane"}]
-  #
-  # @example multi-step setup with explicit component classes
-  #   config = ROM::Configuration.new(:sql, 'sqlite::memory')
-  #
-  #   config.default.create_table :users do
-  #     primary_key :id
-  #     column :name, String, null: false
-  #   end
-  #
-  #   class Users < ROM::Relation[:sql]
-  #     schema(:users, infer: true)
-  #
-  #     def by_name(name)
-  #       where(name: name)
-  #     end
-  #   end
-  #
-  #   config.register_relation(Users)
-  #
-  #   rom = ROM.container(config)
-  #
-  #   rom.relations[:users].insert(name: "Jane")
-  #
-  #   rom.relations[:users].by_name("Jane").to_a
-  #   # [{:id=>1, :name=>"Jane"}]
-  #
-  #
-  # @example multi-step setup with auto-registration
-  #   config = ROM::Configuration.new(:sql, 'sqlite::memory')
-  #   config.auto_registration('./persistence', namespace: false)
-  #
-  #   config.default.create_table :users do
-  #     primary_key :id
-  #     column :name, String, null: false
-  #   end
-  #
-  #   # ./persistence/relations/users.rb
-  #   class Users < ROM::Relation[:sql]
-  #     schema(infer: true)
-  #
-  #     def by_name(name)
-  #       where(name: name)
-  #     end
-  #   end
-  #
-  #   rom = ROM.container(config)
-  #
-  #   rom.relations[:users].insert(name: "Jane")
-  #
-  #   rom.relations[:users].by_name("Jane").to_a
-  #   # [{:id=>1, :name=>"Jane"}]
-  #
-  # @api public
-  class Container
-    include ROM::Support::Publisher
-    include Dry::Equalizer(:gateways, :relations, :mappers, :commands)
-
-    # @return [Hash] configured gateways
-    #
-    # @api public
-    attr_reader :gateways
-
-    # @return [RelationRegistry] relation registry
-    #
-    # @api public
-    attr_reader :relations
-
-    # @return [Registry] command registry
-    #
-    # @api public
-    attr_reader :commands
-
-    # @return [Registry] mapper registry
-    #
-    # @api public
-    attr_reader :mappers
-
-    # @api private
-    def initialize(gateways, relations, mappers, commands)
-      @gateways = gateways
-      @relations = relations
-      @mappers = mappers
-      @commands = commands
-    end
-
-    # Get relation instance identified by its name
-    #
-    # This method will use a custom mapper if it was configured. ie if you have
-    # a relation called `:users` and a mapper configured for `:users` relation,
-    # then by default this mapper will be used.
-    #
-    # @example
-    #   rom.relation(:users)
-    #   rom.relation(:users).by_name('Jane')
-    #
-    #   # block syntax allows accessing lower-level query DSLs (usage is discouraged though)
-    #   rom.relation { |r| r.restrict(name: 'Jane') }
-    #
-    #   # with mapping
-    #   rom.relation(:users).map_with(:presenter)
-    #
-    #   # using multiple mappers
-    #   rom.relation(:users).page(1).map_with(:presenter, :json_serializer)
-    #
-    # @param [Symbol] name of the relation to load
-    #
-    # @yield [Relation]
-    #
-    # @return [Relation]
-    #
-    # @api public
-    def relation(name, &block)
-      relation =
-        if block
-          yield(relations[name])
-        else
-          relations[name]
-        end
-
-      if mappers.key?(name)
-        relation.with(mappers: mappers[name])
-      else
-        relation
-      end
-    end
-
-    # Returns commands registry for the given relation
-    #
-    # @example
-    #   # plain command without mapping
-    #   rom.command(:users).create
-    #
-    #   # allows auto-mapping using registered mappers
-    #   rom.command(:users).as(:entity)
-    #
-    #   # allows building up a command graph for nested input
-    #   command = rom.command([:users, [:create, [:tasks, [:create]]]])
-    #
-    #   command.call(users: [{ name: 'Jane', tasks: [{ title: 'One' }] }])
-    #
-    # @param [Array,Symbol] options Either graph options or registered command name
-    #
-    # @return [Command, Command::Graph]
-    #
-    # @api public
-    def command(options = nil)
-      case options
-      when Symbol
-        name = options
-        if mappers.key?(name)
-          commands[name].with(mappers: mappers[name])
-        else
-          commands[name]
-        end
-      when Array
-        graph = Commands::Graph.build(commands, options)
-        name = graph.name
-
-        if mappers.key?(name)
-          graph.with(mappers: mappers[name])
-        else
-          graph
-        end
-      when nil
-        Commands::Graph::Builder.new(self)
-      else
-        raise ArgumentError, "#{self.class}#command accepts a symbol or an array"
-      end
-    end
-
-    # Disconnect all gateways
-    #
-    # @example
-    #   rom = ROM.container(:sql, 'sqlite://my_db.sqlite')
-    #   rom.relations[:users].insert(name: "Jane")
-    #   rom.disconnect
-    #
-    # @return [Hash<Symbol=>Gateway>] a hash with disconnected gateways
-    #
-    # @api public
-    def disconnect
-      gateways.each_value(&:disconnect)
-    end
-  end
-end

data/lib/rom/create_container.rb

@@ -1,61 +0,0 @@
-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,70 +0,0 @@
-require 'rom/support/configurable'
-require 'rom/gateway'
-
-module ROM
-  # Core gateway configuration interface
-  #
-  # @api public
-  class Environment
-    include Configurable
-
-    attr_reader :gateways, :gateways_map
-
-    # @api public
-    def initialize(*args)
-      @gateways = {}
-      @gateways_map = {}
-
-      configure_gateways(*args) unless args.empty?
-    end
-
-    private
-
-    def configure_gateways(*args)
-      normalized_gateway_args = normalize_gateway_args(*args)
-      normalized_gateways = normalize_gateways(normalized_gateway_args)
-
-      @gateways, @gateways_map = normalized_gateways.values_at(:gateways, :map)
-
-      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
-
-
-    # @api private
-    def normalize_gateway_args(*args)
-      args.first.is_a?(Hash) ? args.first : {default: args}
-    end
-
-    # Build gateways using the setup interface
-    #
-    # @api private
-    def normalize_gateways(gateways_config)
-      gateways_config.each_with_object({map: {}, gateways: {}}) do |(name, spec), hash|
-        identifier, *args = Array(spec)
-
-        if identifier.is_a?(Gateway)
-          gateway = identifier
-        else
-          gateway = Gateway.setup(identifier, *(args.flatten))
-          hash[:map][gateway] = identifier
-        end
-
-        hash[:gateways][name] = gateway
-      end
-    end
-
-    # @api private
-    def load_config(config, hash)
-      hash.each do |key, value|
-        if value.is_a?(Hash)
-          load_config(config[key], value)
-        else
-          config.send("#{key}=", value)
-        end
-      end
-    end
-  end
-end

data/lib/rom/gateway.rb

@@ -1,154 +0,0 @@
-module ROM
-  # Abstract gateway class
-  #
-  # @api public
-  class Gateway
-    extend ClassMacros
-
-    defines :adapter
-
-    # Return connection object
-    #
-    # @return [Object] type varies depending on the gateway
-    #
-    # @api public
-    attr_reader :connection
-
-    # Setup a gateway
-    #
-    # @overload setup(type, *args)
-    #   Sets up a single-gateway given a gateway type.
-    #   For custom gateways, create an instance and pass it directly.
-    #
-    #   @param [Symbol] type
-    #   @param [Array] *args
-    #
-    # @overload setup(gateway)
-    #   @param [Gateway] gateway
-    #
-    # @return [Gateway] a specific gateway subclass
-    #
-    # @example
-    #   module SuperDB
-    #     class Gateway < ROM::Gateway
-    #       def initialize(options)
-    #       end
-    #     end
-    #   end
-    #
-    #   ROM.register_adapter(:super_db, SuperDB)
-    #
-    #   Gateway.setup(:super_db, some: 'options')
-    #   # SuperDB::Gateway.new(some: 'options') is called
-    #
-    #   # or alternatively
-    #   super_db = Gateway.setup(SuperDB::Gateway.new(some: 'options'))
-    #   Gateway.setup(super_db)
-    #
-    # @api public
-    def self.setup(gateway_or_scheme, *args)
-      case gateway_or_scheme
-      when String
-        raise ArgumentError, <<-STRING.gsub(/^ {10}/, '')
-          URIs without an explicit scheme are not supported anymore.
-          See https://github.com/rom-rb/rom/blob/master/CHANGELOG.md
-        STRING
-      when Symbol
-        klass = class_from_symbol(gateway_or_scheme)
-
-        if klass.instance_method(:initialize).arity == 0
-          klass.new
-        else
-          klass.new(*args)
-        end
-      else
-        if args.empty?
-          gateway_or_scheme
-        else
-          raise ArgumentError, "Can't accept arguments when passing an instance"
-        end
-      end
-    end
-
-    # Get gateway subclass for a specific adapter
-    #
-    # @param [Symbol] type adapter identifier
-    #
-    # @return [Class]
-    #
-    # @api private
-    def self.class_from_symbol(type)
-      adapter = ROM.adapters.fetch(type) {
-        begin
-          require "rom/#{type}"
-        rescue LoadError
-          raise AdapterLoadError, "Failed to load adapter rom/#{type}"
-        end
-
-        ROM.adapters.fetch(type)
-      }
-
-      if adapter.const_defined?(:Gateway)
-        adapter.const_get(:Gateway)
-      else
-        adapter.const_get(:Repository)
-      end
-    end
-
-    # Returns the adapter, defined for the class
-    #
-    # @return [Symbol]
-    #
-    # @api public
-    def adapter
-      self.class.adapter || raise(
-        MissingAdapterIdentifierError,
-        "gateway class +#{self}+ is missing the adapter identifier"
-      )
-    end
-
-    # A generic interface for setting up a logger
-    #
-    # @api public
-    def use_logger(*)
-      # noop
-    end
-
-    # A generic interface for returning default logger
-    #
-    # @api public
-    def logger
-      # noop
-    end
-
-    # Extension hook for adding gateway-specific behavior to a command class
-    #
-    # @param [Class] klass command class
-    # @param [Object] _dataset dataset that will be used with this command class
-    #
-    # @return [Class]
-    #
-    # @api public
-    def extend_command_class(klass, _dataset)
-      klass
-    end
-
-    # Schema inference hook
-    #
-    # Every gateway that supports schema inference should implement this method
-    #
-    # @return [Array] array with datasets and their names
-    #
-    # @api private
-    def schema
-      []
-    end
-
-    # Disconnect is optional and it's a no-op by default
-    #
-    # @api public
-    def disconnect
-      # noop
-    end
-  end
-end

data/lib/rom/global/plugin_dsl.rb

@@ -1,49 +0,0 @@
-require 'rom/support/constants'
-
-module ROM
-  module Global
-    # plugin registration DSL
-    #
-    # @private
-    class PluginDSL
-      # Default options passed to plugin registration
-      #
-      # @return [Hash]
-      #
-      # @api private
-      attr_reader :defaults
-
-      # Plugin registry
-      #
-      # @return [PluginRegistry]
-      #
-      # @api private
-      attr_reader :registry
-
-      # @api private
-      def initialize(registry, defaults = EMPTY_HASH, &block)
-        @registry = registry
-        @defaults = defaults
-        instance_exec(&block)
-      end
-
-      # Register a plugin
-      #
-      # @param [Symbol] name of the plugin
-      # @param [Module] mod to include
-      # @param [Hash] options
-      #
-      # @api public
-      def register(name, mod, options = EMPTY_HASH)
-        registry.register(name, mod, defaults.merge(options))
-      end
-
-      # Register plugins for a specific adapter
-      #
-      # @param [Symbol] adapter type
-      def adapter(type, &block)
-        self.class.new(registry, adapter: type, &block)
-      end
-    end
-  end
-end

data/lib/rom/global.rb

@@ -1,60 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'rom/plugin_registry'
-require 'rom/global/plugin_dsl'
-require 'rom/support/deprecations'
-
-module ROM
-  # Globally accessible public interface exposed via ROM module
-  #
-  # @api public
-  module Global
-    # Set base global registries in ROM constant
-    #
-    # @api private
-    def self.extended(rom)
-      super
-
-      rom.instance_variable_set('@adapters', {})
-      rom.instance_variable_set('@plugin_registry', PluginRegistry.new)
-    end
-
-    # An internal adapter identifier => adapter module map used by setup
-    #
-    # @return [Hash<Symbol=>Module>]
-    #
-    # @api private
-    attr_reader :adapters
-
-    # An internal identifier => plugin map used by the setup
-    #
-    # @return [Hash]
-    #
-    # @api private
-    attr_reader :plugin_registry
-
-    # Global plugin setup DSL
-    #
-    # @example
-    #   ROM.plugins do
-    #     register :publisher, Plugin::Publisher, type: :command
-    #   end
-    #
-    # @example
-    def plugins(*args, &block)
-      PluginDSL.new(plugin_registry, *args, &block)
-    end
-
-    # Register adapter namespace under a specified identifier
-    #
-    # @param [Symbol] identifier
-    # @param [Class,Module] adapter
-    #
-    # @return [self]
-    #
-    # @api private
-    def register_adapter(identifier, adapter)
-      adapters[identifier] = adapter
-      self
-    end
-  end
-end

data/lib/rom/lint/enumerable_dataset.rb

@@ -1,54 +0,0 @@
-require 'rom/lint/linter'
-
-module ROM
-  module Lint
-    # Ensures that a [ROM::EnumerableDataset] extension correctly yields
-    # arrays and tuples
-    #
-    # @api public
-    class EnumerableDataset < ROM::Lint::Linter
-      # The linted subject
-      #
-      # @api public
-      attr_reader :dataset
-
-      # The expected data
-      #
-      # @api public
-      attr_reader :data
-
-      # Create a linter for EnumerableDataset
-      #
-      # @param [EnumerableDataset] dataset the linted subject
-      # @param [Object] data the expected data
-      #
-      # @api public
-      def initialize(dataset, data)
-        @dataset = dataset
-        @data = data
-      end
-
-      # Lint: Ensure that +dataset+ yield tuples via +each+
-      #
-      # @api public
-      def lint_each
-        result = []
-        dataset.each do |tuple|
-          result << tuple
-        end
-        return if result == data
-
-        complain "#{dataset.class}#each must yield tuples"
-      end
-
-      # Lint: Ensure that +dataset+'s array equals to expected +data+
-      #
-      # @api public
-      def lint_to_a
-        return if dataset.to_a == data
-
-        complain "#{dataset.class}#to_a must cast dataset to an array"
-      end
-    end
-  end
-end