Class: ActiveInteraction::Inputs

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Includes:
Enumerable
Defined in:
lib/active_interaction/inputs.rb

Overview

Holds inputs passed to the interaction.

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(raw_inputs, base) ⇒ Inputs

Returns a new instance of Inputs.



39
40
41
42
43
44
45
46
47
 
# File 'lib/active_interaction/inputs.rb', line 39

def initialize(raw_inputs, base)
  @base = base
  @normalized_inputs = normalize(raw_inputs)
  @inputs = base.class.filters.each_with_object({}) do |(name, filter), inputs|
    inputs[name] = filter.process(@normalized_inputs[name], base)

    yield name, inputs[name] if block_given?
  end
end

Class Method Details

.reserved?(name) ⇒ Boolean

Checking ‘syscall` is the result of what appears to be a bug in Ruby. bugs.ruby-lang.org/issues/15597

Returns:

  • (Boolean) 


24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/active_interaction/inputs.rb', line 24

def reserved?(name)
  name.to_s.start_with?('_interaction_') ||
    name == :syscall ||
    (
      Base.method_defined?(name) &&
      !Object.method_defined?(name)
    ) ||
    (
      Base.private_method_defined?(name) &&
      !Object.private_method_defined?(name)
    )
end

Instance Method Details

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


134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/active_interaction/inputs.rb', line 134

def given?(input, *rest)
  filter_level = @base.class
  input_level = @normalized_inputs

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

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

      input_level = input_level[key] || input_level[key_to_s]
    else
      index = key_or_index
      filter_level = filter_level.filters.first.last

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

      input_level = input_level[index]
    end
  end && true
end

#normalized ⇒ Object 



50
51
52
 
# File 'lib/active_interaction/inputs.rb', line 50

def normalized
  @normalized_inputs
end

#to_h ⇒ Hash

Turn the inputs into a Hash.

Returns:

  • (Hash) 


57
58
59
 
# File 'lib/active_interaction/inputs.rb', line 57

def to_h
  @to_h ||= @inputs.transform_values(&:value).freeze
end