Module: Angus::Remote::Response::Builder

Defined in:
lib/angus/remote/response/builder.rb

Class Method Summary collapse

Class Method Details

.apply_glossary(name, glossary_terms_hash) ⇒ Object

Searches for a short name in the glossary and returns the corresponding long name

If name is not a short name, returns the name

Parameters:

  • name (String)
  • glossary_terms_hash, (Hash<String, GlossaryTerm>) —

    where keys are short names

Returns:

  • long name



156
157
158
159
160
161
162
 
# File 'lib/angus/remote/response/builder.rb', line 156

def self.apply_glossary(name, glossary_terms_hash)
  if glossary_terms_hash.include?(name)
    name = glossary_terms_hash[name].long_name
  end

  return name
end

.build(status_code, body, service_code_name, version, operation_namespace, operation_code_name) ⇒ Object

Builds a Response

The r parameter should contain in the body, encoded as json, the values / objects specified in the operation response metadata

Parameters:

  • status_code (Integer) —

    HTTP status_code

  • body (String) —

    HTTP body

  • service_name (String) —

    Name of the service that the response belongs to

  • version (String) —

    Version of the service that the response belongs to

  • operation_namespace (String) —

    Namespace of the operation that the response belongs to

  • operation_name (String) —

    Name of the operation that the response belongs to

Returns:

  • A Response object that responds to the methods:

    • status

    • messages

    Also, provides one method for each value / object / array returned



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
 
# File 'lib/angus/remote/response/builder.rb', line 39

def self.build(status_code, body, service_code_name, version, operation_namespace,
               operation_code_name)
  service_definition = Angus::Remote::ServiceDirectory.service_definition(
    service_code_name, version
  )

  representations = service_definition.representations
  glossary = service_definition.glossary

  operation_definition = service_definition.operation_definition(operation_namespace,
                                                                 operation_code_name)

  json_response = JSON(body)

  response_class = build_response_class(operation_definition.name)

  response = response_class.new

  # TODO use constants
  response[:status_code] = status_code
  response[:body] = body
  response[:service_code_name] = service_code_name
  response[:service_version] = version
  response[:operation_namespace] = operation_namespace
  response[:operation_code_name] = operation_code_name

  response.status = json_response['status']
  response.messages = self.build_messages(json_response['messages'])

  representations_hash = self.representations_hash(representations)
  glossary_terms_hash = glossary.terms_hash

  operation_definition.response_elements.each do |element|
    self.build_response_method(json_response, response_class, response,
                               representations_hash, glossary_terms_hash, element)
  end

  response
end

.build_collection_from_representation(value_array, type, representations, glossary_terms_hash) ⇒ Object

Builds an array of objects that corresponds to the received type



261
262
263
264
265
266
267
268
269
270
271
 
# File 'lib/angus/remote/response/builder.rb', line 261

def self.build_collection_from_representation(value_array, type, representations,
                                              glossary_terms_hash)
  collection = []

  value_array.each do |raw_value|
    collection << build_from_representation(raw_value, type, representations,
                                            glossary_terms_hash)
  end

  collection
end

.build_from_remote_response(remote_response, service_code_name, version, operation_namespace, operation_code_name) ⇒ Object

Builds a Response based on a service’s response

The remote_response parameter should contain in the body, encoded as json, the values / objects specified in the operation response metadata.

Parameters:

  • remote_response (Http) —

    HTTP response object, must respond to methods :body and :code

  • service_name (String) —

    Name of the invoked service

  • version (String) —

    Version of the invoked service

  • operation_namespace (String) —

    Namespace of the invoked operation

  • operation_name (String) —

    Name of the invoked operation



138
139
140
141
142
143
144
145
146
 
# File 'lib/angus/remote/response/builder.rb', line 138

def self.build_from_remote_response(remote_response, service_code_name, version,
                                    operation_namespace, operation_code_name)

  status_code = remote_response.code
  body = remote_response.body

  self.build(status_code, body, service_code_name, version, operation_namespace,
             operation_code_name)
end

.build_from_representation(hash_value, type, representations, glossary_terms_hash) ⇒ Object

Receives a hash, a type and an array of representations and build an object that has one method for each attribute of the type.



200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
 
# File 'lib/angus/remote/response/builder.rb', line 200

def self.build_from_representation(hash_value, type, representations, glossary_terms_hash)
  return nil if hash_value.nil?

  representation_class = Class.new do
    include Angus::Remote::Response::Hash
  end

  representation_object = representation_class.new

  if representations.include?(type)
    representation = representations[type]
    return nil if representation.nil?
    representation.fields.each do |field|
      field_raw_value = hash_value[field.name]
      field_value = nil
      unless field_raw_value.nil? && field.required == false
        if field.type && representations.include?(field.type)
          field_value = self.build_from_representation(field_raw_value, field.type,
                                                       representations,
                                                       glossary_terms_hash)
        elsif field.elements_type
          field_value = self.build_collection_from_representation(field_raw_value,
                                                                  field.elements_type,
                                                                  representations,
                                                                  glossary_terms_hash)
        elsif field.type && field.type.to_sym == :variable
          field_value = self.build_from_variable_fields(field_raw_value)
        elsif field.type
          field_value = Angus::Unmarshalling.unmarshal_scalar(field_raw_value,
                                                                field.type.to_sym)
        end
      end

      # Don't apply the glossary to response elements
      representation_object.elements[field.name] = field_value

      # Instead, apply the glossary to method names
      getter_method_name = self.apply_glossary(field.name, glossary_terms_hash)

      representation_class.send :define_method, field.name.to_sym do
        field_value
      end
    end
  else
    if type.to_sym == :variable
      representation_object = self.build_from_variable_fields(hash_value)
    else
      begin
        representation_object = Angus::Unmarshalling.unmarshal_scalar(hash_value,
                                                                        type.to_sym)
      rescue ArgumentError
        representation_object = nil
      end
    end
  end


  return representation_object
end

.build_from_variable_fields(variable_fields_hash) ⇒ Object

Builds an object from variable fields



274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
 
# File 'lib/angus/remote/response/builder.rb', line 274

def self.build_from_variable_fields(variable_fields_hash)

  return nil if variable_fields_hash.nil?

  representation_class = Class.new do
    include Angus::Remote::Response::Hash
  end

  representation_object = representation_class.new

  variable_fields_hash.each do |key_name, field_value|
    representation_object.elements[key_name] = field_value
    representation_class.send :define_method, key_name.to_sym do
      field_value
    end
  end

  representation_object

end

.build_messages(messages) ⇒ Object

Receives an array of messages and returns an array of Message objects



185
186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/angus/remote/response/builder.rb', line 185

def self.build_messages(messages)
  messages ||= []

  messages.map do |m|
    message = Angus::Remote::Message.new
    message.description = m['dsc']
    message.key = m['key']
    message.level = m['level']

    message
  end
end

.build_response_class(operation_name) ⇒ Class

Build a response class for the operation

Parameters:

  • operation_name (String) —

    the name of the operation

Returns:



169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'lib/angus/remote/response/builder.rb', line 169

def self.build_response_class(operation_name)
  response_class = Class.new(Angus::Remote::RemoteResponse)
  response_class.class_eval <<-END
    def self.name
      "#<Response_#{operation_name.gsub(' ', '_')}>"
    end

    def self.to_s
      name
    end
  END

  response_class
end

.build_response_method(json_response, response_class, response, representations_hash, glossary_terms_hash, element) ⇒ Object

Builds the methods for each value / object / array

The r parameter should contain in the body, encoded as json, the values / objects specified in the operation response metadata



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
 
# File 'lib/angus/remote/response/builder.rb', line 83

def self.build_response_method(json_response, response_class, response,
                               representations_hash, glossary_terms_hash, element)
  if (json_response.has_key?(element.name))
    hash_value = json_response[element.name]
  elsif (element.required == false)
    hash_value = element.default
  else
    return
  end

  object_value = nil

  if element.type && representations_hash.include?(element.type)
    object_value = self.build_from_representation(hash_value, element.type,
                                                  representations_hash, glossary_terms_hash)
  elsif element.elements_type
    object_value = self.build_collection_from_representation(hash_value,
                                                             element.elements_type,
                                                             representations_hash,
                                                             glossary_terms_hash)
  elsif element.type && element.type.to_sym == :variable
    object_value = self.build_from_variable_fields(hash_value)
  elsif element.type
    begin
      object_value = Angus::Unmarshalling.unmarshal_scalar(hash_value,
                                                             element.type.to_sym)
    rescue ArgumentError
      object_value = nil
    end
  end

  # Don't apply the glossary to response elements
  response.elements[element.name] = object_value

  # Instead, apply the glossary to method names
  getter_method_name = self.apply_glossary(element.name, glossary_terms_hash)

  response_class.send :define_method, getter_method_name do
    object_value
  end
end

.representations_hash(representations) ⇒ Object

Receives an array of representations and returns a hash of representations where the keys are the representation’s names and the values are the representations



297
298
299
300
301
302
303
 
# File 'lib/angus/remote/response/builder.rb', line 297

def self.representations_hash(representations)
  hash = {}
  representations.each do |representation|
    hash[representation.name] = representation
  end
  hash
end