Class: ActiveInteractor::Organizer::InteractorInterface Private

Inherits:
Object
  • Object
show all
Defined in:
lib/active_interactor/organizer/interactor_interface.rb

Overview

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

An interface object to facilitate conditionally calling .perform on an interactor

Author:

Since:

  • 1.0.0

Constant Summary collapse

CONDITIONAL_FILTERS =

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

Keywords for conditional filters

Returns:

  • (Array<Symbol>)

Since:

  • 1.0.0

%i[if unless].freeze
CALLBACKS =

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

Since:

  • 1.0.0

%i[before after].freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(interactor_class, options = {}) ⇒ InteractorInterface

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.

Initialize a new instance of ActiveInteractor::Organizer::InteractorInterface

Parameters:

Since:

  • 1.0.0



50
51
52
53
54
55
 
# File 'lib/active_interactor/organizer/interactor_interface.rb', line 50

def initialize(interactor_class, options = {})
  @interactor_class = interactor_class.to_s.camelize.safe_constantize
  @filters = options.select { |key, _value| CONDITIONAL_FILTERS.include?(key) }
  @callbacks = options.select { |key, _value| CALLBACKS.include?(key) }
  @perform_options = options.reject { |key, _value| CONDITIONAL_FILTERS.include?(key) || CALLBACKS.include?(key) }
end

Instance Attribute Details

#callbacks ⇒ Hash{Symbol=>*} (readonly)

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.

Callbacks for the interactor_class

Returns:

  • (Hash{Symbol=>*}) —

    the interactor callbacks

Since:

  • 1.1.0



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/active_interactor/organizer/interactor_interface.rb', line 36

class InteractorInterface
  attr_reader :filters, :callbacks, :interactor_class, :perform_options

  # Keywords for conditional filters
  # @return [Array<Symbol>]
  CONDITIONAL_FILTERS = %i[if unless].freeze
  CALLBACKS = %i[before after].freeze

  # Initialize a new instance of {InteractorInterface}
  #
  # @param interactor_class [Const] an {ActiveInteractor::Base interactor} class
  # @param options [Hash] options to use for the {ActiveInteractor::Base interactor's}
  #  {Interactor::Perform::ClassMethods#perform .perform}. See {Interactor::Perform::Options}.
  # @return [InteractorInterface] a new instance of {InteractorInterface}
  def initialize(interactor_class, options = {})
    @interactor_class = interactor_class.to_s.camelize.safe_constantize
    @filters = options.select { |key, _value| CONDITIONAL_FILTERS.include?(key) }
    @callbacks = options.select { |key, _value| CALLBACKS.include?(key) }
    @perform_options = options.reject { |key, _value| CONDITIONAL_FILTERS.include?(key) || CALLBACKS.include?(key) }
  end

  # Call the {#interactor_class} {Interactor::Perform::ClassMethods#perform .perform} or
  # {Interactor::Perform::ClassMethods#perform! .perform!} method if all conditions in {#filters} are properly met.
  #
  # @param target [Class] the calling {Base organizer} instance
  # @param context [Class] an instance of {Context::Base context}
  # @param fail_on_error [Boolean] if `true` {Interactor::Perform::ClassMethods#perform! .perform!} will be called
  #  on the {#interactor_class} other wise {Interactor::Perform::ClassMethods#perform .perform} will be called.
  # @param perform_options [Hash] additional {Interactor::Perform::Options} to merge with {#perform_options}
  # @raise [Error::ContextFailure] if `fail_on_error` is `true` and the {#interactor_class}
  #  {Context::Status#fail! fails} its {Context::Base context}.
  # @return [Class] an instance of {Context::Base context}
  def perform(target, context, fail_on_error = false, perform_options = {})
    return if check_conditionals(target, :if) == false
    return if check_conditionals(target, :unless) == true

    method = fail_on_error ? :perform! : :perform
    options = self.perform_options.merge(perform_options)
    interactor_class.send(method, context, options)
  end

  def execute_inplace_callback(target, callback)
    resolve_option(target, callbacks[callback])
  end

  private

  def check_conditionals(target, filter)
    resolve_option(target, filters[filter])
  end

  def resolve_option(target, opt)
    return unless opt

    return target.send(opt) if opt.is_a?(Symbol)
    return target.instance_exec(&opt) if opt.is_a?(Proc)
  end
end

#filters ⇒ Hash{Symbol=>Proc, Symbol} (readonly)

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.

Conditional options for the interactor class

Returns:

  • (Hash{Symbol=>Proc, Symbol}) —

    conditional options for the interactor class

Since:

  • 1.0.0



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/active_interactor/organizer/interactor_interface.rb', line 36

class InteractorInterface
  attr_reader :filters, :callbacks, :interactor_class, :perform_options

  # Keywords for conditional filters
  # @return [Array<Symbol>]
  CONDITIONAL_FILTERS = %i[if unless].freeze
  CALLBACKS = %i[before after].freeze

  # Initialize a new instance of {InteractorInterface}
  #
  # @param interactor_class [Const] an {ActiveInteractor::Base interactor} class
  # @param options [Hash] options to use for the {ActiveInteractor::Base interactor's}
  #  {Interactor::Perform::ClassMethods#perform .perform}. See {Interactor::Perform::Options}.
  # @return [InteractorInterface] a new instance of {InteractorInterface}
  def initialize(interactor_class, options = {})
    @interactor_class = interactor_class.to_s.camelize.safe_constantize
    @filters = options.select { |key, _value| CONDITIONAL_FILTERS.include?(key) }
    @callbacks = options.select { |key, _value| CALLBACKS.include?(key) }
    @perform_options = options.reject { |key, _value| CONDITIONAL_FILTERS.include?(key) || CALLBACKS.include?(key) }
  end

  # Call the {#interactor_class} {Interactor::Perform::ClassMethods#perform .perform} or
  # {Interactor::Perform::ClassMethods#perform! .perform!} method if all conditions in {#filters} are properly met.
  #
  # @param target [Class] the calling {Base organizer} instance
  # @param context [Class] an instance of {Context::Base context}
  # @param fail_on_error [Boolean] if `true` {Interactor::Perform::ClassMethods#perform! .perform!} will be called
  #  on the {#interactor_class} other wise {Interactor::Perform::ClassMethods#perform .perform} will be called.
  # @param perform_options [Hash] additional {Interactor::Perform::Options} to merge with {#perform_options}
  # @raise [Error::ContextFailure] if `fail_on_error` is `true` and the {#interactor_class}
  #  {Context::Status#fail! fails} its {Context::Base context}.
  # @return [Class] an instance of {Context::Base context}
  def perform(target, context, fail_on_error = false, perform_options = {})
    return if check_conditionals(target, :if) == false
    return if check_conditionals(target, :unless) == true

    method = fail_on_error ? :perform! : :perform
    options = self.perform_options.merge(perform_options)
    interactor_class.send(method, context, options)
  end

  def execute_inplace_callback(target, callback)
    resolve_option(target, callbacks[callback])
  end

  private

  def check_conditionals(target, filter)
    resolve_option(target, filters[filter])
  end

  def resolve_option(target, opt)
    return unless opt

    return target.send(opt) if opt.is_a?(Symbol)
    return target.instance_exec(&opt) if opt.is_a?(Proc)
  end
end

#interactor_class ⇒ Const (readonly)

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.

An interactor class

Returns:

Since:

  • 1.0.0



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/active_interactor/organizer/interactor_interface.rb', line 36

class InteractorInterface
  attr_reader :filters, :callbacks, :interactor_class, :perform_options

  # Keywords for conditional filters
  # @return [Array<Symbol>]
  CONDITIONAL_FILTERS = %i[if unless].freeze
  CALLBACKS = %i[before after].freeze

  # Initialize a new instance of {InteractorInterface}
  #
  # @param interactor_class [Const] an {ActiveInteractor::Base interactor} class
  # @param options [Hash] options to use for the {ActiveInteractor::Base interactor's}
  #  {Interactor::Perform::ClassMethods#perform .perform}. See {Interactor::Perform::Options}.
  # @return [InteractorInterface] a new instance of {InteractorInterface}
  def initialize(interactor_class, options = {})
    @interactor_class = interactor_class.to_s.camelize.safe_constantize
    @filters = options.select { |key, _value| CONDITIONAL_FILTERS.include?(key) }
    @callbacks = options.select { |key, _value| CALLBACKS.include?(key) }
    @perform_options = options.reject { |key, _value| CONDITIONAL_FILTERS.include?(key) || CALLBACKS.include?(key) }
  end

  # Call the {#interactor_class} {Interactor::Perform::ClassMethods#perform .perform} or
  # {Interactor::Perform::ClassMethods#perform! .perform!} method if all conditions in {#filters} are properly met.
  #
  # @param target [Class] the calling {Base organizer} instance
  # @param context [Class] an instance of {Context::Base context}
  # @param fail_on_error [Boolean] if `true` {Interactor::Perform::ClassMethods#perform! .perform!} will be called
  #  on the {#interactor_class} other wise {Interactor::Perform::ClassMethods#perform .perform} will be called.
  # @param perform_options [Hash] additional {Interactor::Perform::Options} to merge with {#perform_options}
  # @raise [Error::ContextFailure] if `fail_on_error` is `true` and the {#interactor_class}
  #  {Context::Status#fail! fails} its {Context::Base context}.
  # @return [Class] an instance of {Context::Base context}
  def perform(target, context, fail_on_error = false, perform_options = {})
    return if check_conditionals(target, :if) == false
    return if check_conditionals(target, :unless) == true

    method = fail_on_error ? :perform! : :perform
    options = self.perform_options.merge(perform_options)
    interactor_class.send(method, context, options)
  end

  def execute_inplace_callback(target, callback)
    resolve_option(target, callbacks[callback])
  end

  private

  def check_conditionals(target, filter)
    resolve_option(target, filters[filter])
  end

  def resolve_option(target, opt)
    return unless opt

    return target.send(opt) if opt.is_a?(Symbol)
    return target.instance_exec(&opt) if opt.is_a?(Proc)
  end
end

#perform_options ⇒ Hash{Symbol=>*} (readonly)

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.

Interactor::Perform::Options for the interactor #perform

Returns:

See Also:

Since:

  • 1.0.0



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/active_interactor/organizer/interactor_interface.rb', line 36

class InteractorInterface
  attr_reader :filters, :callbacks, :interactor_class, :perform_options

  # Keywords for conditional filters
  # @return [Array<Symbol>]
  CONDITIONAL_FILTERS = %i[if unless].freeze
  CALLBACKS = %i[before after].freeze

  # Initialize a new instance of {InteractorInterface}
  #
  # @param interactor_class [Const] an {ActiveInteractor::Base interactor} class
  # @param options [Hash] options to use for the {ActiveInteractor::Base interactor's}
  #  {Interactor::Perform::ClassMethods#perform .perform}. See {Interactor::Perform::Options}.
  # @return [InteractorInterface] a new instance of {InteractorInterface}
  def initialize(interactor_class, options = {})
    @interactor_class = interactor_class.to_s.camelize.safe_constantize
    @filters = options.select { |key, _value| CONDITIONAL_FILTERS.include?(key) }
    @callbacks = options.select { |key, _value| CALLBACKS.include?(key) }
    @perform_options = options.reject { |key, _value| CONDITIONAL_FILTERS.include?(key) || CALLBACKS.include?(key) }
  end

  # Call the {#interactor_class} {Interactor::Perform::ClassMethods#perform .perform} or
  # {Interactor::Perform::ClassMethods#perform! .perform!} method if all conditions in {#filters} are properly met.
  #
  # @param target [Class] the calling {Base organizer} instance
  # @param context [Class] an instance of {Context::Base context}
  # @param fail_on_error [Boolean] if `true` {Interactor::Perform::ClassMethods#perform! .perform!} will be called
  #  on the {#interactor_class} other wise {Interactor::Perform::ClassMethods#perform .perform} will be called.
  # @param perform_options [Hash] additional {Interactor::Perform::Options} to merge with {#perform_options}
  # @raise [Error::ContextFailure] if `fail_on_error` is `true` and the {#interactor_class}
  #  {Context::Status#fail! fails} its {Context::Base context}.
  # @return [Class] an instance of {Context::Base context}
  def perform(target, context, fail_on_error = false, perform_options = {})
    return if check_conditionals(target, :if) == false
    return if check_conditionals(target, :unless) == true

    method = fail_on_error ? :perform! : :perform
    options = self.perform_options.merge(perform_options)
    interactor_class.send(method, context, options)
  end

  def execute_inplace_callback(target, callback)
    resolve_option(target, callbacks[callback])
  end

  private

  def check_conditionals(target, filter)
    resolve_option(target, filters[filter])
  end

  def resolve_option(target, opt)
    return unless opt

    return target.send(opt) if opt.is_a?(Symbol)
    return target.instance_exec(&opt) if opt.is_a?(Proc)
  end
end

Instance Method Details

#execute_inplace_callback(target, callback) ⇒ 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.

Since:

  • 1.0.0



77
78
79
 
# File 'lib/active_interactor/organizer/interactor_interface.rb', line 77

def execute_inplace_callback(target, callback)
  resolve_option(target, callbacks[callback])
end

#perform(target, context, fail_on_error = false, perform_options = {}) ⇒ Class

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.

Call the #interactor_class .perform or .perform! method if all conditions in #filters are properly met.

Parameters:

Returns:

  • (Class) —

    an instance of context

Raises:

Since:

  • 1.0.0



68
69
70
71
72
73
74
75
 
# File 'lib/active_interactor/organizer/interactor_interface.rb', line 68

def perform(target, context, fail_on_error = false, perform_options = {})
  return if check_conditionals(target, :if) == false
  return if check_conditionals(target, :unless) == true

  method = fail_on_error ? :perform! : :perform
  options = self.perform_options.merge(perform_options)
  interactor_class.send(method, context, options)
end