rom 3.3.3 → 4.0.0.beta1

data/lib/rom/configuration_dsl/mapper.rb

@@ -1,36 +0,0 @@
-require 'dry/core/class_builder'
-
-module ROM
-  module ConfigurationDSL
-    # 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, mapper_registry, options = EMPTY_HASH, &block)
-        class_name = "ROM::Mapper[#{name}]"
-
-        parent = options[:parent]
-        inherit_header = options.fetch(:inherit_header) { ROM::Mapper.inherit_header }
-
-        parent_class =
-          if parent
-            mapper_registry.detect { |klass| klass.relation == parent }
-          else
-            ROM::Mapper
-          end
-
-        Dry::Core::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
-end

data/lib/rom/configuration_dsl/mapper_dsl.rb

@@ -1,43 +0,0 @@
-require 'rom/configuration_dsl/mapper'
-
-module ROM
-  module ConfigurationDSL
-    # Mapper definition DSL used by Setup DSL
-    #
-    # @private
-    class MapperDSL
-      attr_reader :registry, :mapper_classes, :mapper_classes
-
-      # @api private
-      def initialize(registry, mapper_classes, block)
-        @registry = registry
-        @mapper_classes = mapper_classes
-        @defined_mappers = []
-
-        instance_exec(&block)
-
-        @mapper_classes = @defined_mappers
-      end
-
-      # Define a mapper class
-      #
-      # @param [Symbol] name of the mapper
-      # @param [Hash] options
-      #
-      # @return [Class]
-      #
-      # @api public
-      def define(name, options = EMPTY_HASH, &block)
-        @defined_mappers << Mapper.build_class(name, (@mapper_classes + @defined_mappers), options, &block)
-        self
-      end
-
-      # TODO
-      #
-      # @api public
-      def register(relation, mappers)
-        registry.register_mapper(relation => mappers)
-      end
-    end
-  end
-end

data/lib/rom/configuration_dsl/relation.rb

@@ -1,26 +0,0 @@
-require 'dry/core/class_builder'
-require 'dry/core/inflector'
-
-module ROM
-  module ConfigurationDSL
-    # 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 = EMPTY_HASH)
-        class_name = "ROM::Relation[#{Dry::Core::Inflector.camelize(name)}]"
-        adapter = options.fetch(:adapter)
-
-        Dry::Core::ClassBuilder.new(name: class_name, parent: ROM::Relation[adapter]).call do |klass|
-          klass.gateway(options.fetch(:gateway, :default))
-          klass.dataset(name, deprecation: false)
-        end
-      end
-    end
-  end
-end

data/lib/rom/configuration_dsl.rb

@@ -1,107 +0,0 @@
-require 'rom/configuration_dsl/relation'
-require 'rom/configuration_dsl/mapper_dsl'
-require 'rom/configuration_dsl/command_dsl'
-
-module ROM
-  # This extends Configuration class with the DSL methods
-  #
-  # @api public
-  module ConfigurationDSL
-    # Relation definition DSL
-    #
-    # @example
-    #
-    #   setup.relation(:users) do
-    #     def names
-    #       project(:name)
-    #     end
-    #   end
-    #
-    # @api public
-    def relation(name, options = EMPTY_HASH, &block)
-      klass_opts = { adapter: default_adapter }.merge(options)
-      klass = Relation.build_class(name, klass_opts)
-      klass.register_as(name, deprecation: false)
-      klass.class_eval(&block) if block
-      register_relation(klass)
-      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)
-      register_mapper(*MapperDSL.new(self, mapper_classes, block).mapper_classes)
-    end
-
-    # Command definition DSL
-    #
-    # @example
-    #
-    #   setup.commands(:users) do
-    #     define(:create) do
-    #       input NewUserParams
-    #       result :one
-    #     end
-    #
-    #     define(:update) do
-    #       input UserParams
-    #       result :many
-    #     end
-    #
-    #     define(:delete) do
-    #       result :many
-    #     end
-    #   end
-    #
-    # @api public
-    def commands(name, &block)
-      register_command(*CommandDSL.new(name, default_adapter, &block).command_classes)
-    end
-
-    # Configures a plugin for a specific adapter to be enabled for all relations
-    #
-    # @example
-    #   config = ROM::Configuration.new(:sql, 'sqlite::memory')
-    #
-    #   config.plugin(:sql, relations: :instrumentation) do |p|
-    #     p.notifications = MyNotificationsBackend
-    #   end
-    #
-    #   config.plugin(:sql, relations: :pagination)
-    #
-    # @param [Symbol] adapter The adapter identifier
-    # @param [Hash<Symbol=>Symbol>] spec Component identifier => plugin identifier
-    #
-    # @return [Plugin]
-    #
-    # @api public
-    def plugin(adapter, spec, &block)
-      type, name = spec.flatten(1)
-      plugin = plugin_registry.send(type).adapter(adapter).fetch(name) { plugin_registry.send(type).fetch(name) }
-
-      if block
-        register_plugin(plugin.configure(&block))
-      else
-        register_plugin(plugin)
-      end
-    end
-
-    # @api private
-    def plugin_registry
-      ROM.plugin_registry
-    end
-  end
-end

data/lib/rom/configuration_plugin.rb

@@ -1,17 +0,0 @@
-require 'rom/plugin_base'
-
-module ROM
-  # ConfigurationPlugin is a simple object used to store configuration plugin configurations
-  #
-  # @private
-  class ConfigurationPlugin < PluginBase
-    # Apply this plugin to the provided configuration
-    #
-    # @param [ROM::Configuration] configuration
-    #
-    # @api private
-    def apply_to(configuration, options = {})
-      mod.apply(configuration, options)
-    end
-  end
-end

data/lib/rom/constants.rb

@@ -1,36 +0,0 @@
-# Constants and errors common in the whole library
-module ROM
-  AdapterLoadError = Class.new(StandardError)
-
-  class AdapterNotPresentError < StandardError
-    def initialize(adapter, component)
-      super(
-        "Failed to find #{component} class for #{adapter} adapter. " \
-        "Make sure ROM setup was started and the adapter identifier is correct."
-      )
-    end
-  end
-
-  EnvAlreadyFinalizedError = Class.new(StandardError)
-  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)
-
-  MissingSchemaClassError = Class.new(StandardError) do
-    def initialize(klass)
-      super("#{klass.inspect} relation is missing schema_class")
-    end
-  end
-
-  DuplicateConfigurationError = Class.new(StandardError)
-  DuplicateContainerError = Class.new(StandardError)
-
-  InvalidOptionValueError = Class.new(StandardError)
-  InvalidOptionKeyError = Class.new(StandardError)
-end

data/lib/rom/container.rb

@@ -1,233 +0,0 @@
-require 'dry/core/deprecations'
-
-require 'rom/relation/loaded'
-require 'rom/commands/graph'
-require 'rom/commands/graph/builder'
-
-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:
-  #
-  # * Setup DSL - 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
-  # * Explicit 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
-  # * Explicit setup with auto-registration - same as explicit setup 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
-    extend Dry::Core::Deprecations[:rom]
-
-    include Dry::Equalizer(:gateways, :relations, :mappers, :commands)
-
-    # @!attribute [r] gateways
-    #   @return [Hash] A hash with configured gateways
-    attr_reader :gateways
-
-    # @!attribute [r] relations
-    #   @return [RelationRegistry] The relation registry
-    attr_reader :relations
-
-    # @!attribute [r] gateways
-    #   @return [CommandRegistry] The command registry
-    attr_reader :commands
-
-    # @!attribute [r] mappers
-    #   @return [Hash] A hash with configured custom mappers
-    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)
-      Dry::Core::Deprecations.warn("#{self.class}#relation is deprecated and will be removed in 4.0\n\n#{caller[0..5].join("\n")}")
-
-      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)
-      Dry::Core::Deprecations.warn("#{self.class}#command is deprecated and will be removed in 4.0\n\n#{caller[0..5].join("\n")}")
-
-      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,60 +0,0 @@
-require 'rom/configuration'
-require 'rom/environment'
-require 'rom/setup'
-require 'rom/setup/finalize'
-
-module ROM
-  class CreateContainer
-    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,
-        plugins: setup.plugins,
-        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/data_proxy.rb

@@ -1,94 +0,0 @@
-module ROM
-  # Helper module for dataset classes
-  #
-  # It provides a constructor accepting data, header and an optional row_proc.
-  # This module is used internally by EnumerableDataset and ArrayDataset.
-  #
-  # @private
-  module DataProxy
-    NON_FORWARDABLE = [
-      :each, :to_a, :to_ary, :kind_of?, :instance_of?, :is_a?
-    ].freeze
-
-    # Wrapped data array
-    #
-    # @return [Object] Data object for the iterator
-    #
-    # @api private
-    attr_reader :data
-
-    # @return [Proc] tuple processing proc
-    #
-    # @api private
-    attr_reader :row_proc
-
-    # Extends the class with `forward` DSL and Equalizer using `data` attribute
-    #
-    # @see ClassMethods#forward
-    #
-    # @api private
-    def self.included(klass)
-      klass.class_eval do
-        extend ClassMethods
-
-        include Dry::Equalizer(:data)
-
-        option :row_proc, default: -> { self.class.row_proc }
-      end
-    end
-
-    # Iterate over data using row_proc
-    #
-    # @return [Enumerator] if block is not given
-    #
-    # @api private
-    def each
-      return to_enum unless block_given?
-      data.each { |tuple| yield(row_proc[tuple]) }
-    end
-
-    module ClassMethods
-      # Default no-op tuple proc
-      #
-      # @return [Proc]
-      #
-      # @api private
-      def row_proc
-        -> tuple { tuple }
-      end
-
-      # Forward provided methods to the underlaying data object
-      #
-      # @example
-      #
-      #   class MyDataset
-      #     include DataProxy
-      #
-      #     forward(:find_all, :map)
-      #   end
-      #
-      # @return [undefined]
-      #
-      # @api public
-      def forward(*methods)
-        # FIXME: we should probably raise if one of the non-forwardable methods
-        #       was provided
-        (methods - NON_FORWARDABLE).each do |method_name|
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{method_name}(*args, &block)
-              response = data.public_send(#{method_name.inspect}, *args, &block)
-
-              if response.equal?(data)
-                self
-              elsif response.is_a?(data.class)
-                self.class.new(response)
-              else
-                response
-              end
-            end
-          RUBY
-        end
-      end
-    end
-  end
-end