rom 3.3.3 → 4.0.0.beta1

data/Rakefile

@@ -1,28 +0,0 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-require "rake/testtask"
-
-RSpec::Core::RakeTask.new(:spec)
-task default: [:ci]
-
-desc 'Run specs in isolation'
-task :"spec:isolation" do
-  FileList["spec/**/*_spec.rb"].each do |spec|
-    sh "COVERAGE=false bundle exec rspec #{spec}"
-  end
-end
-
-if RUBY_ENGINE != 'ruby'
-  desc "Run CI tasks"
-  task ci: [:spec, :lint]
-else
-  desc "Run CI tasks"
-  task ci: [:spec, :lint, :"spec:isolation"]
-end
-
-Rake::TestTask.new(:lint) do |test|
-  test.description = "Run adapter lint tests against memory adapter"
-  test.test_files = FileList.new('spec/test/*_test.rb')
-  test.libs << 'test'
-  test.verbose = true
-end

data/lib/rom/array_dataset.rb

@@ -1,44 +0,0 @@
-require 'rom/initializer'
-require 'rom/enumerable_dataset'
-
-module ROM
-  # A helper module that adds data-proxy behavior to an array-like object
-  #
-  # @see EnumerableDataset
-  #
-  # @api public
-  module ArrayDataset
-    extend DataProxy::ClassMethods
-    include EnumerableDataset
-
-    # Extends the class with data-proxy behavior
-    #
-    # @api private
-    def self.included(klass)
-      klass.class_eval do
-        extend Initializer
-        include DataProxy
-
-        param :data
-      end
-    end
-
-    forward(
-      :*, :+, :-, :compact, :compact!, :flatten, :flatten!, :length, :pop,
-      :reverse, :reverse!, :sample, :size, :shift, :shuffle, :shuffle!,
-      :slice, :slice!, :sort!, :uniq, :uniq!, :unshift, :values_at
-    )
-
-    [
-      :map!, :combination, :cycle, :delete_if, :keep_if, :permutation, :reject!,
-      :select!, :sort_by!
-    ].each do |method|
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{method}(*args, &block)
-          return to_enum unless block
-          self.class.new(data.send(:#{method}, *args, &block), options)
-        end
-      RUBY
-    end
-  end
-end

data/lib/rom/association_set.rb

@@ -1,49 +0,0 @@
-require 'dry/core/deprecations'
-require 'dry/core/inflector'
-
-require 'rom/registry'
-
-module ROM
-  class AssociationSet < ROM::Registry
-    # @api private
-    def try(name, &block)
-      key = name.to_sym
-
-      if key?(key) || key?(singularize(key))
-        yield(self[key])
-      else
-        msg = <<-STR
-          Key inference will be removed in rom 4.0. You need to define :#{key} association.
-            => Called at:
-               #{caller.join("\n")}
-          STR
-
-        Dry::Core::Deprecations.warn(msg)
-
-        false
-      end
-    end
-
-    # @api private
-    def [](name)
-      key = name.to_sym
-
-      if key?(key)
-        super
-      else
-        sk = singularize(key)
-
-        if key?(sk)
-          super(sk)
-        else
-          super
-        end
-      end
-    end
-
-    # @api private
-    def singularize(key)
-      Dry::Core::Inflector.singularize(key).to_sym
-    end
-  end
-end

data/lib/rom/auto_curry.rb

@@ -1,55 +0,0 @@
-module ROM
-  module AutoCurry
-    def self.extended(klass)
-      klass.define_singleton_method(:method_added) do |name|
-        return if auto_curry_busy?
-        auto_curry_guard { auto_curry(name) }
-        super(name)
-      end
-    end
-
-    def auto_curry_guard
-      @__auto_curry_busy__ = true
-      yield
-    ensure
-      @__auto_curry_busy__ = false
-    end
-
-    def auto_curry_busy?
-      @__auto_curry_busy__ ||= false
-    end
-
-    def auto_curried_methods
-      @__auto_curried_methods__ ||= []
-    end
-
-    def auto_curry(name, &block)
-      arity = instance_method(name).arity
-
-      return unless public_instance_methods.include?(name) && arity != 0
-
-      mod = Module.new
-
-      mod.module_eval do
-        define_method(name) do |*args, &mblock|
-          response =
-            if arity < 0 || arity == args.size
-              super(*args, &mblock)
-            else
-              self.class.curried.new(self, name: name, curry_args: args, arity: arity)
-            end
-
-          if block
-            response.instance_exec(&block)
-          else
-            response
-          end
-        end
-      end
-
-      auto_curried_methods << name
-
-      prepend(mod)
-    end
-  end
-end

data/lib/rom/command.rb

@@ -1,494 +0,0 @@
-require 'dry/core/deprecations'
-require 'dry/core/class_attributes'
-
-require 'rom/types'
-require 'rom/initializer'
-require 'rom/pipeline'
-
-require 'rom/commands/class_interface'
-require 'rom/commands/composite'
-require 'rom/commands/graph'
-require 'rom/commands/lazy'
-
-module ROM
-  # Abstract command class
-  #
-  # Provides a constructor accepting relation with options and basic behavior
-  # for calling, currying and composing commands.
-  #
-  # Typically command subclasses should inherit from specialized
-  # Create/Update/Delete, not this one.
-  #
-  # @abstract
-  #
-  # @api public
-  class Command
-    extend Initializer
-    include Dry::Equalizer(:relation, :options)
-    include Commands
-    include Pipeline::Operator
-
-    extend Dry::Core::ClassAttributes
-    extend Dry::Core::Deprecations[:rom]
-    extend ClassInterface
-
-    # @!method self.adapter
-    #   Get or set adapter identifier
-    #
-    #   @overload adapter
-    #     Get adapter identifier
-    #
-    #     @example
-    #       ROM::Memory::Commands::Create.adapter
-    #       # => :memory
-    #
-    #     @return [Symbol]
-    #
-    #   @overload adapter(identifier)
-    #     Set adapter identifier. This must always match actual adapter identifier
-    #     that was used to register an adapter.
-    #
-    #     @example
-    #       module MyAdapter
-    #         class CreateCommand < ROM::Commands::Memory::Create
-    #           adapter :my_adapter
-    #         end
-    #       end
-    #
-    # @api public
-    defines :adapter
-
-    # @!method self.relation
-    #   Get or set relation identifier
-    #
-    #   @overload relation
-    #     Get relation identifier
-    #
-    #     @example
-    #       class CreateUser < ROM::Commands::Create[:memory]
-    #         relation :users
-    #       end
-    #
-    #       CreateUser.relation
-    #       # => :users
-    #
-    #     @return [Symbol]
-    #
-    #   @overload relation(identifier)
-    #     Set relation identifier.
-    #
-    #     @example
-    #       class CreateUser < ROM::Commands::Create[:memory]
-    #         relation :users
-    #       end
-    #
-    # @api public
-    defines :relation
-
-    # @!method self.relation
-    #   Get or set result type
-    #
-    #   @overload result
-    #     Get result type
-    #
-    #     @example
-    #       class CreateUser < ROM::Commands::Create[:memory]
-    #         result :one
-    #       end
-    #
-    #       CreateUser.result
-    #       # => :one
-    #
-    #     @return [Symbol]
-    #
-    #   @overload relation(identifier)
-    #     Set result type
-    #
-    #     @example
-    #       class CreateUser < ROM::Commands::Create[:memory]
-    #         result :one
-    #       end
-    #
-    # @api public
-    defines :result
-
-    # @!method self.relation
-    #   Get or set input processing function. This is typically set during setup
-    #   to relation's input_schema
-    #
-    #   @overload input
-    #     Get input processing function
-    #
-    #     @example
-    #       class CreateUser < ROM::Commands::Create[:memory]
-    #         input -> tuple { .. }
-    #       end
-    #
-    #       CreateUser.input
-    #       # Your custom function
-    #
-    #     @return [Proc,#call]
-    #
-    #   @overload input(identifier)
-    #     Set input processing function
-    #
-    #     @example
-    #       class CreateUser < ROM::Commands::Create[:memory]
-    #         input -> tuple { .. }
-    #       end
-    #
-    # @api public
-    defines :input
-
-    # @!method self.register_as
-    #   Get or set identifier that should be used to register a command in a container
-    #
-    #   @overload register_as
-    #     Get registration identifier
-    #
-    #     @example
-    #       class CreateUser < ROM::Commands::Create[:memory]
-    #         register_as :create_user
-    #       end
-    #
-    #       CreateUser.register_as
-    #       # => :create_user
-    #
-    #     @return [Symbol]
-    #
-    #   @overload register_as(identifier)
-    #     Set registration identifier
-    #
-    #     @example
-    #       class CreateUser < ROM::Commands::Create[:memory]
-    #         register_as :create_user
-    #       end
-    #
-    # @api public
-    defines :register_as
-
-    # @!method self.restrictable
-    #   @overload restrictable
-    #     Check if a command class is restrictable
-    #
-    #     @example
-    #       class UpdateUser < ROM::Commands::Update[:memory]
-    #         restrictable true
-    #       end
-    #
-    #       CreateUser.restrictable
-    #       # => true
-    #
-    #     @return [FalseClass, TrueClass]
-    #
-    #   @overload restrictable(value)
-    #     Set if a command is restrictable
-    #
-    #     @example
-    #       class UpdateUser < ROM::Commands::Update[:memory]
-    #         restrictable true
-    #       end
-    #
-    # @api public
-    defines :restrictable
-
-    # @!attribute [r] relation
-    #   @return [Relation] Command's relation
-    param :relation
-
-    CommandType = Types::Strict::Symbol.enum(:create, :update, :delete)
-    Result = Types::Strict::Symbol.enum(:one, :many)
-
-    # @!attribute [r] type
-    #   @return [Symbol] The command type, one of :create, :update or :delete
-    option :type, type: CommandType, optional: true
-
-    # @!attribute [r] source
-    #   @return [Relation] The source relation
-    option :source, default: -> { relation }
-
-    # @!attribute [r] result
-    #   @return [Symbol] Result type, either :one or :many
-    option :result, type: Result
-
-    # @!attribute [r] input
-    #   @return [Proc, #call] Tuple processing function, typically uses Relation#input_schema
-    option :input
-
-    # @!attribute [r] curry_args
-    #   @return [Array] Curried args
-    option :curry_args, default: -> { EMPTY_ARRAY }
-
-    # @!attribute [r] before
-    #   @return [Array<Hash>] An array with before hooks configuration
-    option :before, Types::Coercible::Array, reader: false, default: -> { self.class.before }
-
-    # @!attribute [r] after
-    #   @return [Array<Hash>] An array with after hooks configuration
-    option :after, Types::Coercible::Array, reader: false, default: -> { self.class.after }
-
-    input Hash
-    result :many
-
-    # Return name of this command's relation
-    #
-    # @return [ROM::Relation::Name]
-    #
-    # @api public
-    def name
-      relation.name
-    end
-
-    # Return gateway of this command's relation
-    #
-    # @return [Symbol]
-    #
-    # @api public
-    def gateway
-      relation.gateway
-    end
-
-    # Execute the command
-    #
-    # @abstract
-    #
-    # @return [Array] an array with inserted tuples
-    #
-    # @api private
-    def execute(*)
-      raise(
-        NotImplementedError,
-        "#{self.class}##{__method__} must be implemented"
-      )
-    end
-
-    # Call the command and return one or many tuples
-    #
-    # This method will apply before/after hooks automatically
-    #
-    # @api public
-    def call(*args, &block)
-      tuples =
-        if hooks?
-          prepared =
-            if curried?
-              apply_hooks(before_hooks, *(curry_args + args))
-            else
-              apply_hooks(before_hooks, *args)
-            end
-
-          result = prepared ? execute(prepared, &block) : execute(&block)
-
-          if curried?
-            if args.size > 0
-              apply_hooks(after_hooks, result, *args)
-            elsif curry_args.size > 1
-              apply_hooks(after_hooks, result, curry_args[1])
-            else
-              apply_hooks(after_hooks, result)
-            end
-          else
-            apply_hooks(after_hooks, result, *args[1..args.size-1])
-          end
-        else
-          execute(*(curry_args + args), &block)
-        end
-
-      if one?
-        tuples.first
-      else
-        tuples
-      end
-    end
-    alias_method :[], :call
-
-    # Curry this command with provided args
-    #
-    # Curried command can be called without args. If argument is a graph input processor,
-    # lazy command will be returned, which is used for handling nested input hashes.
-    #
-    # @return [Command, Lazy]
-    #
-    # @api public
-    def curry(*args)
-      if curry_args.empty? && args.first.is_a?(Graph::InputEvaluator)
-        Lazy[self].new(self, *args)
-      else
-        self.class.build(relation, **options, curry_args: args)
-      end
-    end
-
-    # @api public
-    def with(*args)
-      self.class.warn "Command#with will change its behavior in rom 4.0. Use Command#curry instead.\n\n#{caller[0..5].join("\n")}"
-      curry(*args)
-    end
-
-    # Compose this command with other commands
-    #
-    # Composed commands can handle nested input
-    #
-    # @return [Command::Graph]
-    #
-    # @api public
-    def combine(*others)
-      Graph.new(self, others)
-    end
-
-    # Check if this command is curried
-    #
-    # @return [TrueClass, FalseClass]
-    #
-    # @api public
-    def curried?
-      curry_args.size > 0
-    end
-
-    # Return a new command with new options
-    #
-    # @param [Hash] new_opts A hash with new options
-    #
-    # @return [Command]
-    #
-    # @api public
-    def with_opts(new_opts)
-      self.class.new(relation, options.merge(new_opts))
-    end
-
-    # Return a new command with appended before hooks
-    #
-    # @param [Array<Hash>] hooks A list of before hooks configurations
-    #
-    # @return [Command]
-    #
-    # @api public
-    def before(*hooks)
-      self.class.new(relation, **options, before: before_hooks + hooks)
-    end
-
-    # Return a new command with appended after hooks
-    #
-    # @param [Array<Hash>] hooks A list of after hooks configurations
-    #
-    # @return [Command]
-    #
-    # @api public
-    def after(*hooks)
-      self.class.new(relation, **options, after: after_hooks + hooks)
-    end
-
-    # List of before hooks
-    #
-    # @return [Array]
-    #
-    # @api public
-    def before_hooks
-      options[:before]
-    end
-
-    # List of after hooks
-    #
-    # @return [Array]
-    #
-    # @api public
-    def after_hooks
-      options[:after]
-    end
-
-    # Return a new command with other source relation
-    #
-    # This can be used to restrict command with a specific relation
-    #
-    # @return [Command]
-    #
-    # @api public
-    def new(new_relation)
-      self.class.build(new_relation, **options, source: relation)
-    end
-
-    # Check if this command has any hooks
-    #
-    # @api private
-    def hooks?
-      before_hooks.size > 0 || after_hooks.size > 0
-    end
-
-    # Check if this command is lazy
-    #
-    # @return [false]
-    #
-    # @api private
-    def lazy?
-      false
-    end
-
-    # Check if this command is a graph
-    #
-    # @return [false]
-    #
-    # @api private
-    def graph?
-      false
-    end
-
-    # Check if this command returns a single tuple
-    #
-    # @return [TrueClass,FalseClass]
-    #
-    # @api private
-    def one?
-      result.equal?(:one)
-    end
-
-    # Check if this command returns many tuples
-    #
-    # @return [TrueClass,FalseClass]
-    #
-    # @api private
-    def many?
-      result.equal?(:many)
-    end
-
-    private
-
-    # Hook called by Pipeline to get composite class for commands
-    #
-    # @return [Class]
-    #
-    # @api private
-    def composite_class
-      Command::Composite
-    end
-
-    # Apply provided hooks
-    #
-    # Used by #call
-    #
-    # @return [Array<Hash>]
-    #
-    # @api private
-    def apply_hooks(hooks, tuples, *args)
-      hooks.reduce(tuples) do |a, e|
-        if e.is_a?(Hash)
-          hook_meth, hook_args = e.to_a.flatten(1)
-          __send__(hook_meth, a, *args, **hook_args)
-        else
-          __send__(e, a, *args)
-        end
-      end
-    end
-
-    # Pipes a dataset through command's relation
-    #
-    # @return [Array]
-    #
-    # @api private
-    def wrap_dataset(dataset)
-      if relation.is_a?(Relation::Composite)
-        relation.new(dataset).to_a
-      else
-        dataset
-      end
-    end
-  end
-end