module OpenApi::Objects

Constants

METADATA_MERGE

Public Class Methods

merge_metadata(metadata, merge_metadata, opts = {}) click to toggle source
# File lib/open-api/objects.rb, line 11
def merge_metadata(metadata, merge_metadata, opts = {})
  OpenApi::Utils.merge_hash(metadata, merge_metadata, opts.merge(merge_by: METADATA_MERGE))
end
resolve_refs(metadata, definitions, controller, opts = {}) click to toggle source
# File lib/open-api/objects.rb, line 15
def resolve_refs(metadata, definitions, controller, opts = {})
  resolve_proc = -> (object_name) { controller.open_api_object_metadata(object_name) }
  if metadata.is_a?(Hash)
    Hash[(metadata.map do |key, value|
      value = resolve_refs(value, definitions, controller, opts)
      if ['schema', 'items', '$ref'].include?(key.to_s) && value.respond_to?(:to_sym) &&
          !(object = resolve_ref(value.to_sym, resolve_proc)).nil?
        fail 'Expected Hash for definitions!' unless definitions.is_a?(Hash)
        object = resolve_refs(object, definitions, controller, opts)
        add_definition(definitions, value.to_sym, object)
        next [:'$ref', "#/definitions/#{value}"] if key.to_s == '$ref'
        next [key.to_sym, { :'$ref' => "#/definitions/#{value}" }]
      end
      [key, value]
    end)]
  elsif metadata.is_a?(Array)
    metadata.map do |elem|
      resolve_refs(elem, definitions, controller, opts)
    end
  else
    metadata
  end
end

Private Class Methods

add_definition(definitions, key, object) click to toggle source
# File lib/open-api/objects.rb, line 54
def add_definition(definitions, key, object)
  return if object.nil?
  json = object.to_json
  retry_index = 0
  loop do
    if definitions.include?(key)
      break if definitions[key].to_json == json
      retry_index += 1
      key = "#{key}#{retry_index}".to_sym
    else
      definitions[key] = object
      break
    end
  end
end
resolve_ref(key, resolve_proc, opts = {}) click to toggle source
# File lib/open-api/objects.rb, line 41
def resolve_ref(key, resolve_proc, opts = {})
  unless resolve_proc.respond_to?(:call) &&
      resolve_proc.respond_to?(:parameters)
    fail 'Expected proc/lambda for resolve_proc!'
  end
  proc_param_count = resolve_proc.parameters.size
  fail 'Expected 1+ parameters (object name) for resolve_proc!' if proc_param_count < 1
  object = resolve_proc.send(*([:call, key, opts][0..proc_param_count]))
  return nil if object.nil?
  fail 'Expected hash result from resolve_proc!' unless object.is_a?(Hash)
  object
end