Module: Fatty::Actions

Defined in:
lib/fatty/action.rb

Class Method Summary collapse

Class Method Details

.call(name, env, *args, **kwargs) ⇒ Object

Raises:



73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/fatty/action.rb', line 73

def self.call(name, env, *args, **kwargs)
  arg_str = "name: #{name}, env: #{env}, args: #{args}, kwargs: #{kwargs}"
  Fatty.debug("Action.call(#{arg_str})", tag: :action)
  key = name.to_sym
  defn = @defs[key] or raise ActionError, "Unknown action: #{key}"

  target = env.public_send(defn[:on])
  raise ActionError, "env.#{defn[:on]} is nil for action #{key}" unless target

  # Inject count: from env.counter when the target accepts it.
  if env.counter&.active? && !kwargs.key?(:count)
    meth = target.method(defn[:method])
    params = meth.parameters

    accepts_count =
      params.any? { |(kind, pname)| kind == :key && pname == :count } ||
      params.any? { |(kind, _pname)| kind == :keyrest }

    if accepts_count
      kwargs = kwargs.merge(count: env.counter.consume(default: 1))
    end
  end

  target.public_send(defn[:method], *args, **kwargs)
end

.catalog ⇒ Object 



17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/fatty/action.rb', line 17

def self.catalog
  names.map do |name|
    defn = @defs[name]
    {
      name: name.to_s,
      doc: defn[:doc],
      on: defn[:on].to_s,
      method: defn[:method].to_s,
    }
  end
end

.catalog_by_target ⇒ Object 



29
30
31
32
33
34
35
36
37
 
# File 'lib/fatty/action.rb', line 29

def self.catalog_by_target
  @defs
    .group_by { |_name, defn| defn[:on].to_s }
    .sort
    .to_h do |target, entries|
      names = entries.map { |name, _defn| name.to_s }.sort
      [target, names]
    end
end

.defs ⇒ Object 



51
52
53
 
# File 'lib/fatty/action.rb', line 51

def self.defs
  @defs
end

.lookup(name) ⇒ Object 



55
56
57
 
# File 'lib/fatty/action.rb', line 55

def self.lookup(name)
  @defs[name.to_sym]
end

.names ⇒ Object 



9
10
11
 
# File 'lib/fatty/action.rb', line 9

def self.names
  @defs.keys.sort
end

.register(name, owner:, on:, method_name: name, doc: nil) ⇒ Object

Raises:



59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/fatty/action.rb', line 59

def self.register(name, owner:, on:, method_name: name, doc: nil)
  arg_str = "Action.register: name: #{name}, on: #{on}, method_name: #{method_name}, doc: #{doc}"
  Fatty.debug("Action.register(#{arg_str})", tag: :action)
  key = name.to_sym
  raise ActionError, "action already registered for #{key}" if @defs.key?(key)

  @defs[key] = {
    owner: owner,
    on: on.to_sym,
    doc: doc,
    method: method_name.to_sym,
  }
end

.registered?(name) ⇒ Boolean

Returns:

  • (Boolean) 


99
100
101
 
# File 'lib/fatty/action.rb', line 99

def self.registered?(name)
  @defs.key?(name.to_sym)
end

.reset! ⇒ Object 



47
48
49
 
# File 'lib/fatty/action.rb', line 47

def self.reset!
  @defs.clear
end

.restore(snapshot) ⇒ Object 



43
44
45
 
# File 'lib/fatty/action.rb', line 43

def self.restore(snapshot)
  @defs = snapshot
end

.snapshot ⇒ Object 



39
40
41
 
# File 'lib/fatty/action.rb', line 39

def self.snapshot
  @defs.dup
end

.valid_names ⇒ Object 



13
14
15
 
# File 'lib/fatty/action.rb', line 13

def self.valid_names
  names.map(&:to_s)
end