Class: ActiveInteraction::Base

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/record_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

rubocop:disable Lint/EmptyClass

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.

Parameters:

  • inputs (Hash{Symbol => Object}) (defaults to: {}) —

    Attribute values to set.



166
167
168
169
 
# File 'lib/active_interaction/base.rb', line 166

def initialize(inputs = {})
  inputs = normalize_inputs!(inputs)
  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!"

Parameters:

  • desc (String, nil) (defaults to: nil) —

    What to set the description to.

Returns:

  • (String, nil) —

    The description.



74
75
76
77
78
79
80
81
82
 
# File 'lib/active_interaction/base.rb', line 74

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

  @_interaction_desc
end

.filters ⇒ Hash{Symbol => Filter}

Get all the filters defined on this interaction.

Returns:



87
88
89
90
91
 
# File 'lib/active_interaction/base.rb', line 87

def filters
  # rubocop:disable Naming/MemoizedInstanceVariableName
  @_interaction_filters ||= {}
  # rubocop:enable Naming/MemoizedInstanceVariableName
end

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

Import filters from another interaction.

Parameters:

  • klass (Class) —

    The other interaction.

  • options (Hash) (defaults to: {})

Options Hash (options):

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

    Import only these filters.

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

    Import all filters except for these.

Returns:



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.each_value { |filter| initialize_filter(filter) }
end

.method_missing(*args, &block) ⇒ Object

rubocop:disable Style/MissingRespondToMissing



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

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.

Parameters:

  • inputs (Hash{Symbol => Object}) (defaults to: {}) —

    Attribute values to set.

Returns:




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

.run!(inputs = {}) ⇒ Object

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

an exception if there were any validation errors.

Parameters:

  • inputs (Hash{Symbol => Object}) (defaults to: {}) —

    Attribute values to set.

Returns:

  • (Object)

Raises:




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

Instance Method Details

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

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

fails, halt execution.

Parameters:

  • other (Class) —

    The other interaction.

  • inputs (Hash{Symbol => Object}) (defaults to: {}) —

    Attribute values to set.

Returns:

  • (Object) 



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

#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 180

#given?(input, *rest) ⇒ 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`. Keys within nested hash filter can also be checked by passing them in series. Arrays can be checked in the same manor as hashes by passing an index.

rubocop:disable all

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

Nested checks

class Example < ActiveInteraction::Base
  hash :x, default: {} do
    integer :y, default: nil
  end
  array :a, default: [] do
    integer
  end
  def execute; given?(:x, :y) || given?(:a, 2) end
end
Example.run!()               # => false
Example.run!(x: nil)         # => false
Example.run!(x: {})          # => false
Example.run!(x: { y: nil })  # => true
Example.run!(x: { y: rand }) # => true
Example.run!(a: [1, 2])      # => false
Example.run!(a: [1, 2, 3])   # => true

Parameters:

  • input (#to_sym)

Returns:

  • (Boolean)

Since:

  • 2.1.0



236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
 
# File 'lib/active_interaction/base.rb', line 236

def given?(input, *rest)
  filter_level = self.class
  input_level = @_interaction_raw_inputs

  [input, *rest].each do |key_or_index|
    if key_or_index.is_a?(Symbol) || key_or_index.is_a?(String)
      key_or_index = key_or_index.to_sym
      filter_level = filter_level.filters[key_or_index]

      break false if filter_level.nil? || input_level.nil?
      break false unless input_level.key?(key_or_index) || input_level.key?(key_or_index.to_s)

      input_level = input_level[key_or_index] || input_level[key_or_index.to_s]
    else
      filter_level = filter_level.filters.first.last

      break false if filter_level.nil? || input_level.nil?
      break false unless key_or_index.between?(-input_level.size, input_level.size - 1)

      input_level = input_level[key_or_index]
    end
  end && true
end

#inputs ⇒ Hash{Symbol => Object}

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

on the filters in the class.

Returns:

  • (Hash{Symbol => Object}) —

    All inputs passed to run or run!.



193
194
195
 
# File 'lib/active_interaction/base.rb', line 193

def inputs
  @_interaction_inputs
end