class OpenApi::DSL::Api

Attributes

action_path[RW]
dry_blocks[RW]
dry_only[RW]
dry_skip[RW]
dryed[RW]
param_order[RW]

Public Class Methods

new(action_path = '', summary: nil, tags: [ ], id: nil) click to toggle source
# File lib/open_api/dsl/api.rb, line 12
def initialize(action_path = '', summary: nil, tags: [ ], id: nil)
  self.action_path = action_path
  self.dry_blocks  = [ ]
  self.merge!(summary: summary, operationId: id, tags: tags, description: '', parameters: [ ],
              requestBody: nil, responses: { }, callbacks: { }, links: { }, security: [ ], servers: [ ])
end

Public Instance Methods

auth(scheme_name, scopes: [ ])
Alias for: security_require
auth_with(scheme_name, scopes: [ ])
Alias for: security_require
body_ref(component_key) click to toggle source
# File lib/open_api/dsl/api.rb, line 75
def body_ref component_key
  self[:requestBody] = RefObj.new(:requestBody, component_key)
end
callback(event_name, http_method, callback_url, &block) click to toggle source
# File lib/open_api/dsl/api.rb, line 117
def callback event_name, http_method, callback_url, &block
  self[:callbacks].deep_merge! CallbackObj.new(event_name, http_method, callback_url, &block).process
end
data(name, type = nil, schema = { }) click to toggle source
# File lib/open_api/dsl/api.rb, line 93
def data name, type = nil, schema = { }
  schema[:type] = type if type.present?
  form data: { name => schema }
end
desc(desc) click to toggle source
# File lib/open_api/dsl/api.rb, line 27
def desc desc
  self[:description] = desc
end
Also aliased as: description
description(desc)
Alias for: desc
dry(only: nil, skip: nil, none: false) click to toggle source
# File lib/open_api/dsl/api.rb, line 33
def dry only: nil, skip: nil, none: false
  return if dry_blocks.blank? || dryed
  self.dry_skip = skip && Array(skip)
  self.dry_only = none ? [:none] : only && Array(only)
  dry_blocks.each { |blk| instance_eval(&blk) }
  self.dry_skip = self.dry_only = nil
  self.dryed = true
end
error(code, desc, media_type = nil, headers: { })
Alias for: response
examples(exp_params = :all, examples_hash)
Alias for: param_examples
form(data:, **options) click to toggle source
# File lib/open_api/dsl/api.rb, line 85
def form data:, **options
  body :form, data: data, **options
end
form!(data:, **options) click to toggle source
# File lib/open_api/dsl/api.rb, line 89
def form! data:, **options
  body! :form, data: data, **options
end
param(param_type, name, type, required, schema = { }) click to toggle source
# File lib/open_api/dsl/api.rb, line 42
def param param_type, name, type, required, schema = { }
  return if dry_skip&.include?(name) || dry_only&.exclude?(name)

  return unless schema = process_schema_input(type, schema, name)
  param_obj = ParamObj.new(name, param_type, type, required, schema)
  # The definition of the same name parameter will be overwritten
  index = self[:parameters].map(&:name).index(param_obj.name)
  index ? self[:parameters][index] = param_obj : self[:parameters] << param_obj
end
Also aliased as: parameter
param_examples(exp_params = :all, examples_hash) click to toggle source
# File lib/open_api/dsl/api.rb, line 125
def param_examples exp_params = :all, examples_hash
  exp_params = self[:parameters].map(&:name) if exp_params == :all
  self[:examples] = ExampleObj.new(examples_hash, exp_params, multiple: true).process
end
Also aliased as: examples
param_ref(component_key, *keys) click to toggle source
# File lib/open_api/dsl/api.rb, line 66
def param_ref component_key, *keys
  self[:parameters] += [component_key, *keys].map { |key| RefObj.new(:parameter, key) }
end
parameter(param_type, name, type, required, schema = { })
Alias for: param
request_body(required, media_type, data: { }) click to toggle source

options: `exp_params` and `examples`

# File lib/open_api/dsl/api.rb, line 71
def request_body required, media_type, data: { }, desc: '', **options
  (self[:requestBody] ||= RequestBodyObj.new(required, desc)).absorb(media_type, { data: data , **options })
end
resp(code, desc, media_type = nil, headers: { })
Alias for: response
response(code, desc, media_type = nil, headers: { }) click to toggle source
# File lib/open_api/dsl/api.rb, line 98
def response code, desc, media_type = nil, headers: { }, data: { }, **options
  (self[:responses][code.to_s] ||= ResponseObj.new(desc)).absorb(desc, media_type, headers: headers, data: data, **options)
end
Also aliased as: resp, error
response_ref(code_and_compkey) click to toggle source
# File lib/open_api/dsl/api.rb, line 105
def response_ref code_and_compkey # = { }
  code_and_compkey.each { |code, component_key| self[:responses][code.to_s] = RefObj.new(:response, component_key) }
end
run_dsl(dry: false, &block) click to toggle source
# File lib/open_api/dsl/api.rb, line 132
def run_dsl(dry: false, &block)
  instance_exec(&block) if block_given?
  dry() if dry

  self[:parameters].map!(&:process)
  self[:requestBody] = self[:requestBody].try(:process)
  self[:responses].each { |code, response| self[:responses][code] = response.process }
  self[:responses] = self[:responses].sort.to_h
  self.delete_if { |_, v| v.blank? }
end
security(scheme_name, scopes: [ ])
Alias for: security_require
security_require(scheme_name, scopes: [ ]) click to toggle source
# File lib/open_api/dsl/api.rb, line 109
def security_require scheme_name, scopes: [ ]
  self[:security] << { scheme_name => scopes }
end
Also aliased as: security, auth, auth_with
server(url, desc: '') click to toggle source
# File lib/open_api/dsl/api.rb, line 121
def server url, desc: ''
  self[:servers] << { url: url, description: desc }
end
this_api_is_expired!(*)
this_api_is_invalid!(*) click to toggle source
# File lib/open_api/dsl/api.rb, line 19
def this_api_is_invalid!(*)
  self[:deprecated] = true
end
this_api_is_under_repair!(*)
this_api_is_unused!(*)