rom-core 4.0.0.beta1

data/lib/rom/configuration_plugin.rb

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,64 @@
+require 'dry/core/constants'
+
+# Constants and errors common in the whole library
+module ROM
+  include Dry::Core::Constants
+
+  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)
+  MapperAlreadyDefinedError = Class.new(StandardError)
+  NoRelationError = Class.new(StandardError)
+  CommandError = Class.new(StandardError)
+  KeyMissing = Class.new(ROM::CommandError)
+  TupleCountMismatchError = Class.new(CommandError)
+  UnknownPluginError = Class.new(StandardError)
+  UnsupportedRelationError = Class.new(StandardError)
+  MissingAdapterIdentifierError = Class.new(StandardError)
+
+  class ElementNotFoundError < KeyError
+    def initialize(key, registry)
+      super(set_message(key, registry))
+    end
+
+    def set_message(key, registry)
+      "#{key.inspect} doesn't exist in #{registry.class.name} registry"
+    end
+  end
+
+  MapperMissingError = Class.new(ElementNotFoundError)
+
+  CommandNotFoundError = Class.new(ElementNotFoundError) do
+    def set_message(key, registry)
+      "There is no :#{key} command for :#{registry.relation_name} relation"
+    end
+  end
+
+  MissingSchemaClassError = Class.new(StandardError) do
+    def initialize(klass)
+      super("#{klass.inspect} relation is missing schema_class")
+    end
+  end
+
+  MissingSchemaError = Class.new(StandardError) do
+    def initialize(klass)
+      super("#{klass.inspect} relation is missing schema definition")
+    end
+  end
+
+  DuplicateConfigurationError = Class.new(StandardError)
+  DuplicateContainerError = Class.new(StandardError)
+
+  InvalidOptionValueError = Class.new(StandardError)
+  InvalidOptionKeyError = Class.new(StandardError)
+end

data/lib/rom/container.rb

@@ -0,0 +1,147 @@
+require 'dry/container'
+
+require 'rom/cache'
+
+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
+    include Dry::Container::Mixin
+    include Dry::Equalizer(:gateways, :relations, :mappers, :commands)
+
+    # @api private
+    def self.new(gateways, relations, mappers, commands)
+      super().tap do |container|
+        container.register(:gateways, gateways)
+        container.register(:mappers, mappers)
+        container.register(:commands, commands)
+        container.register(:relations, relations)
+      end
+    end
+
+    # @api public
+    def gateways
+      self[:gateways]
+    end
+
+    # @api public
+    def mappers
+      self[:mappers]
+    end
+
+    # @api public
+    def relations
+      self[:relations]
+    end
+
+    # @api public
+    def commands
+      self[:commands]
+    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/core.rb

@@ -0,0 +1,46 @@
+require 'dry/equalizer'
+require 'dry/core/constants'
+
+require 'rom/version'
+require 'rom/constants'
+
+# core parts
+require 'rom/configuration_plugin'
+require 'rom/plugin'
+require 'rom/schema_plugin'
+require 'rom/relation'
+require 'rom-mapper'
+require 'rom/mapper/configuration_plugin'
+require 'rom/commands'
+
+# rom Global
+require 'rom/global'
+
+# rom configurations
+require 'rom/configuration'
+
+# container with registries
+require 'rom/container'
+
+# container factory
+require 'rom/create_container'
+
+# register core plugins
+require 'rom/plugins/configuration/configuration_dsl'
+require 'rom/plugins/relation/registry_reader'
+require 'rom/plugins/relation/instrumentation'
+require 'rom/plugins/command/schema'
+require 'rom/plugins/schema/timestamps'
+
+module ROM
+  extend Global
+
+  plugins do
+    register :mappers, ROM::Mapper::ConfigurationPlugin, type: :configuration
+    register :macros, ROM::ConfigurationPlugins::ConfigurationDSL, type: :configuration
+    register :timestamps, ROM::Plugins::Schema::Timestamps, type: :schema
+    register :registry_reader, ROM::Plugins::Relation::RegistryReader, type: :relation
+    register :instrumentation, ROM::Plugins::Relation::Instrumentation, type: :relation
+    register :schema, ROM::Plugins::Command::Schema, type: :command
+  end
+end

data/lib/rom/create_container.rb

@@ -0,0 +1,60 @@
+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,
+        relation_classes: setup.relation_classes,
+        command_classes: setup.command_classes,
+        mappers: setup.mapper_classes,
+        plugins: setup.plugins,
+        notifications: setup.notifications,
+        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

@@ -0,0 +1,94 @@
+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

data/lib/rom/enumerable_dataset.rb

@@ -0,0 +1,68 @@
+require 'rom/initializer'
+require 'rom/data_proxy'
+
+module ROM
+  # A helper module that adds data-proxy behavior to an enumerable object
+  #
+  # This module is intended to be used by gateways
+  #
+  # Class that includes this module can define `row_proc` class method which
+  # must return a proc-like object which will be used to process each element
+  # in the enumerable
+  #
+  # @example
+  #   class MyDataset
+  #     include ROM::EnumerableDataset
+  #
+  #     def self.row_proc
+  #       -> tuple { tuple.each_with_object({}) { |(k,v), h| h[k.to_sym] = v } }
+  #     end
+  #   end
+  #
+  #   ds = MyDataset.new([{ 'name' => 'Jane' }, [:name])
+  #   ds.to_a # => { :name => 'Jane' }
+  #
+  # @api public
+  module EnumerableDataset
+    extend DataProxy::ClassMethods
+    include Enumerable
+
+    # Coerce a dataset to an array
+    #
+    # @return [Array]
+    #
+    # @api public
+    alias_method :to_ary, :to_a
+
+    # Included hook which extends a class with DataProxy behavior
+    #
+    # This module can also be included into other modules so we apply the
+    # extension only for classes
+    #
+    # @api private
+    def self.included(klass)
+      return unless klass.is_a?(Class)
+
+      klass.class_eval do
+        extend Initializer
+        include DataProxy
+
+        param :data
+      end
+    end
+
+    forward :take
+
+    [
+      :chunk, :collect, :collect_concat, :drop_while, :find_all, :flat_map,
+      :grep, :map, :reject, :select, :sort, :sort_by, :take_while
+    ].each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(*args, &block)
+          return to_enum unless block
+          self.class.new(super(*args, &block), options)
+        end
+      RUBY
+    end
+  end
+end