Class: EurekaBot::Resolver

Inherits:
Object
  • Object
show all
Includes:
Instrumentation
Defined in:
lib/eureka_bot/resolver.rb

Defined Under Namespace

Classes: ActionNotFound, ControllerNotFound

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Instrumentation

#instrument, prefix

Constructor Details

#initialize(message:, response: nil, logger: EurekaBot.logger) ⇒ Resolver

Returns a new instance of Resolver.



9
10
11
12
13
 
# File 'lib/eureka_bot/resolver.rb', line 9

def initialize(message:, response: nil, logger: EurekaBot.logger)
  @logger   = logger
  @message  = message
  @response = response
end

Instance Attribute Details

#controller ⇒ Object (readonly)

Returns the value of attribute controller.



7
8
9
 
# File 'lib/eureka_bot/resolver.rb', line 7

def controller
  @controller
end

#logger ⇒ Object (readonly)

Returns the value of attribute logger.



7
8
9
 
# File 'lib/eureka_bot/resolver.rb', line 7

def logger
  @logger
end

#message ⇒ Object (readonly)

Returns the value of attribute message.



7
8
9
 
# File 'lib/eureka_bot/resolver.rb', line 7

def message
  @message
end

#response ⇒ Object (readonly)

Returns the value of attribute response.



7
8
9
 
# File 'lib/eureka_bot/resolver.rb', line 7

def response
  @response
end

Instance Method Details

#controller_namespace ⇒ Object 



74
75
76
 
# File 'lib/eureka_bot/resolver.rb', line 74

def controller_namespace
  EurekaBot
end

#decode_params(str, delimiter: ':') ⇒ Object 



45
46
47
48
49
50
51
52
 
# File 'lib/eureka_bot/resolver.rb', line 45

def decode_params(str, delimiter: ':')
  action_raw, version, *params = str.split(delimiter)
  {
      action:  parameterize(action_raw),
      version: version,
      params:  {raw: params, version: version} || {}
  }
end

#encode_params(action:, version: 'v1', params: []) ⇒ Object 



54
55
56
 
# File 'lib/eureka_bot/resolver.rb', line 54

def encode_params(action:, version: 'v1', params: [])
  ([action, version] + params.map(&:to_json)).join(':')
end

#execute ⇒ Object

Raises:



27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/eureka_bot/resolver.rb', line 27

def execute
  raise ControllerNotFound.new("Can't resolve #{message}") unless resolved
  @controller = resolve_controller(resolved[:controller]).new(
      params:   resolved[:params] || {},
      message:  message,
      logger:   logger,
      response: response
  )
  instrument 'resolver.execute' do
    controller.execute(resolved[:action])
  end
  self
end

#parameterize(str) ⇒ Object 



41
42
43
 
# File 'lib/eureka_bot/resolver.rb', line 41

def parameterize(str)
  ActiveSupport::Inflector.parameterize(str, separator: '_').presence
end

#resolve ⇒ Object 



15
16
17
 
# File 'lib/eureka_bot/resolver.rb', line 15

def resolve
  nil
end

#resolve_controller(klass) ⇒ Object 



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/eureka_bot/resolver.rb', line 58

def resolve_controller(klass)
  instrument 'resolver.resolve_controller' do
    return klass if klass.is_a?(Class) && klass <= EurekaBot::Controller
    camelized = ActiveSupport::Inflector.camelize(klass)
    camelized = [camelized, 'Controller'].join unless camelized.include?('Controller')
    [
        camelized,
        [controller_namespace, camelized].join('::')
    ].each do |variant|
      constant= ActiveSupport::Inflector.safe_constantize(variant)
      return constant if constant
    end
    raise ControllerNotFound.new(klass)
  end
end

#resolved ⇒ Object 



19
20
21
22
23
24
25
 
# File 'lib/eureka_bot/resolver.rb', line 19

def resolved
  @resolved ||= begin
    resolved = resolve
    instrument 'resolver.resolved', level: Logger::INFO, result: resolved, message: message
    resolved
  end
end