Class: ROM::Command

Inherits:
Object
  • Object
show all
Extended by:
Dry::Core::ClassAttributes, ClassInterface, Initializer
Includes:
Commands, Pipeline::Operator
Defined in:
lib/rom/command.rb,
lib/rom/commands/class_interface.rb

Overview

Base command class with factory class-level interface and setup-related logic

Defined Under Namespace

Modules: ClassInterface

Constant Summary collapse

CommandType = 
Types::Strict::Symbol.enum(:create, :update, :delete)
Result = 
Types::Strict::Symbol.enum(:one, :many)

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Initializer

extended

Methods included from ClassInterface

adapter_namespace, build, create_class, default_name, extend_for_relation, extended, inherited, options, relation_methods_mod, set_hooks, use

Methods included from Pipeline::Operator

#>>

Instance Attribute Details

#after(*hooks) ⇒ Command (readonly)

Return a new command with appended after hooks



228
 
# File 'lib/rom/command.rb', line 228

option :after, Types::Coercible::Array, reader: false, default: -> { self.class.after }

#before(*hooks) ⇒ Command (readonly)

Return a new command with appended before hooks



224
 
# File 'lib/rom/command.rb', line 224

option :before, Types::Coercible::Array, reader: false, default: -> { self.class.before }

#curry_args ⇒ Array (readonly) 



220
 
# File 'lib/rom/command.rb', line 220

option :curry_args, default: -> { EMPTY_ARRAY }

#input ⇒ Proc, #call (readonly) 



216
 
# File 'lib/rom/command.rb', line 216

option :input

#relation ⇒ Relation (readonly) 



197
 
# File 'lib/rom/command.rb', line 197

param :relation

#result ⇒ Symbol (readonly) 



212
 
# File 'lib/rom/command.rb', line 212

option :result, type: Result

#source ⇒ Relation (readonly) 



208
 
# File 'lib/rom/command.rb', line 208

option :source, default: -> { relation }

#type ⇒ Symbol (readonly) 



204
 
# File 'lib/rom/command.rb', line 204

option :type, type: CommandType, optional: true

Class Method Details

.adapter ⇒ Symbol .adapter(identifier) ⇒ Object

Get or set adapter identifier

Overloads:

  • .adapter ⇒ Symbol

    Get adapter identifier

    Examples:

    ROM::Memory::Commands::Create.adapter
# => :memory
  • .adapter(identifier) ⇒ Object

    Set adapter identifier. This must always match actual adapter identifier that was used to register an adapter.

    Examples:

    module MyAdapter
  class CreateCommand < ROM::Commands::Memory::Create
    adapter :my_adapter
  end
end



59
 
# File 'lib/rom/command.rb', line 59

defines :adapter

.register_as ⇒ Symbol .register_as(identifier) ⇒ Object

Get or set identifier that should be used to register a command in a container

Overloads:

  • .register_as ⇒ Symbol

    Get registration identifier

    Examples:

    class CreateUser < ROM::Commands::Create[:memory]
  register_as :create_user
end

CreateUser.register_as
# => :create_user
  • .register_as(identifier) ⇒ Object

    Set registration identifier

    Examples:

    class CreateUser < ROM::Commands::Create[:memory]
  register_as :create_user
end



168
 
# File 'lib/rom/command.rb', line 168

defines :register_as

.input ⇒ Proc, #call .input(identifier) ⇒ Object

Get or set input processing function. This is typically set during setup to relation’s input_schema

Overloads:

  • .input ⇒ Proc, #call

    Get input processing function

    Examples:

    class CreateUser < ROM::Commands::Create[:memory]
  input -> tuple { .. }
end

CreateUser.input
# Your custom function
  • .input(identifier) ⇒ Object

    Set input processing function

    Examples:

    class CreateUser < ROM::Commands::Create[:memory]
  input -> tuple { .. }
end



86
 
# File 'lib/rom/command.rb', line 86

defines :relation

.restrictable ⇒ FalseClass, TrueClass .restrictable(value) ⇒ Object

Overloads:

  • .restrictable ⇒ FalseClass, TrueClass

    Check if a command class is restrictable

    Examples:

    class UpdateUser < ROM::Commands::Update[:memory]
  restrictable true
end

CreateUser.restrictable
# => true
  • .restrictable(value) ⇒ Object

    Set if a command is restrictable

    Examples:

    class UpdateUser < ROM::Commands::Update[:memory]
  restrictable true
end



193
 
# File 'lib/rom/command.rb', line 193

defines :restrictable

Instance Method Details

#after_hooks ⇒ Array

List of after hooks



377
378
379
 
# File 'lib/rom/command.rb', line 377

def after_hooks
  options[:after]
end

#before_hooks ⇒ Array

List of before hooks



368
369
370
 
# File 'lib/rom/command.rb', line 368

def before_hooks
  options[:before]
end

#call(*args, &block) ⇒ Object Also known as: []

Call the command and return one or many tuples

This method will apply before/after hooks automatically



270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
 
# File 'lib/rom/command.rb', line 270

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

#combine(*others) ⇒ Command::Graph

Compose this command with other commands

Composed commands can handle nested input



328
329
330
 
# File 'lib/rom/command.rb', line 328

def combine(*others)
  Graph.new(self, others)
end

#curried? ⇒ TrueClass, FalseClass

Check if this command is curried



337
338
339
 
# File 'lib/rom/command.rb', line 337

def curried?
  curry_args.size > 0
end

#curry(*args) ⇒ Command, Lazy

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.



313
314
315
316
317
318
319
 
# File 'lib/rom/command.rb', line 313

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

#execute ⇒ Array

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

This method is abstract.

Execute the command

Raises:

  • (NotImplementedError) 


258
259
260
261
262
263
 
# File 'lib/rom/command.rb', line 258

def execute(*)
  raise(
    NotImplementedError,
    "#{self.class}##{__method__} must be implemented"
  )
end

#gateway ⇒ Symbol

Return gateway of this command’s relation



247
248
249
 
# File 'lib/rom/command.rb', line 247

def gateway
  relation.gateway
end

#graph? ⇒ false

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Check if this command is a graph



413
414
415
 
# File 'lib/rom/command.rb', line 413

def graph?
  false
end

#hooks? ⇒ Boolean

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Check if this command has any hooks



395
396
397
 
# File 'lib/rom/command.rb', line 395

def hooks?
  before_hooks.size > 0 || after_hooks.size > 0
end

#lazy? ⇒ false

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Check if this command is lazy



404
405
406
 
# File 'lib/rom/command.rb', line 404

def lazy?
  false
end

#many? ⇒ TrueClass, FalseClass

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Check if this command returns many tuples



431
432
433
 
# File 'lib/rom/command.rb', line 431

def many?
  result.equal?(:many)
end

#map_input_tuples(tuples, &mapper) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Yields tuples for insertion or return an enumerator



447
448
449
450
451
452
453
454
455
 
# File 'lib/rom/command.rb', line 447

def map_input_tuples(tuples, &mapper)
  return enum_for(:with_input_tuples, tuples) unless mapper

  if tuples.respond_to? :merge
    mapper[tuples]
  else
    tuples.map(&mapper)
  end
end

#name ⇒ ROM::Relation::Name

Return name of this command’s relation



238
239
240
 
# File 'lib/rom/command.rb', line 238

def name
  relation.name
end

#new(new_relation) ⇒ Command

Return a new command with other source relation

This can be used to restrict command with a specific relation



388
389
390
 
# File 'lib/rom/command.rb', line 388

def new(new_relation)
  self.class.build(new_relation, **options, source: relation)
end

#one? ⇒ TrueClass, FalseClass

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Check if this command returns a single tuple



422
423
424
 
# File 'lib/rom/command.rb', line 422

def one?
  result.equal?(:one)
end

#restrictible? ⇒ TrueClass, FalseClass

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Check if this command is restrictible through relation



440
441
442
 
# File 'lib/rom/command.rb', line 440

def restrictible?
  self.class.restrictable.equal?(true)
end