openapi-sourcetools 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 783a57d4ca224bb9710cb523d3ee2fd2dee0e821cb7382ffc32fa9b8cb36b4f1
-  data.tar.gz: b7c02ac6cd2e30fc4f9f5d9fb87bfcd84b8f60b76007e82d82a1a1bfb7f37e42
+  metadata.gz: 44ff7d64b4781fdfbab07060f6faa294a8092e342530e6cde786e50ff8f69db1
+  data.tar.gz: 893e593407c4734e67c83bffe77a67bb55b2ecef3970620a416580fd33109437
 SHA512:
-  metadata.gz: eec2859f712324b85f9db32f5c92d4e3947a80021f9bf920f287f9b01a2a56ab7d20e3f2b5d30e039a2e606e57b4ca0f0b5872961e91f1898c44c402eade14ef
-  data.tar.gz: 72bbafa47688fd1eb3dd78d1ff0782d8e1a3510e541e4ad4f4e49ceec056cedaf9c6ebbbbe4dd9c7c6b446f3c0dd4c22d54a23afb0bacfa8f5dea33fe751e55a
+  metadata.gz: 741c12063a6d5df5d090f26b80c60a7810083537076573cb10f9ba5a3ca3afc8109ab6faa305707139c881a7efa1f478d7d0de562db67b44f93c0329ae8263e4
+  data.tar.gz: 9e1c2bc87442258d75517beb13f99c1e0b210b7074ee622db8057e1e4ebf17c253538ba52b893b0f148baa21188a306976a9783d778e92dd769caee6eb84aef6

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/bin/openapi-patterntests

@@ -0,0 +1,159 @@
+#!/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/common'
+require 'optparse'
+include OpenAPISourceTools
+
+def key(item)
+  "#{item['pattern']}::#{item.fetch('minLength', 0)}::#{item.fetch('maxLength', 'inf')}"
+end
+
+def find_patterns(doc, pmm)
+  if doc.is_a?(Hash)
+    if doc.key?('pattern')
+      item = { 'pattern' => doc['pattern'] }
+      item['minLength'] = doc['minLength'] if doc.key?('minLength')
+      item['maxLength'] = doc['maxLength'] if doc.key?('maxLength')
+      pmm[key(doc)] = item
+      return
+    end
+    doc = doc.values
+  end
+  doc.each { |v| find_patterns(v, pmm) } if doc.is_a?(Array)
+end
+
+def pattern_list2hash(list)
+  pmms = {}
+  list.each { |item| pmms[key(item)] = item }
+  pmms
+end
+
+def add_strings(item)
+  passes = []
+  fails = []
+  min_len = item.fetch('minLength', 0)
+  fails.push('f' * (min_len - 1)) unless min_len.zero?
+  max_len = item['maxLength']
+  fails.push('f' * (max_len + 1)) unless max_len.nil?
+  # Fails within length limits require considering the pattern.
+  # All passes require considering the pattern.
+  item['pass'] = passes
+  item['fail'] = fails
+end
+
+def merge_arrays(current, past)
+  if current.is_a?(Array)
+    if past.is_a?(Array)
+      return current.concat(past)
+    end
+    current
+  elsif past.is_a?(Array)
+    past
+  else
+    false
+  end
+end
+
+def merge_existing(pmms, existing)
+  pmms.each do |k, v|
+    ex = existing[k]
+    next if ex.nil?
+    %w[pass fail].each do |arr|
+      m = merge_arrays(v[arr], ex[arr])
+      v[arr] = m.is_a?(Array) ? m.sort!.uniq : m
+    end
+    ex.each do |ek, ev|
+      v[ek] = ev unless v.key?(ek)
+    end
+  end
+end
+
+def add_removed(pmms, existing)
+  existing.each { |k, v| pmms[k] = v unless pmms.key?(k) }
+end
+
+def compare(a, b)
+  d = a['pattern'] <=> b['pattern']
+  return d unless d.zero?
+  d = a.fetch('minLength', 0) <=> b.fetch('minLength', 0)
+  return d unless d.zero?
+  a.fetch('maxLength', Float::INFINITY) <=> b.fetch('maxLength', Float::INFINITY)
+end
+
+def pattern_hash2list(pmms)
+  pmms.values.sort { |a, b| compare(a, b) }
+end
+
+def main
+  array_name = 'patterns'
+  input_name = nil
+  output_name = nil
+  source_tests = nil
+  keep = false
+  chain = []
+
+  parser = OptionParser.new do |opts|
+    opts.summary_indent = '  '
+    opts.summary_width = 20
+    opts.banner = 'Usage: openapi-patterntests [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('-t', '--tests FILE', 'Read existing tests from FILE.') do |f|
+      source_tests = f
+    end
+    opts.on('-u', '--under STR', %(Top-level "#{array_name}" is under dot-separated keys.)) do |s|
+      chain = s.split('.').reject(&:empty?)
+    end
+    opts.on('-k', '--[no-]keep', "Keep missing test patterns, default = #{Common.yesno(keep)}.") do |b|
+      keep = b
+    end
+    opts.on('-h', '--help', 'Print this help and exit.') do
+      $stdout.puts %(#{opts}
+
+Loads API document in OpenAPI format, extracts string patterns, and outputs
+a YAML file that contains mapping from patterns to matching and not mathcing
+strings for testing generated code.
+)
+      exit 0
+    end
+  end
+  parser.order!
+
+  doc = Common.load_source(input_name)
+  return 2 if doc.nil?
+
+  if source_tests.nil?
+    ex = {}
+    pats = []
+  else
+    ex = Common.load_source(source_tests)
+    return 2 if ex.nil?
+    parent = chain.empty? ? ex : ex.dig(*chain)
+    return Common.aargh("Key chain #{chain.join('.')} not found in source tests.", 4) if parent.nil?
+    pats = parent[array_name] || []
+  end
+  chain.push(array_name)
+
+  existing = pattern_list2hash(pats)
+  pmms = {}
+  find_patterns(doc, pmms)
+  pmms.each_value { |item| add_strings(item) }
+  merge_existing(pmms, existing)
+  add_removed(pmms, existing) if keep
+  pats = pattern_hash2list(pmms)
+
+  Common.bury(ex, chain, pats)
+  Common.dump_result(output_name, ex, 3)
+end
+
+exit(main) if defined?($unit_test).nil?

data/lib/openapi/sourcetools/apiobjects.rb

@@ -187,5 +187,69 @@ module OpenAPISourceTools
       end
       out
     end
+
+    # Single server variable object.
+    class ServerVariableObject
+      include Comparable
+
+      attr_reader :name, :default, :enum
+
+      def initialize(name, variable_object)
+        @name = name
+        @default = variable_object['default']
+        @enum = (variable_object['enum'] || []).sort!
+      end
+
+      def <=>(other)
+        d = @name <=> other.name
+        return d unless d.zero?
+        d = @default <=> other.default
+        return d unless d.zero?
+        @enum <=> other.enum
+      end
+    end
+
+    # Single server object with variables.
+    class ServerObject
+      include Comparable
+
+      attr_reader :url, :variables
+
+      def initialize(server_object)
+        @url = server_object['url']
+        vs = server_object['variables'] || {}
+        @variables = vs.keys.sort!.map do |name|
+          obj = vs[name]
+          ServerVariableObject.new(name, obj)
+        end
+      end
+
+      def <=>(other)
+        d = @url <=> other.url
+        return d unless d.zero?
+        if @variables.nil? || other.variables.nil?
+          return -1 if @variables.nil?
+          return 1 if other.variables.nil?
+        end
+        @variables <=> other.variables
+      end
+    end
+
+    # Combines servers array with set identifier.
+    class ServerAlternatives
+      include Comparable
+
+      attr_reader :servers
+      attr_accessor :set_id
+
+      def initialize(server_objects)
+        @servers = server_objects.map { |so| ServerObject.new(so) }
+        @servers.sort!
+      end
+
+      def <=>(other)
+        @servers <=> other.servers
+      end
+    end
   end
 end

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/helper.rb

@@ -76,6 +76,47 @@ module OpenAPISourceTools
       end
       uniqs.keys.sort!.map { |k| uniqs[k] }
     end
+
+    def response_codes(responses_object)
+      responses_object.keys.sort! do |a, b|
+        ad = a.downcase
+        bd = b.downcase
+        if ad == 'default'
+          1
+        elsif bd == 'default'
+          -1
+        else
+          ax = ad.end_with?('x')
+          bx = bd.end_with?('x')
+          if ax && bx || !ax && !bx
+            a <=> b # Both numbers or patterns.
+          else
+            ax ? 1 : -1
+          end
+        end
+      end
+    end
+
+    def response_code_condition(code, var: 'code', op_and: '&&', op_lte: '<=', op_eq: '==')
+      low = []
+      high = []
+      code.downcase.each_char do |c|
+        if c == 'x'
+          low.push('0')
+          high.push('9')
+        else
+          low.push(c)
+          high.push(c)
+        end
+      end
+      low = low.join
+      high = high.join
+      if low == high
+        "#{var} #{op_eq} #{low}"
+      else
+        "(#{low} #{op_lte} #{var}) #{op_and} (#{var} #{op_lte} #{high})"
+      end
+    end
   end
 
   # Task class to add an Helper instance to Gen.h, for convenience.

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/output.rb

@@ -46,13 +46,15 @@ module OpenAPISourceTools
       indent = 0
       blocks.each do |block|
         if block.nil?
-          indent = 0
+          next
         elsif block.is_a?(Integer)
           indent += block
+          indent = 0 if indent.negative?
         elsif block.is_a?(TrueClass)
           indent += @config.indent_step
         elsif block.is_a?(FalseClass)
           indent -= @config.indent_step
+          indent = 0 if indent.negative?
         else
           block = block.to_s unless block.is_a?(String)
           if block.empty?

data/lib/openapi/sourcetools/version.rb

@@ -5,7 +5,7 @@
 
 module OpenAPISourceTools
   NAME = 'openapi-sourcetools'
-  VERSION = '0.8.0'
+  VERSION = '0.9.0'
 
   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.9.0
 platform: ruby
 authors:
 - Ismo Kärkkäinen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-28 00:00:00.000000000 Z
+date: 2025-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deep_merge
@@ -41,11 +41,13 @@ executables:
 - openapi-addparameters
 - openapi-addresponses
 - openapi-addschemas
+- openapi-addsecurityschemes
 - openapi-checkschemas
 - openapi-frequencies
 - openapi-generate
 - openapi-merge
 - openapi-modifypaths
+- openapi-patterntests
 - openapi-processpaths
 extensions: []
 extra_rdoc_files: []
@@ -55,11 +57,13 @@ files:
 - bin/openapi-addparameters
 - bin/openapi-addresponses
 - bin/openapi-addschemas
+- bin/openapi-addsecurityschemes
 - bin/openapi-checkschemas
 - bin/openapi-frequencies
 - bin/openapi-generate
 - bin/openapi-merge
 - bin/openapi-modifypaths
+- bin/openapi-patterntests
 - bin/openapi-processpaths
 - lib/openapi/sourcetools.rb
 - lib/openapi/sourcetools/apiobjects.rb
@@ -71,7 +75,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