Class: MemoriClient::Operation

Inherits:
Object
  • Object
show all
Defined in:
lib/memori_client/operation.rb

Instance Method Summary collapse

Constructor Details

#initialize(item, version:, key:) ⇒ Operation

Returns a new instance of Operation.



3
4
5
6
7
 
# File 'lib/memori_client/operation.rb', line 3

def initialize(item, version:, key:)
  @item = item
  @version = version
  @key = key
end

Instance Method Details

#generate_method_code(method) ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/memori_client/operation.rb', line 9

def generate_method_code(method)
  module_name = method[:module]
  method_name = method[:method_name]
  qualified_method = [module_name, method_name].join('#')

  params_list = []
  (method[:params] || {}).each do |k, required|
    if required
      params_list << "#{k}:"
    else
      params_list << "#{k}: nil"
    end
  end
  
  params_definition = (method[:spec]['parameters'] || []).map do |param|
    {
      name: param['name'],
      description: param['description'],
      required: param['required'] == true,
      type: param['schema']['type']
    }
  end
  
  payload_keys = []
  payload_required_keys = []
  
  if method[:request_body]
    params_list << "payload: {}"
  
    params_definition << {
      name: 'payload',
      description: 'request payload',
      required: false,
      type: 'Hash',
    }
  
    request_body_schema_ref = method.dig(:spec, 'requestBody', 'content', 'application/json', 'schema', '$ref')
  
    # Note:
    # capturing required keys is not exact as sometimes there are two keys where
    # only one must be present or at least one.
    # So we report requirement of the key in the documentation but we do not
    # enforce any check on the presence.
    # We validate the valid key instead
    key = request_body_schema_ref.split('/').last
    schema = MemoriClient::Swagger::SchemaStore.instance.get(key)
    required_keys = schema['required'] || []
    schema['properties'].each do |key, value|
      required = value['nullable'] == false || required_keys.include?(key)
      payload_keys << key
      payload_required_keys << key if required
      params_definition << {
        name: "payload.#{key}",
        description: '',
        required: required,
        type: value['type']&.titleize,
        indent: 2
      }
    end
  end
  
  payload_keys.sort!
  payload_required_keys.sort!
  signature = "#{method_name}(#{params_list.join(', ')})"
  
  params_list_doc = params_definition.each_with_object([]) do |param, acc|
    if param[:indent]
      prefix = " " * param[:indent]
    else
      prefix = ""
    end
    acc << "#{prefix}- `#{param[:name]}`: **#{param[:type]}** #{param[:description]}. #{param[:required] ? 'required' : 'optional' }"
  end.join("\n")
  
  optional_payload_code = ''
  if payload_keys.size > 0
    optional_payload_code = <<-EOS
    payload_keys = [
  #{payload_keys.map { |k| "        '#{k}'," }.join("\n") }
    ]
    payload_required_keys = %w[#{payload_required_keys.join(' ')}]
    validate_payload!(args[:payload], keys: payload_keys, required: payload_required_keys)
    EOS
  end
  
  output = <<-EOS
## #{method_name}
  
Summary:
#{method[:summary].gsub("\n", ' ').gsub("\r", ' ')}
  
Signature: `#{signature}`
Invokation: `client.#{@version}.#{@key.downcase}.#{signature}`
  
HTTP API: #{method[:method].upcase} #{method[:path]}`
  
  EOS
  
  if params_list_doc.size > 0
    output << <<-EOS
Parameters:
  
#{params_list_doc}
    EOS
  end
  
  output << "\n"
  
  output
end

#markdown_documentation ⇒ Object 



120
121
122
123
124
125
126
 
# File 'lib/memori_client/operation.rb', line 120

def markdown_documentation
    # #{@item[:method_name]}
    #{@item[:path]}
    <<~MARKDOWN
#{generate_method_code(@item)}
  MARKDOWN
end

#spec ⇒ Object 



128
129
130
 
# File 'lib/memori_client/operation.rb', line 128

def spec
  @item
end