openapi-sourcetools 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 783a57d4ca224bb9710cb523d3ee2fd2dee0e821cb7382ffc32fa9b8cb36b4f1
-  data.tar.gz: b7c02ac6cd2e30fc4f9f5d9fb87bfcd84b8f60b76007e82d82a1a1bfb7f37e42
+  metadata.gz: 93117ebfa33920b762da40afe48264ead793574ad336628487d3cfb3b6019987
+  data.tar.gz: 67cb3400cd879b3625e58b72db11cfc860a87179d069ff341a6202391f8d61f5
 SHA512:
-  metadata.gz: eec2859f712324b85f9db32f5c92d4e3947a80021f9bf920f287f9b01a2a56ab7d20e3f2b5d30e039a2e606e57b4ca0f0b5872961e91f1898c44c402eade14ef
-  data.tar.gz: 72bbafa47688fd1eb3dd78d1ff0782d8e1a3510e541e4ad4f4e49ceec056cedaf9c6ebbbbe4dd9c7c6b446f3c0dd4c22d54a23afb0bacfa8f5dea33fe751e55a
+  metadata.gz: af4681c719424375326d4149ede787f0d6a58d33ff28082d7c1f7b00db4b40186f6406bfe99707012aeae0ac03d4504fb14cd49b6e587f55d91c1f2cb353a3b3
+  data.tar.gz: f6c84c0a9e6b20040fefa9611c8abf211abc1fb65c6a3c3041ce1f96f3b3482fa1789eb2eb16460c5a1d892d56fd843164ae4d7dfb9c4cdb6e3a13f26977d323

data/bin/openapi-addsecurityschemes

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Copyright © 2025 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+require_relative '../lib/openapi/sourcetools/apiobjects'
+require_relative '../lib/openapi/sourcetools/common'
+require 'optparse'
+include OpenAPISourceTools
+
+
+def add_combinations(combinations, security)
+  security.each do |s|
+    subset = s.keys.sort!
+    next if subset.empty?
+    combinations.add(subset)
+  end
+end
+
+def gather_security(doc)
+  combinations = Set.new
+  security = doc.fetch('security', [])
+  add_combinations(combinations, security)
+  operation_objects = []
+  doc.fetch('paths', {}).each_value do |item|
+    oos = ApiObjects.operation_objects(item).values
+    oos.each do |oo|
+      add_combinations(combinations, oo['security'] || [])
+      operation_objects.push(oo)
+    end
+  end
+  [security, operation_objects, combinations]
+end
+
+def check_security(doc, combinations)
+  singles = Set.new
+  combinations.each do |c|
+    c.each do |s|
+      singles.add(s)
+    end
+  end
+  available = Set.new((doc.dig('components', 'securitySchemes') || {}).keys)
+  missing = false
+  singles.each do |s|
+    unless available.include?(s)
+      $stderr.puts "Security scheme unavailable: #{s}"
+      missing = true
+    end
+  end
+  !missing
+end
+
+def namelist2security(item)
+  item.keys.sort!.join(' ')
+end
+
+def security2hash(security)
+  out = {}
+  security.each { |s| out[namelist2security(s)] = s }
+  out
+end
+
+def add_security_to_operations(operation_objects, top_level_security)
+  operation_objects.each do |oo|
+    sec = security2hash(oo['security'] || top_level_security)
+    oo['security'] = sec.keys.sort!.map { |k| Marshal.load(Marshal.dump(sec[k])) }
+  end
+end
+
+def main
+  input_name = nil
+  output_name = nil
+
+  parser = OptionParser.new do |opts|
+    opts.summary_indent = '  '
+    opts.summary_width = 26
+    opts.banner = 'Usage: openapi-addsecurityschemes [options]'
+    opts.separator ''
+    opts.separator 'Options:'
+    opts.on('-i', '--input FILE', 'Read API spec from FILE, not stdin.') do |f|
+      input_name = f
+    end
+    opts.on('-o', '--output FILE', 'Output to FILE, not stdout.') do |f|
+      output_name = f
+    end
+    opts.on('-h', '--help', 'Print this help and exit.') do
+      $stdout.puts %(#{opts}
+
+Loads API document in OpenAPI format and moves security schemes under components and
+replaces the original with reference.
+)
+      exit 0
+    end
+  end
+  parser.order!
+
+  doc = Common.load_source(input_name)
+  return 2 if doc.nil?
+
+  security, operation_objects, combinations = gather_security(doc)
+  return 4 unless check_security(doc, combinations)
+  add_security_to_operations(operation_objects, security)
+
+  Common.dump_result(output_name, doc, 3)
+end
+
+exit(main) unless defined?($unit_test)

data/bin/openapi-generate

@@ -18,7 +18,7 @@ def main
 
   parser = OptionParser.new do |opts|
     opts.summary_indent = '  '
-    opts.summary_width = 26
+    opts.summary_width = 20
     opts.banner = 'Usage: openapi-generate [options] generator-names...'
     opts.separator ''
     opts.separator 'Options:'
@@ -37,7 +37,7 @@ Loads API document in OpenAPI format and generator names. Built-in generator
 or additional document loaders accept the following:
 #{OpenAPISourceTools::Loaders.document.strip}
 
-During load each generator can add and modify tasks via Gen module:
+During load each generator can add and modify tasks via Gen singleton:
 #{Gen.document.strip}
 
 After all generators have loaded succesfully, tasks are run.
@@ -48,10 +48,10 @@ After all generators have loaded succesfully, tasks are run.
   parser.order!
 
   return OpenAPISourceTools::Common.aargh('Generator names must be given.', 1) if ARGV.empty?
+  return OpenAPISourceTools::Common.aargh("Not a directory: #{output_dir}", 3) unless File.directory?(output_dir)
 
   a = OpenAPISourceTools::Common.load_source(input_name)
   return 2 if a.nil?
-  return OpenAPISourceTools::Common.aargh("Not a directory: #{output_dir}", 3) unless File.directory?(output_dir)
   gen = OpenAPISourceTools::Generator.new(a, input_name, output_dir, config_prefix)
   ec = gen.load(ARGV)
   return ec unless ec.zero?

data/lib/openapi/sourcetools/gen.rb

@@ -9,97 +9,77 @@ require_relative 'docs'
 require_relative 'output'
 require_relative 'config'
 require 'deep_merge'
-
+require 'singleton'
 
 # The generation module that contains things visible to tasks.
-module Gen
+class Gen
+  include Singleton
+
+  @docsrc = []
   def self.add_doc(symbol, docstr)
-    return if docstr.nil?
-    @docsrc = [] unless instance_variable_defined?('@docsrc')
     @docsrc.push("- #{symbol} : #{docstr}")
   end
   private_class_method :add_doc
 
-  def self.read_attr(symbol, default)
-    return if symbol.nil?
+  def self.attrib_reader(symbol, docstr, initial_value = nil)
+    add_doc(symbol, docstr)
     attr_reader(symbol)
-    module_function(symbol)
-    instance_variable_set("@#{symbol}", default)
+    instance_eval("def #{symbol}; Gen.instance.#{symbol}; end")
+    Gen.instance.instance_variable_set("@#{symbol}", initial_value) unless initial_value.nil?
   end
-  private_class_method :read_attr
+  private_class_method :attrib_reader
 
-  def self.mod_attr2_reader(symbol, symbol2, docstr = nil, default = nil)
-    read_attr(symbol, default)
-    read_attr(symbol2, default)
+  def self.attrib_accessor(symbol, docstr, initial_value = nil)
     add_doc(symbol, docstr)
-  end
-  private_class_method :mod_attr2_reader
-
-  def self.mod_attr_reader(symbol, docstr = nil, default = nil)
-    mod_attr2_reader(symbol, nil, docstr, default)
-  end
-  private_class_method :mod_attr_reader
-
-  def self.rw_attr(symbol, default)
     attr_accessor(symbol)
-    module_function(symbol)
-    s = symbol.to_s
-    module_function((s + '=').to_sym)
-    instance_variable_set("@#{s}", default)
+    instance_eval("def #{symbol}; Gen.instance.#{symbol}; end")
+    instance_eval("def #{symbol}=(v); Gen.instance.#{symbol} = v; end")
+    Gen.instance.instance_variable_set("@#{symbol}", initial_value) unless initial_value.nil?
   end
-  private_class_method :rw_attr
-
-  def self.mod_attr2_accessor(symbol, symbol2, docstr = nil, default = nil)
-    rw_attr(symbol, default)
-    rw_attr(symbol2, default) unless symbol2.nil?
-    add_doc(symbol, docstr)
-  end
-  private_class_method :mod_attr2_accessor
-
-  def self.mod_attr_accessor(symbol, docstr = nil, default = nil)
-    mod_attr2_accessor(symbol, nil, docstr, default)
-  end
-  private_class_method :mod_attr_accessor
-
-  mod_attr_reader :doc, 'OpenAPI document.'
-  mod_attr_reader :outdir, 'Output directory name.'
-  mod_attr_reader :d, 'Other documents object.', OpenAPISourceTools::Docs.new
-  mod_attr_reader :wd, 'Original working directory', Dir.pwd
-  mod_attr_reader :configuration, 'Generator internal configuration'
-  mod_attr_accessor :config, 'Configuration file name for next gem or Ruby file.'
-  mod_attr_accessor :separator, 'Key separator in config file names.', nil
-  mod_attr_accessor :in_name, 'OpenAPI document name, nil if stdin.'
-  mod_attr_accessor :in_basename, 'OpenAPI document basename, nil if stdin.'
-  mod_attr_reader :g, 'Hash for storing values visible to all tasks.', {}
-  mod_attr_accessor :x, 'Hash for storing values visible to tasks from processor.', {}
-  mod_attr_accessor :h, 'Instance of class with helper methods.'
-  mod_attr_accessor :tasks, 'Tasks array.', []
-  mod_attr2_accessor :task, :t, 'Current task instance.'
-  mod_attr_accessor :task_index, 'Current task index.'
-  mod_attr_accessor :loaders, 'Array of processor loader methods.', []
-  mod_attr_accessor :output, 'Output-formatting helper.', OpenAPISourceTools::Output.new
-
-  def self.load_config(config_prefix)
+  private_class_method :attrib_accessor
+
+  attrib_reader :doc, 'OpenAPI document.'
+  attrib_reader :outdir, 'Output directory name.'
+  attrib_reader :d, 'Other documents object.', OpenAPISourceTools::Docs.new
+  attrib_reader :wd, 'Original working directory', Dir.pwd
+  attrib_reader :configuration, 'Generator internal configuration'
+  attrib_accessor :config, 'Configuration file name for next gem or Ruby file.'
+  attrib_accessor :separator, 'Key separator in config file names.'
+  attrib_accessor :in_name, 'OpenAPI document name, nil if stdin.'
+  attrib_accessor :in_basename, 'OpenAPI document basename, nil if stdin.'
+  attrib_reader :g, 'Hash for storing values visible to all tasks.', {}
+  attrib_accessor :x, 'Hash for storing values visible to tasks from processor.', {}
+  attrib_accessor :h, 'Instance of class with helper methods.'
+  attrib_accessor :tasks, 'Tasks array.', []
+  attrib_accessor :t, 'Current task instance.'
+  attrib_accessor :task_index, 'Current task index.'
+  attrib_accessor :loaders, 'Array of processor loader methods.', []
+  attrib_accessor :output, 'Output-formatting helper.', OpenAPISourceTools::Output.new
+
+  def self.load_config(name_prefix, extensions = [ '.*' ])
     cfg = {}
-    cfgs = OpenAPISourceTools::ConfigLoader.find_files(name_prefix: config_prefix)
+    cfgs = OpenAPISourceTools::ConfigLoader.find_files(name_prefix:, extensions:)
     cfgs = OpenAPISourceTools::ConfigLoader.read_contents(cfgs)
     cfgs.each { |c| cfg.deep_merge!(c) }
     cfg
   end
-  private_class_method :load_config
 
-  def self.setup(document_content, input_name, output_directory, config_prefix)
+  def setup(document_content, input_name, output_directory, config_prefix)
     @doc = document_content
     @outdir = output_directory
     unless input_name.nil?
       @in_name = File.basename(input_name)
       @in_basename = File.basename(input_name, '.*')
     end
-    @configuration = load_config(config_prefix)
+    @configuration = Gen.load_config(config_prefix)
     add_task(task: OpenAPISourceTools::HelperTask.new)
   end
 
-  def self.add_task(task:, name: nil, executable: false, x: nil)
+  def self.setup(document_content, input_name, output_directory, config_prefix)
+    Gen.instance.setup(document_content, input_name, output_directory, config_prefix)
+  end
+
+  def add_task(task:, name: nil, executable: false, x: nil)
     @tasks.push(task)
     # Since this method allows the user to pass their own task type instance,
     # assign optional values with defaults only when clearly given.
@@ -108,15 +88,27 @@ module Gen
     @tasks.last.x = x unless x.nil?
   end
 
-  def self.add_write_content(name:, content:, executable: false)
+  def self.add_task(task:, name: nil, executable: false, x: nil)
+    Gen.instance.add_task(task:, name:, executable:, x:)
+  end
+
+  def add_write_content(name:, content:, executable: false)
     add_task(task: OpenAPISourceTools::WriteTask.new(name, content, executable))
   end
 
-  def self.add(source:, template: nil, template_name: nil, name: nil, executable: false, x: nil)
+  def self.add_write_content(name:, content:, executable: false)
+    Gen.instance.add_write_content(name:, content:, executable:)
+  end
+
+  def add(source:, template: nil, template_name: nil, name: nil, executable: false, x: nil)
     add_task(task: OpenAPISourceTools::Task.new(source, template, template_name),
       name:, executable:, x:)
   end
 
+  def self.add(source:, template: nil, template_name: nil, name: nil, executable: false, x: nil)
+    Gen.instance.add(source:, template:, template_name:, name:, executable:, x:)
+  end
+
   def self.document
     @docsrc.join("\n") + %(
 - add_task(task:, name: nil, executable: false, x: nil) : Adds task object.

data/lib/openapi/sourcetools/generate.rb

@@ -78,7 +78,6 @@ module OpenAPISourceTools
       Gen.task_index = 0
       while Gen.task_index < Gen.tasks.size
         Gen.t = Gen.tasks[Gen.task_index]
-        Gen.task = Gen.t
         out = generate(Gen.t)
         Gen.task_index += 1
         return out if out.is_a?(Integer)

data/lib/openapi/sourcetools/loaders.rb

@@ -4,6 +4,7 @@
 # Licensed under Universal Permissive License. See LICENSE.txt.
 
 require_relative 'task'
+require_relative 'gen'
 
 
 # Original loader functions. These are accessible via Gen.loaders. New loaders
@@ -33,19 +34,17 @@ module OpenAPISourceTools
       true
     end
 
-    REREQ_PREFIX = 'rereq:'
+    EVAL_PREFIX = 'eval:'
 
-    def self.rereq_loader(name)
-      return false unless name.downcase.start_with?(REREQ_PREFIX)
+    def self.eval_loader(name)
+      return false unless name.downcase.start_with?(EVAL_PREFIX)
       begin
         t = OpenAPISourceTools::RestoreProcessorStorage.new({})
         Gen.tasks.push(t)
-        code = name.slice(REREQ_PREFIX.size...name.size)
+        code = name.slice(EVAL_PREFIX.size...name.size)
         eval(code)
         Gen.config = nil
         t.x = Gen.x # In case setup code replaced the object.
-      rescue LoadError => e
-        raise StandardError, "Failed to require again #{name}\n#{e}"
       rescue Exception => e
         raise StandardError, "Problem with #{name}\n#{e}\n#{e.backtrace.join("\n")}"
       end
@@ -64,11 +63,11 @@ module OpenAPISourceTools
         Gen.tasks.push(t)
         base = File.basename(name)
         Gen.config = base[0..-4] if Gen.config.nil?
-        require(File.join(Dir.pwd, base))
+        load(File.join(Dir.pwd, base))
         Gen.config = nil
         t.x = Gen.x # In case setup code replaced the object.
       rescue LoadError => e
-        raise StandardError, "Failed to require #{name}\n#{e}"
+        raise StandardError, "Failed to load #{name}\n#{e}"
       rescue Exception => e
         raise StandardError, "Problem with #{name}\n#{e}\n#{e.backtrace.join("\n")}"
       end
@@ -139,7 +138,7 @@ module OpenAPISourceTools
     def self.loaders
       [
         method(:req_loader),
-        method(:rereq_loader),
+        method(:eval_loader),
         method(:ruby_loader),
         method(:yaml_loader),
         method(:bin_loader),
@@ -151,7 +150,7 @@ module OpenAPISourceTools
     def self.document
       <<EOB
 - #{Loaders::REQ_PREFIX}req_name : requires the gem.
-- #{Loaders::REREQ_PREFIX}code : runs code to add gem tasks again.
+- #{Loaders::EVAL_PREFIX}code : runs code to add gem tasks again.
 - ruby_file#{Loaders::RUBY_EXT} : changes to Ruby file directory and requires the file.
 - #{Loaders::YAML_PREFIX}name:filename : Loads YAML file into Gen.d.name.
 - name:filename.{#{(Loaders::YAML_EXTS.map { |s| s[1...s.size] }).join('|')}} : Loads YAML file into Gen.d.name.

data/lib/openapi/sourcetools/version.rb

@@ -5,7 +5,7 @@
 
 module OpenAPISourceTools
   NAME = 'openapi-sourcetools'
-  VERSION = '0.8.0'
+  VERSION = '0.8.1'
 
   def self.info(separator = ': ')
     "#{NAME}#{separator}#{VERSION}"

data/lib/openapi/sourcetools.rb

@@ -6,6 +6,7 @@
 require_relative 'sourcetools/task'
 require_relative 'sourcetools/config'
 require_relative 'sourcetools/version'
+require_relative 'sourcetools/apiobjects'
 # Other modules or classes are exposed via Gen attributes as class instances as needed.
 # Docs is only needed for run-time storage of whatever loaders can handle.
 # Loaders array is exposed and can be added to at run-time.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openapi-sourcetools
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Ismo Kärkkäinen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-28 00:00:00.000000000 Z
+date: 2025-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deep_merge
@@ -41,6 +41,7 @@ executables:
 - openapi-addparameters
 - openapi-addresponses
 - openapi-addschemas
+- openapi-addsecurityschemes
 - openapi-checkschemas
 - openapi-frequencies
 - openapi-generate
@@ -55,6 +56,7 @@ files:
 - bin/openapi-addparameters
 - bin/openapi-addresponses
 - bin/openapi-addschemas
+- bin/openapi-addsecurityschemes
 - bin/openapi-checkschemas
 - bin/openapi-frequencies
 - bin/openapi-generate
@@ -71,7 +73,6 @@ files:
 - lib/openapi/sourcetools/helper.rb
 - lib/openapi/sourcetools/loaders.rb
 - lib/openapi/sourcetools/output.rb
-- lib/openapi/sourcetools/securityschemes.rb
 - lib/openapi/sourcetools/task.rb
 - lib/openapi/sourcetools/version.rb
 homepage: https://xn--ismo-krkkinen-gfbd.fi/openapi-sourcetools/index.html

data/lib/openapi/sourcetools/securityschemes.rb

@@ -1,268 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright © 2024-2025 Ismo Kärkkäinen
-# Licensed under Universal Permissive License. See LICENSE.txt.
-
-require_relative 'task'
-require 'yaml'
-
-
-module OpenAPISourceTools
-  # Class that contains security scheme objects and what headers
-  # and parameters are added to the request when the scheme is used.
-  class SecuritySchemeInfo
-    include Comparable
-
-    attr_reader :headers, :parameters, :query_parameters, :cookies
-
-    def initialize(security_scheme = {}, scheme_templates = [])
-      @headers = {}
-      @parameters = {}
-      @query_parameters = {}
-      @cookies = {}
-      scheme_templates.each do |template|
-        s = template['scheme']
-        match = true
-        s.each do |k, v|
-          unless v == security_scheme[k]
-            match = false
-            break
-          end
-        end
-        next unless match
-        o = template['output']
-        fill_in(@headers, o['headers'] || {}, security_scheme)
-        fill_in(@parameters, o['parameters'] || {}, security_scheme)
-        fill_in(@query_parameters, o['query_parameters'] || {}, security_scheme)
-        fill_in(@cookies, o['cookies'] || {}, security_scheme)
-        break
-      end
-    end
-
-    def fill_in(output, source, scheme)
-      source.each do |k, v|
-        if k.start_with?('<') && k.end_with?('>')
-          scheme_key = k[1..-2]
-          scheme_value = scheme[scheme_key]
-          raise "Missing security scheme value for #{scheme_key}" if scheme_value.nil?
-          output[scheme_value] = v
-        else
-          output[k] = v
-        end
-      end
-    end
-
-    def merge!(other)
-      @headers.merge!(other.headers)
-      @parameters.merge!(other.parameters)
-      @query_parameters.merge!(other.query_parameters)
-      @cookies.merge!(other.cookies)
-    end
-
-    def merge(other)
-      out = SecuritySchemeInfo.new({}, [])
-      out.merge!(self)
-      out.merge!(other)
-      out
-    end
-
-    def <=>(other)
-      # Only really interested in equality.
-      @headers <=> other.headers || @parameters <=> other.parameters || @query_parameters <=> other.query_parameters || @cookies <=> other.cookies
-    end
-  end
-
-  class ScopedSecuritySchemeInfo
-    include Comparable
-
-    attr_reader :ssi, :scopes
-
-    def initialize(ssi, scopes)
-      @ssi = ssi
-      @scopes = scopes
-    end
-
-    def merge(other)
-      @ssi = @ssi.merge(other.ssi)
-      @scopes = @scopes.concat(other.scopes).uniq
-    end
-
-    def <=>(other)
-      # Only really interested in equality.
-      @ssi <=> other.ssi || @scopes <=> other.scopes
-    end
-  end
-
-  # Helper class for dealing with securitySchemes.
-  # Adds :security key to each operation object and to root.
-  # They contain the used securitySchemes in use and the security schemes
-  # in effect for that operation.
-  class SecuritySchemesTask
-    include TaskInterface
-
-    def default_configuration
-      # type apiKey, name, in.
-      # type http, scheme, bearerFormat.
-      # type mutualTLS, beyond the scope of code templates.
-      # type oauth2, flows object.
-      # type openIdConnect, openIdConnectUrl. More for login?
-      YAML.safe_load(%q(---
-security_schemes:
-- scheme:
-    type: apiKey
-    in: header
-  output:
-    headers:
-      '<name>': string
-- scheme:
-    type: apiKey
-    in: query
-  output:
-    parameters:
-      '<name>': string
-- scheme:
-    type: apiKey
-    in: query
-  output:
-    query_parameters:
-      '<name>': string
-- scheme:
-    type: apiKey
-    in: cookie
-  output:
-    cookies:
-     '<name>': true
-- scheme:
-    type: http
-    scheme: basic
-  output:
-    headers:
-      Authorization: string
-- scheme:
-    type: http
-    scheme: bearer
-  output:
-    headers:
-      Authorization: string
-- scheme:
-    type: mutualTLS
-  output: {}
-- scheme:
-    type: oauth2
-  output:
-    headers:
-      Authorization: string
-- scheme:
-    type: openIdConnect
-  output:
-    headers:
-      Authorization: string
-))
-    end
-
-    def convert_security_schemes(doc)
-      ss = doc.dig('components', 'securitySchemes')
-      return nil if ss.nil?
-      # Should create unique objects. Different name may lead to same object.
-      out = {}
-      ss.each do |name, security_scheme|
-        out[name] = SecuritySchemeInfo.new(security_scheme)
-      end
-      out
-    end
-
-    def operation_object_security(doc, schemes)
-      # Find all operation objects and security in effect.
-      all_ops = []
-      seen_secs = Set.new
-      root_sec = doc['security'] || []
-      not_method = %w[parameters servers summary description]
-      doc['paths'].each_value do |path_item|
-        path_sec = path_item['security'] || root_sec
-        path_item.each do |method, op|
-          next if not_method.include?(method)
-          op_sec = op['security'] || path_sec
-          all_ops.push([ op, op_sec ])
-          op_sec.each do |security_requirement|
-            names = security_requirement.keys
-            seen_secs.merge(names)
-            if names.empty? && !schemes.key?('')
-              schemes[''] = SecuritySchemeInfo.new
-            end
-          end
-        end
-      end
-      # Check that all seen secs names have a scheme. Report all in one place.
-      missing = false
-      seen_secs.to_a.sort!.each do |name|
-        unless schemes.key?(name)
-          missing = true
-          warn("#/components/securitySchemes is missing: #{name}")
-        end
-      end
-      return 1 if missing
-      # Now we know all individual parts are available.
-      # Map security arrays of objects to arrays of arrays.
-      all_scopeds = [] # For having just one instance for unique data combination.
-      all_ops.each do |pair|
-        sec = pair.second.map do |sec_req|
-          keys = sec_req.keys.sort!
-          values = keys.map { |name| sec_req[name].sort! }
-          if keys.empty?
-            keys = [ '' ]
-            values = [ [] ]
-          end
-          s3is = []
-          keys.size.times do |idx|
-            name = keys[idx]
-            scopes = values[idx]
-            s3i = ScopedSecuritySchemeInfo.new(schemes[name], scopes)
-            idx = all_scopeds.index(s3i)
-            if idx.nil?
-              all_scopeds.push(s3i)
-            else
-              s3i = all_scopeds(idx) # Use the same instance everywhere.
-            end
-            s3is.push(s3i)
-          end
-          s3is
-        end
-        pair.first[:security] = sec # Arrays of ScopedSecuritySchemeInfo.
-        # When individual objects are not needed, provide merged together items.
-        all_merged = []
-        pair.first[:security_merged] = sec.map do |s3is| # ScopedSecuritySchemeInfos.
-          m = s3is.first
-          s3is[1..].each do |s3i|
-            m = m.merge(s3i)
-          end
-          idx = all_merged.index(m)
-          if idx.nil?
-            all_merged.push(m)
-          else
-            m = all_merged[idx] # Use the same instance everywhere.
-          end
-          m
-        end
-      end
-      all_merged.map(&:ssi).uniq.sort!
-    end
-
-    def generate(_context_binding)
-      # Get security_schemes from config, append defaults to it.
-      scheme_templates = gen.configuration['security_schemes'] || []
-      scheme_templates.concat(default_configuration['security_schemes'])
-      simple_schemes = convert_security_schemes(Gen.doc)
-      # For all operation objects, add :security array with all used schemes.
-      merged_schemes = operation_object_security(Gen.doc, simple_schemes || {})
-      return merged_schemes if merged_schemes.is_a?(Integer)
-      Gen.doc[:securitySchemes] = simple_schemes unless simple_schemes.nil?
-      Gen.doc[:securitySchemes_merged] = merged_schemes unless merged_schemes.empty?
-    end
-
-    def discard
-      true
-    end
-
-    COMPONENTS = '#/components/'
-  end
-end