Class: ActiveInteraction::Base Abstract

Inherits:
Object
  • Object
show all
Extended by:
Hashable, Missable
Includes:
ActiveModelable, ActiveRecordable, Runnable
Defined in:
lib/active_interaction/base.rb,
lib/active_interaction/filters/date_filter.rb,
lib/active_interaction/filters/file_filter.rb,
lib/active_interaction/filters/hash_filter.rb,
lib/active_interaction/filters/time_filter.rb,
lib/active_interaction/filters/array_filter.rb,
lib/active_interaction/filters/float_filter.rb,
lib/active_interaction/filters/object_filter.rb,
lib/active_interaction/filters/string_filter.rb,
lib/active_interaction/filters/symbol_filter.rb,
lib/active_interaction/filters/boolean_filter.rb,
lib/active_interaction/filters/decimal_filter.rb,
lib/active_interaction/filters/integer_filter.rb,
lib/active_interaction/filters/date_time_filter.rb,
lib/active_interaction/filters/interface_filter.rb

Overview

This class is abstract.

Subclass and override #execute to implement a custom ActiveInteraction::Base class.

Provides interaction functionality. Subclass this to create an interaction.

Examples:

class ExampleInteraction < ActiveInteraction::Base
  # Required
  boolean :a

  # Optional
  boolean :b, default: false

  def execute
    a && b
  end
end

outcome = ExampleInteraction.run(a: true)
if outcome.valid?
  outcome.result
else
  outcome.errors
end

Since:

  • 1.0.0

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Missable

method_missing

Methods included from Hashable

hash

Methods included from Runnable

#errors, #result, #result=, #valid?

Methods included from ActiveRecordable

#column_for_attribute, #has_attribute?

Methods included from ActiveModelable

#i18n_scope, #new_record?, #persisted?

Constructor Details

#initialize(inputs = {}) ⇒ Base

Returns a new instance of Base.

Raises:

  • (ArgumentError)

Since:

  • 1.0.0



169
170
171
172
173
 
# File 'lib/active_interaction/base.rb', line 169

def initialize(inputs = {})
  raise ArgumentError, 'inputs must be a hash' unless inputs.is_a?(Hash)

  process_inputs(inputs.symbolize_keys)
end

Class Method Details

.desc(desc = nil) ⇒ String?

Get or set the description.

Examples:

core.desc
# => nil
core.desc('Description!')
core.desc
# => "Description!"

Since:

  • 1.0.0



76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/active_interaction/base.rb', line 76

def desc(desc = nil)
  if desc.nil?
    unless instance_variable_defined?(:@_interaction_desc)
      @_interaction_desc = nil
    end
  else
    @_interaction_desc = desc
  end

  @_interaction_desc
end

.filters ⇒ Hash{Symbol => Filter}

Get all the filters defined on this interaction.

Since:

  • 1.0.0



91
92
93
 
# File 'lib/active_interaction/base.rb', line 91

def filters
  @_interaction_filters ||= {}
end

.import_filters(klass, options = {}) ⇒ Hash{Symbol => Filter}

Import filters from another interaction.

Options Hash (options):

  • :only (Array<Symbol>, nil) —

    Import only these filters.

  • :except (Array<Symbol>, nil) —

    Import all filters except for these.

Since:

  • 1.0.0



127
128
129
130
131
132
133
134
135
136
 
# File 'lib/active_interaction/base.rb', line 127

def import_filters(klass, options = {})
  only = options[:only]
  except = options[:except]

  other_filters = klass.filters.dup
  other_filters.select! { |k, _| [*only].include?(k) } if only
  other_filters.reject! { |k, _| [*except].include?(k) } if except

  other_filters.values.each { |filter| initialize_filter(filter) }
end

.method_missing(*args, &block) ⇒ Object

Since:

  • 1.0.0



96
97
98
99
100
101
102
 
# File 'lib/active_interaction/base.rb', line 96

def method_missing(*args, &block)
  super do |klass, names, options|
    raise InvalidFilterError, 'missing attribute name' if names.empty?

    names.each { |name| add_filter(klass, name, options, &block) }
  end
end

.run(inputs = {}) ⇒ Base

Note:

If the interaction inputs are valid and there are no runtime errors and execution completed successfully, Runnable#valid? will always return true.

Runs validations and if there are no errors it will call #execute.




# File 'lib/active_interaction/base.rb', line 43

.run!(inputs = {}) ⇒ Object

Like run except that it returns the value of #execute or raises

an exception if there were any validation errors.

Raises:




# File 'lib/active_interaction/base.rb', line 54

Instance Method Details

#compose(other, inputs = {}) ⇒ Object

Run another interaction and return its result. If the other interaction

fails, halt execution.




# File 'lib/active_interaction/base.rb', line 175

#execute ⇒ Object

This method is abstract.

Runs the business logic associated with the interaction. This method is only run when there are no validation errors. The return value is placed into Runnable#result.

Raises:

  • (NotImplementedError) 



# File 'lib/active_interaction/base.rb', line 184

#given?(input) ⇒ Boolean

Returns true if the given key was in the hash passed to run. Otherwise returns false. Use this to figure out if an input was given, even if it was nil.

Examples:

class Example < ActiveInteraction::Base
  integer :x, default: nil
  def execute; given?(:x) end
end
Example.run!()        # => false
Example.run!(x: nil)  # => true
Example.run!(x: rand) # => true

Since:

  • 2.1.0



221
222
223
 
# File 'lib/active_interaction/base.rb', line 221

def given?(input)
  @_interaction_keys.include?(input.to_sym)
end

#inputs ⇒ Hash{Symbol => Object}

Returns the inputs provided to run or run! after being cast based

on the filters in the class.

Since:

  • 1.0.0



197
198
199
200
201
 
# File 'lib/active_interaction/base.rb', line 197

def inputs
  self.class.filters.keys.each_with_object({}) do |name, h|
    h[name] = public_send(name)
  end
end