openapi-sourcetools 0.12.0 → 0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 830a477c8647ad883e5a6619767f19cfae7c2d9b9baa100b0e10bdd911ef0fc1
-  data.tar.gz: 9e4a89d44c344c0099f826bf08c459b2eaa448e4d8b76b982e7ee8b7146199b2
+  metadata.gz: edfaf16a37a66c6f64cddb2580cd5a85c6daf21937a403358ea03d28b35a47d6
+  data.tar.gz: 6e81dcc098183b9547fbc9dd956fb0f11e2ccf556dbf7d8baaf73821bfe9334e
 SHA512:
-  metadata.gz: eef01e1c3095d747213533d8ceeb4d0ba4107970b6541632b92b9ffaa0a0202d583ec6934f2af4af3dbf0dff4d0344e053bbf9201d8128cd474406fe11a8b308
-  data.tar.gz: 92fcbc4c9128e213ee4d67d7eebe69c5de9f5ef2576a0efdeae33b2f512a786d586e0eebe903fc932b43f59475ecbd780d925263adbd9f5039b113292db8ae97
+  metadata.gz: 13c4fd8d5a67c9af5072a8d7e29bee3bec6a82e0a7e9a39284e492871cfb7f9dfca736293d2218df5d91efa2fc200ec0c90b0e8887e0991793dec11a714a692f
+  data.tar.gz: 22ff4d3552d478a72d1e7b5c5d413e4de0c912479da1469ebbb3afa3311e23bd3cb769c69ec40547448e63cd4fbde038383cfef1122fb4a3a8de5297d14d1134

data/bin/openapi-addmediatypes

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Copyright © 2026 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'
+require 'yaml'
+
+
+def main
+  input_name = nil
+  output_name = nil
+  path = %w[components mediaTypes]
+  components = OpenAPISourceTools::ApiObjects::Components.new(path, 'MediaType')
+  replacer = OpenAPISourceTools::ApiObjects::ValueSubValueReplacer.new('content', components)
+
+  parser = OptionParser.new do |opts|
+    opts.summary_indent = '  '
+    opts.summary_width = 26
+    opts.banner = 'Usage: openapi-addmediatypes [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
+    components.add_options(opts)
+    opts.on('-h', '--help', 'Print this help and exit.') do
+      $stdout.puts %(#{opts}
+
+Loads API document in OpenAPI format and moves media types under components
+and replaces the original with reference.
+
+#{components.help}
+)
+      exit 0
+    end
+  end
+  parser.order!
+
+  doc = OpenAPISourceTools::Common.load_source(input_name)
+  return 2 if doc.nil?
+
+  components.items = doc.dig(*path) || {}
+  replacer.replace(doc.dig('components', 'headers') || {})
+  replacer.replace(doc.dig('components', 'responses') || {})
+  replacer.replace(doc.dig('components', 'parameters') || {})
+  replacer.replace(doc.fetch('paths', {}))
+  OpenAPISourceTools::Common.bury(doc, path, components.items) unless components.items.empty?
+
+  OpenAPISourceTools::Common.dump_result(output_name, doc, 3)
+end
+
+exit(main) if File.basename(__FILE__) == File.basename($PROGRAM_NAME)

data/bin/openapi-addrequestbodies

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Copyright © 2026 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'
+require 'yaml'
+
+
+def main
+  input_name = nil
+  output_name = nil
+  path = %w[components requestBodies]
+  components = OpenAPISourceTools::ApiObjects::Components.new(path, 'RequestBody')
+  replacer = OpenAPISourceTools::ApiObjects::ValueReplacer.new('requestBody', components)
+
+  parser = OptionParser.new do |opts|
+    opts.summary_indent = '  '
+    opts.summary_width = 26
+    opts.banner = 'Usage: openapi-addrequestbodies [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
+    components.add_options(opts)
+    opts.on('-h', '--help', 'Print this help and exit.') do
+      $stdout.puts %(#{opts}
+
+Loads API document in OpenAPI format and moves request body under components
+and replaces the original with reference.
+
+#{components.help}
+)
+      exit 0
+    end
+  end
+  parser.order!
+
+  doc = OpenAPISourceTools::Common.load_source(input_name)
+  return 2 if doc.nil?
+
+  components.items = doc.dig(*path) || {}
+  replacer.replace(doc.dig('components', 'pathItems') || {})
+  replacer.replace(doc.fetch('paths', {}))
+  OpenAPISourceTools::Common.bury(doc, path, components.items) unless components.items.empty?
+
+  OpenAPISourceTools::Common.dump_result(output_name, doc, 3)
+end
+
+exit(main) if File.basename(__FILE__) == File.basename($PROGRAM_NAME)

data/bin/openapi-addschemas

@@ -16,6 +16,14 @@ def remove_subitem(obj, path)
   parent.delete(path.last) || {}
 end
 
+def replace_child_inlines(obj, components)
+  return true unless obj.is_a?(Hash)
+  obj.keys.sort!.each do |name|
+    return false unless replace_inlines(obj[name], components)
+  end
+  true
+end
+
 def replace_inlines(obj, components, top_level_name = nil)
   if obj.is_a?(Array)
     obj.each do |o|
@@ -29,22 +37,30 @@ def replace_inlines(obj, components, top_level_name = nil)
     return true
   end
   # Is inlined, process parts recursively.
-  %w[allOf anyOf oneOf items prefixItems additionalProperties unevaluatedItems
-    unevaluatedProperties if then else not
-  ].each do |prop_name|
-    return false unless replace_inlines(obj[prop_name], components)
+  looks_like_type = false
+  # Array-valued.
+  OpenAPISourceTools::Schemas::ARRAY_VALUED.each do |prop_name|
+    value = obj[prop_name]
+    next unless value.is_a?(Array)
+    return false unless replace_inlines(value, components)
+    looks_like_type = true
+  end
+  # Other-valued things.
+  OpenAPISourceTools::Schemas::OTHER_VALUED.each do |prop_name|
+    value = obj[prop_name]
+    next if value.nil? || value.is_a?(Array)
+    return false unless replace_inlines(value, components)
+    looks_like_type = true
   end
-  %w[properties patternProperties dependentSchemas].each do |prop_name|
+  # Keys of these have object values that should be processed.
+  OpenAPISourceTools::Schemas::KEY2SCHEMA.each do |prop_name|
     props = obj[prop_name]
-    next if props.nil?
-    props.keys.sort!.each do |name|
-      return false unless replace_inlines(props[name], components)
-    end
+    next if props.nil? || !props.is_a?(Hash)
+    return false unless replace_child_inlines(props, components)
+    looks_like_type = true
   end
-  looks_like_type = false
   # required is omitted since it is in schema and in parameters.
-  %w[type items prefixItems properties patternProperties additionalProperties
-    unevaluatedItems unevaluatedProperties enum const minimum maximum multipleOf
+  %w[type enum const minimum maximum multipleOf
     exclusiveMinimum exclusiveMaximum maxLength minLength pattern maxItems minItems
     uniqueItems maxContains minContains maxProperties minProperties propertyNames
     dependentRequired format contentEncoding contentMediaType contentSchema
@@ -56,8 +72,8 @@ def replace_inlines(obj, components, top_level_name = nil)
   end
   unless looks_like_type
     # Some kind of intermediate-level object.
-    (obj.keys.sort! { |a, b| a.to_s <=> b.to_s }).each do |key|
-      next if key == 'securitySchemes'
+    obj.keys.sort! { |a, b| a.to_s <=> b.to_s }.each do |key|
+      next if key == 'securitySchemes' || OpenAPISourceTools::Schemas::IGNORED.include?(key) || OpenAPISourceTools::Schemas::HANDLED.include?(key)
       return false unless replace_inlines(obj[key], components)
     end
     return true

data/bin/openapi-generate-checkconfig

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Copyright © 2024-2026 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+require_relative '../lib/openapi/sourcetools/common'
+require_relative '../lib/openapi/sourcetools/config'
+require_relative '../lib/openapi/sourcetools/gen'
+require 'optparse'
+include OpenAPISourceTools
+
+
+def main
+  prefix = nil
+  keys = nil
+  read = false
+
+  parser = OptionParser.new do |opts|
+    opts.summary_indent = '  '
+    opts.summary_width = 26
+    opts.banner = 'Usage: openapi-generate-checkconfig [options]'
+    opts.separator ''
+    opts.separator 'Options:'
+    opts.on('-c', '--config NAME', 'Use config prefix NAME. (config:NAME)') do |c|
+      prefix = c
+    end
+    opts.on('-s', '--separator STRING', 'Use separator STRING. (separator:STRING)') do |s|
+      Gen.separator = s unless s.empty?
+    end
+    opts.on('-r', '--[no-]read', "Show if file is read by read_contents, default #{Common.yesno(read)}.") do |b|
+      read = b
+    end
+    opts.on('-k', '--keys KEYS', 'Show all values of KEYS.') do |ks|
+      keys = ks.split('/').reject(&:empty?) unless ks.empty?
+      keys = nil if !keys.nil? && keys.empty?
+    end
+    opts.on('-h', '--help', 'Print this help and exit.') do
+      $stdout.puts %(#{opts}
+Displays configurations files that are found using specific prefix and an
+optional separator character or string.
+
+If KEYS, separated by "/", is given, the value of that key path is displayed.
+That and read check require the configuration files to be YAML/JSON.
+)
+      exit 0
+    end
+  end
+  parser.order!
+
+  return Common.aargh('Config must be given.', 1) if prefix.nil?
+  cfgs = ConfigLoader.find_files(name_prefix: prefix)
+  ConfigLoader.read_contents(cfgs) if read || !keys.nil?
+  root_dir, _p = ConfigLoader.prepare_prefix(prefix, Gen.wd)
+  drop = root_dir.size + 1
+  cfgs.each do |cfg|
+    ks = cfg.keys.join('/')
+    info = "#{cfg.root}: #{ks.empty? ? '(root)' : ks}, #{cfg.path[drop..]}"
+    ki = nil
+    unless keys.nil? || cfg.content.nil?
+      v = cfg.content.dig(*keys)
+      ki = v.to_s unless v.nil?
+    end
+    ri = read ? !cfg.content.nil? : nil
+    next if (read || !keys.nil?) && ki.nil? && ri.nil?
+    puts info
+    puts "  #{ki}" unless ki.nil?
+    puts "  File is #{ri ? '' : 'not '}read." unless ri.nil?
+  end
+  0
+end
+
+exit(main) if File.basename(__FILE__) == File.basename($PROGRAM_NAME)

data/bin/openapi-logicsplit

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Copyright © 2026 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 mixture?(schema)
+  has_logic = false
+  has_other = false
+  schema.each_key do |key|
+    if OpenAPISourceTools::ApiObjects::LOGIC_KEYS.member?(key)
+      has_logic = true
+      return true if has_other
+    elsif !OpenAPISourceTools::ApiObjects::DOCUMENT_KEYS.include?(key)
+      has_other = true
+      return true if has_logic
+    end
+  end
+  has_logic && has_other
+end
+
+def split(name, schema, added_schemas, schema_path)
+  logic = {}
+  other = {}
+  schema.each do |key, value|
+    if OpenAPISourceTools::ApiObjects::LOGIC_KEYS.member?(key)
+      logic[key] = value
+    else
+      other[key] = value
+    end
+  end
+  logic_name = "#{name}Logic"
+  other_name = "#{name}Other"
+  added_schemas[logic_name] = logic
+  added_schemas[other_name] = other
+  schema.clear
+  schema['allOf'] = [
+    { '$ref' => "#{schema_path}/#{logic_name}" },
+    { '$ref' => "#{schema_path}/#{other_name}" }
+  ]
+end
+
+def main
+  input_name = nil
+  output_name = nil
+  schema_path = '#/components/schemas'
+
+  parser = OptionParser.new do |opts|
+    opts.summary_indent = '  '
+    opts.summary_width = 26
+    opts.banner = 'Usage: openapi-logicsplit [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 splits each schema with a mixture of
+logic keywords and other keywords so that the schema has only allOf with
+references to logic and other schema. The aim is to simplify code generation.
+
+The openapi-addschemas must have been run. Processes "#{schema_path}".
+)
+      return 0
+    end
+  end
+  parser.order!
+
+  doc = Common.load_source(input_name)
+  return 2 if doc.nil?
+
+  path = schema_path.split('/').reject { |x| x == '#' || x.empty? }
+  schemas = doc.dig(*path)
+  added_schemas = {}
+  unless schemas.nil?
+    schemas.keys.sort.each do |name|
+      s = schemas[name]
+      split(name, s, added_schemas, schema_path) if mixture?(s)
+    end
+    schemas.merge!(added_schemas)
+  end
+  Common.dump_result(output_name, doc, 3)
+end
+
+exit(main) if File.basename(__FILE__) == File.basename($PROGRAM_NAME)

data/bin/openapi-order

@@ -53,6 +53,7 @@ def default_order_data(order_key, regexp_prefix)
   server: *ServerObject
   parameters:
     #{order_key}: &ParameterObject_order
+    - required: '>' # True before false.
     - name
     - in
     '*': &ParameterObject
@@ -213,9 +214,10 @@ def default_order_data(order_key, regexp_prefix)
       - parameters
       - '*'
       - additionalOperations
+      - re:^x-openapi-sourcetools.*$
       '*':
         #{order_key}: &OperationObject
-        - '$ref'
+        - '\$ref'
         - operationId
         - summary
         - description
@@ -348,7 +350,7 @@ end
 
 # This needs to extract all path/order pairs, store and sort.
 
-def extract_orders(path, order, collection, order_key, regexp_prefix)
+def extract_orders(path, order, collection, order_key, regexp_prefix, visited)
   return true unless order.is_a?(Hash)
   order.each do |key, value|
     if key == order_key
@@ -356,9 +358,13 @@ def extract_orders(path, order, collection, order_key, regexp_prefix)
         OpenAPISourceTools::Common.aargh("Not an array: #{path.join('.')}.#{order_key} =\n#{YAML.dump(value)}")
         return false
       end
+      return true if visited.member?(value.object_id)
+      visited.add(value.object_id)
       value.each_with_index do |v, k|
-        next if v.is_a?(String)
-        OpenAPISourceTools::Common.aargh("Not a string: #{path}.#{order_key}[#{k}] =\n#{YAML.dump(v)}")
+        ov = OpenAPISourceTools::Ordering::Order.ordervalue(v)
+        value[k] = ov
+        next unless ov.nil?
+        OpenAPISourceTools::Common.aargh("Not valid order value: #{path}.#{order_key}[#{k}] =\n#{YAML.dump(v)}")
         return false
       end
       key_path = OpenAPISourceTools::Ordering::KeyPath.new(path, regexp_prefix)
@@ -367,7 +373,7 @@ def extract_orders(path, order, collection, order_key, regexp_prefix)
     else
       key = key.to_s unless key.is_a?(String)
       path.push(key)
-      return false unless extract_orders(path, value, collection, order_key, regexp_prefix)
+      return false unless extract_orders(path, value, collection, order_key, regexp_prefix, visited)
       path.pop
     end
   end
@@ -472,14 +478,17 @@ def main
       regexp_prefix = p
     end
     opts.on('-h', '--help', 'Print this help and exit.') do
-      $stdout.puts %(#{opts}
+      $stdout.puts <<EOF
+#{opts}
 Loads YAML document and applies ordering to object keys, and arrays with
 objects, when an order matches the key path to object.
 
 Can be used on generic YAML or JSON files. Default order is for OpenAPI
 documents.
 
-The order instructions key "#{order_key}" value must be an array of strings.
+The order instructions key "#{order_key}" value must be an array of strings
+or single-item map from string to "<" or ">" to indicate ascending (default)
+or descending order. Hence any 'key' is same as 'key: "<"'.
 The values can be any combination of the following:
 - Literal key name.
 - Regular expression starting with "#{regexp_prefix}".
@@ -492,13 +501,13 @@ position are sorted within that position.
 The path to the "#{order_key}" can have any combination of the following:
 - Literal key name.
 - Regular expression starting with "#{regexp_prefix}".
-- "*" that matches one key of any value.
-- "**" that matches one or more keys of any value.
+- "*" that matches one key of any content.
+- "**" that matches one or more keys of any content.
 The path is used to determine if a value in the document should be ordered
 using the instructions. At top level the path is empty and applies to the root
 of the document. Long paths are considered to be more specific than short
 paths, because they supposedly contain more literal keys or limiting regular
-expressions so thay are intended for a specific case. Of paths of same length
+expressions so they are intended for a specific case. Of paths of same length
 one with "**" is considered less specific than one without.
 
 The path to a value in the document is matched against paths to "#{order_key}"
@@ -538,7 +547,7 @@ so provide it if you want to keep it. Useful for readability.
 
 When reading an order file, --key and --regexp are over-ridden by root-level
 object "#{metadata}" keys "#{metadata_key}" and "#{metadata_regexp}" values.
-)
+EOF
       exit 0
     end
   end
@@ -561,7 +570,7 @@ object "#{metadata}" keys "#{metadata_key}" and "#{metadata_regexp}" values.
     order_key = md.fetch(metadata_key, order_key)
     regexp_prefix = md.fetch(metadata_regexp, regexp_prefix)
     path_orders = []
-    return 4 unless extract_orders([], order, path_orders, order_key, regexp_prefix)
+    return 4 unless extract_orders([], order, path_orders, order_key, regexp_prefix, Set.new)
     path_orders.sort!.reverse! # Longest key pattern sequence first.
     order_document(path_orders, [], doc)
     doc = formats[format].call(doc, line_width)

data/bin/openapi-schema-in

@@ -0,0 +1,143 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Copyright © 2026 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+require_relative '../lib/openapi/sourcetools/common'
+require_relative '../lib/openapi/sourcetools/schemaio'
+require 'optparse'
+include OpenAPISourceTools
+
+
+# Functions related to saving the output.
+
+def to_json(doc, _line_width)
+  JSON.dump(doc)
+end
+
+def to_pretty_json(doc, _line_width)
+  JSON.pretty_generate(doc)
+end
+
+def to_yaml(doc, line_width)
+  YAML.dump(doc, line_width: line_width)
+end
+
+def main
+  input_file = nil
+  schema_file = nil
+  output_file = nil
+  name = nil
+  refs = true
+  format = 'yaml'
+  formats = {
+    'yaml' => method(:to_yaml),
+    'json' => method(:to_json),
+    'pretty_json' => method(:to_pretty_json)
+  }
+  line_width = 80
+  doc_paths = :openapi
+  schema_paths = :jsonschema
+  drops = []
+
+  parser = OptionParser.new do |opts|
+    opts.summary_indent = '  '
+    opts.summary_width = 26
+    opts.banner = 'Usage: openapi-schema-in [options]'
+    opts.separator ''
+    opts.separator 'Options:'
+    opts.on('-i', '--input FILE', 'Read input from FILE, not stdin.') do |f|
+      input_file = f
+    end
+    opts.on('-s', '--schema FILE', 'Read schema from FILE, not stdin.') do |f|
+      schema_file = f
+    end
+    opts.on('-o', '--output FILE', 'Write result to FILE, not stdout.') do |f|
+      output_file = f
+    end
+    opts.on('-n', '--name NAME', 'Use schema NAME.') do |n|
+      name = n
+    end
+    opts.on('--[no-]refs', "Include referred schemas (default #{Common.yesno(refs)}).") do |r|
+      refs = r
+    end
+    opts.on('-f', '--format FORMAT', "Document output format: #{formats.keys.sort!.join(', ')}.") do |fmt|
+      format = fmt
+    end
+    opts.on('-w', '--width WIDTH', "Set YAML line width, default: #{line_width}") do |w|
+      line_width = w.to_i
+    end
+    opts.on('--inputpaths DATA', 'Input path data.') do |data|
+      doc_paths = data
+    end
+    opts.on('--schemapaths DATA', 'Schema path data.') do |data|
+      schema_paths = data
+    end
+    opts.on('-d', '--drop KEY', 'Drop KEY from chosen schema.') do |k|
+      drops.push(k)
+    end
+    opts.on('-h', '--help', 'Print this help and exit.') do
+      $stdout.puts <<EOF
+#{opts}
+Takes schema with name and places it into document.
+
+The document and schema paths DATA is either a file name, internal data name,
+or a JSON-encoded object containing paths data. Internal data names are:
+#{SchemaIO::BUILTINS.keys.sort!.join(', ')}
+
+Depending on input, schema NAME is used to find and store the schema in the
+location indicated by DATA for input and output.
+
+DATA values default to input and output being OpenAPI format, schema file is
+JSON schema with the named schema at root.
+
+Dropping keys can be used to remove for example "$schema" and "$id" keys from
+the chosen schema, if present.
+EOF
+      return 0
+    end
+  end
+  parser.order!
+
+  drops.sort!.uniq! unless drops.size < 2
+
+  return Common.aargh('Cannot read both document and schema from stdin.', 1) if input_file.nil? && schema_file.nil?
+  return Common.aargh('Schema name must be given.', 1) if name.nil?
+
+  return Common.aargh("Unknown format: #{format}", 1) unless formats.key?(format)
+
+  dp = SchemaIO.key_data(doc_paths)
+  return Common.aargh("Not file or internal format name or format as JSON object: #{doc_paths}", 2) if dp.nil?
+  sp = SchemaIO.key_data(schema_paths)
+  return Common.aargh("Not file or internal format name or format as JSON object: #{schema_paths}", 2) if sp.nil?
+
+  return Common.aargh(%(Name "#{name}" has document path separator "#{dp.separator}"), 1) if name.include?(dp.separator)
+  return Common.aargh(%(Name "#{name}" has schema path separator "#{sp.separator}"), 1) if name.include?(sp.separator)
+
+  doc = Common.load_source(input_file)
+  return 2 if doc.nil?
+  return Common.aargh('Document is not an object.', 2) unless doc.is_a?(Hash)
+  schema = Common.load_source(schema_file)
+  return 2 if schema.nil?
+  return Common.aargh('Schema is not an object.', 2) unless schema.is_a?(Hash)
+
+  tgt = SchemaIO::SchemaAccess.new(dp, doc)
+  src = SchemaIO::SchemaAccess.new(sp, schema)
+
+  desired = src.find_named_schema(name)
+  return Common.aargh("Schema not found: #{name}", 1) if desired.nil?
+  drops.each { |k| desired.delete(k) }
+  tgt.put_named_schema(name, desired)
+
+  if refs
+    refd = src.find_referenced_schemas(name, desired)
+    refd.each { |n, s| tgt.put_referenced_schema(n, s) }
+  end
+  SchemaIO.alter_refs(tgt.document, src, tgt) # After referenced schemas have been found.
+
+  out = formats[format].call(tgt.document, line_width)
+  Common.dump_result(output_file, out, 3)
+end
+
+exit(main) if File.basename(__FILE__) == File.basename($PROGRAM_NAME)