openapi-sourcetools 0.4.3 → 0.6.0

data/lib/helper.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+# Copyright © 2024 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+require_relative 'task'
+
+
+class Helper
+  attr_reader :doc, :parents
+  attr_accessor :parent_parameters
+
+  # Stores the nearesh Hash for each Hash.
+  def store_parents(obj, parent = nil)
+    if obj.is_a?(Hash)
+      @parents[obj.object_id] = parent
+      obj.each do |k, v|
+        store_parents(v, obj)
+      end
+    elsif obj.is_a?(Array)
+      obj.each do |v|
+        store_parents(v, parent)
+      end
+    end
+  end
+
+  def initialize(doc)
+    @doc = doc
+    # For each hash in doc, set parent?
+    # Build an object_id to parent object mapping and use parent method?
+    @parents = {}
+    store_parents(@doc)
+  end
+
+  def parent(object)
+    @parents[object.object_id]
+  end
+
+  COMPONENTS = '#/components/'
+
+  def category_and_name(ref_or_obj)
+    ref = ref_or_obj.is_a?(Hash) ? ref_or_obj['$ref'] : ref_or_obj
+    return nil unless ref.is_a?(String)
+    return nil unless ref.start_with?(Helper::COMPONENTS)
+    idx = ref.index('/', Helper::COMPONENTS.size)
+    return nil if idx.nil?
+    category = ref[Helper::COMPONENTS.size...idx]
+    [ category, ref[(idx + 1)...ref.size] ]
+  end
+
+  def dereference(ref_or_obj)
+    cn = category_and_name(ref_or_obj)
+    return nil if cn.nil?
+    cs = @doc.dig('components', cn.first) || {}
+    cs[cn.last]
+  end
+
+  def basename(ref_or_obj)
+    cn = category_and_name(ref_or_obj)
+    return nil if cn.nil?
+    cn.last
+  end
+
+  def parameters(operation_object, empty_unless_local = false)
+    return [] if empty_unless_local && !operation_object.key?('parameters')
+    cps = @doc.dig('components', 'parameters') || {}
+    uniqs = {}
+    path_item_object = parent(operation_object)
+    [path_item_object, operation_object].each do |p|
+      p.fetch('parameters', []).each do |param|
+        r = basename(param)
+        r = cps[r] if r.is_a?(String)
+        uniqs["#{r['name']}:#{r['in']}"] = param
+      end
+    end
+    uniqs.keys.sort!.map { |k| uniqs[k] }
+  end
+end
+
+
+class HelperTask
+  include TaskInterface
+
+  def generate(context_binding)
+    Gen.h = Helper.new(Gen.doc)
+  end
+
+  def output_name
+    nil
+  end
+
+  def discard
+    true
+  end
+end
+

data/lib/loaders.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Copyright © 2024 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+module Loaders
+
+  GEM_PREFIX = 'gem:'
+
+  def self.gem_loader(name)
+    return false unless name.downcase.start_with?(GEM_PREFIX)
+    begin
+      require(name.slice(GEM_PREFIX.size...name.size))
+    rescue LoadError => e
+      raise StandardError, "Failed to require #{name}\n#{e.to_s}"
+    rescue Exception => e
+      raise StandardError, "Problem with #{name}\n#{e.to_s}"
+    end
+    true
+  end
+
+  RUBY_EXT = '.rb'
+
+  def self.ruby_loader(name)
+    return false unless name.downcase.end_with?(RUBY_EXT)
+    origwd = Dir.pwd
+    d = File.dirname(name)
+    Dir.chdir(d) unless d == '.'
+    begin
+      require(File.join(Dir.pwd, File.basename(name)))
+    rescue LoadError => e
+      raise StandardError, "Failed to require #{name}\n#{e.to_s}"
+    rescue Exception => e
+      raise StandardError, "Problem with #{name}\n#{e.to_s}"
+    end
+    Dir.chdir(origwd) unless d == '.'
+    true
+  end
+
+  def self.loaders
+    [ method(:gem_loader), method(:ruby_loader) ]
+  end
+
+  def self.document
+    %(
+- #{Loaders::GEM_PREFIX}gem_name : requires the gem.
+- ruby_file#{Loaders::RUBY_EXT} : changes to Ruby file directory and requires the file.
+)
+  end
+
+end

data/lib/task.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+# Copyright © 2024 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+require 'erb'
+require_relative 'common'
+
+
+module TaskInterface
+  def generate(context_binding)
+    raise NotImplementedError
+  end
+
+  def output_name
+    raise NotImplementedError
+  end
+
+  def discard
+    false
+  end
+
+  def executable
+    false
+  end
+end
+
+class Task
+  include TaskInterface
+
+  attr_reader :src, :template, :template_name
+  attr_accessor :name, :executable, :discard, :x
+
+  def initialize(src, template, template_name)
+    @src = src
+    @template = template
+    @template_name = template_name
+    if @template.nil?
+      raise ArgumentError, "template_name or template must be given" if @template_name.nil?
+      begin
+        @template = File.read(@template_name)
+      rescue Errno::ENOENT
+        raise StandardError, "Could not load #{@template_name}"
+      rescue StandardError => e
+        raise StandardError, "#{e}\nFailed to read #{@template_name}"
+      end
+    end
+    @name = nil
+    @executable = false
+    @discard = false
+    @x = nil
+  end
+
+  # If this is overridden to perform some processing but not to produce output,
+  # set @discard = true and return value will be ignored. No other methods are
+  # called in that case.
+  def internal_generate(context_binding)
+    ERB.new(@template).result(context_binding)
+  end
+
+  # You can override this instead of internal_generate if you do not need the
+  # exception handling.
+  def generate(context_binding)
+    n = @template_name.nil? ? '' : "#{@template_name} "
+    internal_generate(context_binding)
+  rescue SyntaxError => e
+    aargh("Template #{n}syntax error: #{e.full_message}", 5)
+  rescue Exception => e
+    aargh("Template #{n}error: #{e.full_message}", 6)
+  end
+
+  # This is only called when generate produced output that is not discarded.
+  def output_name
+    return @name unless @name.nil?
+    # Using template name may show where name assignment is missing.
+    # Name assignment may also be missing in the task creation stage.
+    return File.basename(@template_name) unless @template_name.nil?
+    nil
+  end
+end
+
+class WriteTask
+  include TaskInterface
+
+  attr_reader :name, :contents, :executable
+
+  def initialize(name, contents, executable = false)
+    raise ArgumentError, "name and contents must be given" if name.nil? || contents.nil?
+    @name = name
+    @contents = contents
+    @executable = executable
+  end
+
+  def generate(context_binding)
+    @contents
+  end
+
+  def output_name
+    @name
+  end
+end

metadata

@@ -1,37 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: openapi-sourcetools
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.6.0
 platform: ruby
 authors:
 - Ismo Kärkkäinen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-29 00:00:00.000000000 Z
+date: 2024-07-17 00:00:00.000000000 Z
 dependencies: []
 description: |2
 
-  Tools for generating source code from API specification in OpenAPI format.
+  Tools for handling API specification in OpenAPI format. Replacement of
+  duplicate definitions with references. Other checks. Does not validate
+  the document against OpenAPI format specification.
 email: ismokarkkainen@icloud.com
 executables:
-- openapi-generatecode
+- openapi-addheaders
+- openapi-addparameters
+- openapi-addresponses
+- openapi-addschemas
+- openapi-checkschemas
 - openapi-frequencies
+- openapi-generate
 - openapi-merge
 - openapi-processpaths
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE.txt
+- bin/openapi-addheaders
+- bin/openapi-addparameters
+- bin/openapi-addresponses
+- bin/openapi-addschemas
+- bin/openapi-checkschemas
 - bin/openapi-frequencies
-- bin/openapi-generatecode
+- bin/openapi-generate
 - bin/openapi-merge
 - bin/openapi-processpaths
+- lib/apiobjects.rb
 - lib/common.rb
+- lib/gen.rb
+- lib/generate.rb
+- lib/helper.rb
+- lib/loaders.rb
+- lib/task.rb
 homepage: https://xn--ismo-krkkinen-gfbd.fi/openapi-sourcetools/index.html
 licenses:
 - UPL-1.0
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -40,14 +59,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: Tools for creating source code from API specification.

data/bin/openapi-generatecode

@@ -1,128 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Copyright © 2021 Ismo Kärkkäinen
-# Licensed under Universal Permissive License. See LICENSE.txt.
-
-require_relative '../lib/common.rb'
-require 'optparse'
-require 'yaml'
-require 'erb'
-
-
-default_env(:out, '')
-default_env(:in, '')
-default_env(:template, '')
-
-ENV['POSIXLY_CORRECT'] = '1'
-parser = OptionParser.new do |opts|
-  opts.summary_indent = '  '
-  opts.summary_width = 26
-  opts.banner = 'Usage: openapi-generatecode [options] [additions...]'
-  opts.separator ''
-  opts.separator 'Options (equivalent environment variable and value in parentheses):'
-  opts.on('-i', '--input FILE', 'Read processed API from FILE, not stdin (IN=FILE).') do |f|
-    env(:in, f)
-  end
-  opts.on('-o', '--output FILE', 'Output result to FILE, not stdout (OUT=FILE).') do |f|
-    env(:out, f)
-  end
-  opts.on('-t', '--template FILE', 'Read template from FILE (TEMPLATE=FILE).') do |f|
-    env(:template, f)
-  end
-  opts.on('-h', '--help', 'Print this help and exit.') do
-    $stdout.puts %(#{opts}
-
-Loads ERB template and optional additions to a context along with the processed
-API document and produces the template result.
-)
-    exit 0
-  end
-end
-parser.parse!
-
-aargh('Template file name must be given.', 1) if env(:template).empty?
-
-def load_content(name)
-  name.empty? ? $stdin.read : File.read(name)
-rescue Errno::ENOENT
-  aargh("Could not load #{name || 'stdin'}", 2)
-rescue StandardError => e
-  aargh("#{e}\nFailed to read #{name || 'stdin'}", 2)
-end
-
-class Generator
-  attr_accessor :addition, :order, :full_name_order, :template, :document
-
-  def initialize(document_content, template_content)
-    @addition = Hash.new
-    @order = []
-    @full_name_order = []
-    @document = document_content
-    @template = template_content
-  end
-
-  def get_binding
-    binding
-  end
-
-  def add(name, content, strip_suffix)
-    @full_name_order.push({ filename: name, contents: content })
-    name = File.basename(name)
-    @order.push name
-    if strip_suffix
-      idx = name.rindex('.')
-      name = name.slice(0, idx) unless idx.nil?
-    end
-    @addition[name] = content
-  end
-end
-t = load_content(env(:template))
-d = load_content(env(:in))
-begin
-  $generator = Generator.new(YAML.safe_load(d), t)
-rescue StandardError => e
-  aargh('Failed to parse API document.', 3)
-end
-
-ARGV.each do |name|
-  aargh('Addition file name is empty.', 1) if name.empty?
-  if name.end_with? '.rb'
-    begin
-      require File.absolute_path(name)
-    rescue SyntaxError => e
-      aargh("Syntax error in addition #{name}: #{e.to_s}", 4)
-    rescue StandardError => e
-      aargh("Failed to require addition #{name}: #{e.to_s}", 5)
-    end
-  else
-    c = load_content(name)
-    begin
-      d = YAML.safe_load(c)
-    rescue StandardError
-      d = c
-    end
-    $generator.add(name, d, name.upcase.end_with?('.YAML') || name.upcase.end_with?('.JSON'))
-  end
-end
-
-begin
-  out = ERB.new($generator.template).result($generator.get_binding)
-rescue SyntaxError => e
-  aargh("Template syntax error: #{e.to_s}", 6)
-rescue StandardError => e
-  aargh("Template error: #{e.to_s}", 7)
-end
-
-output = env(:out)
-if output.empty?
-  output = $stdout
-else
-  begin
-    output = File.open(output, 'w')
-  rescue StandardError
-    aargh("Failed to open for writing: #{output}", 1)
-  end
-end
-output.write(out)
-output.close