Module: Clamo::Server

Defined in:
lib/clamo/server.rb

Class Method Summary collapse

Class Method Details

.dispatch_to_ruby(object:, method:, params:) ⇒ Object 



39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/clamo/server.rb', line 39

def dispatch_to_ruby(object:, method:, params:)
  case params
  when Array
    object.send method.to_sym, *params
  when Hash
    object.send method.to_sym, **params.transform_keys(&:to_sym)
  when NilClass
    object.send method.to_sym
  else
    # TODO: raise
    raise "WTF"
  end
end

.method_known?(object:, method:) ⇒ Boolean

Returns:

  • (Boolean) 


33
34
35
36
37
 
# File 'lib/clamo/server.rb', line 33

def method_known?(object:, method:)
  (object.public_methods - Object.methods)
    .map(&:to_sym)
    .include?(method.to_sym)
end

.parsed_dispatch_to_object(request:, object:, **opts) ⇒ Object 



23
24
25
26
27
28
29
30
31
 
# File 'lib/clamo/server.rb', line 23

def parsed_dispatch_to_object(request:, object:, **opts)
  response_for(request: request, object: object, **opts) do |method, params|
    dispatch_to_ruby(
      object: object,
      method: method,
      params: params # consider splating
    )
  end
end

.response_for(request:, object:, **opts, &block) ⇒ Object 



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/clamo/server.rb', line 53

def response_for(request:, object:, **opts, &block)
  case request
  when Array # batch request
    Parallel.map(request, **opts) do |item|
      response_for_single_request(
        request: item,
        object: object,
        block: block
      )
    end.compact
  when Hash # single request
    response_for_single_request(
      request: request,
      object: object,
      block: block
    )
  else
    JSONRPC.build_error_response_from(
      id: nil,
      descriptor: JSONRPC::ProtocolErrors::INVALID_REQUEST
    )
  end
end

.response_for_single_request(request:, object:, block:) ⇒ Object 



81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/clamo/server.rb', line 81

def response_for_single_request(request:, object:, block:)
  unless JSONRPC.valid_request?(request)
    return JSONRPC.build_error_response_from(
      id: request["id"],
      descriptor: JSONRPC::ProtocolErrors::INVALID_REQUEST
    )
  end

  unless JSONRPC.valid_params?(request)
    return JSONRPC.build_error_response_from(
      id: request["id"],
      descriptor: JSONRPC::ProtocolErrors::INVALID_PARAMS
    )
  end

  unless request.key?("id") # notification - no result needed
    # TODO: block.call off the current thread
    Thread.new do
      yield_to_execution(
        block: block,
        method: request["method"],
        params: request["params"]
      )
    rescue StandardError
      # TODO: add exception handler
      nil
    end

    return nil
  end

  unless method_known?(object: object, method: request["method"])
    return JSONRPC.build_error_response_from(
      id: request["id"],
      descriptor: JSONRPC::ProtocolErrors::METHOD_NOT_FOUND
    )
  end

  JSONRPC.build_result_response(
    id: request["id"],
    result: yield_to_execution(
      block: block,
      method: request["method"],
      params: request["params"]
    )
  )
end

.unparsed_dispatch_to_object(request:, object:, **opts) ⇒ Object

Clamo::Server.unparsed_dispatch_to_object(

request:  request_body,
object:   MyModule

)



12
13
14
15
16
17
18
19
20
21
 
# File 'lib/clamo/server.rb', line 12

def unparsed_dispatch_to_object(request:, object:, **opts)
  # TODO: raise unless object is present?
  begin
    parsed = JSON.parse(request)
  rescue JSON::JSONError # TODO: any error
    return JSONRPC.build_error_response_parse_error
  end

  parsed_dispatch_to_object(request: parsed, object: object, **opts)
end

.yield_to_execution(block:, method:, params:) ⇒ Object 



77
78
79
 
# File 'lib/clamo/server.rb', line 77

def yield_to_execution(block:, method:, params:)
  block.yield method, params
end