openapi-sourcetools 0.7.1 → 0.8.0

data/lib/docs.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright © 2024 Ismo Kärkkäinen
-# Licensed under Universal Permissive License. See LICENSE.txt.
-
-require_relative 'common'
-
-
-class Docs
-  attr_reader :docs
-
-  def initialize
-    @docs = {}
-  end
-
-  def method_missing(method_name, *args)
-    name = method_name.to_s
-    if name.end_with?('=')
-      name = name[0...(name.size - 1)]
-      super unless @docs.key?(name)
-      @docs[name] = args.first
-      return args.first
-    end
-    super unless @docs.key?(name)
-    @docs[name]
-  end
-
-  def add(name, content)
-    return false if docs.key?(name)
-    @docs[name] = content
-    true
-  end
-end

data/lib/generate.rb

@@ -1,90 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Copyright © 2024 Ismo Kärkkäinen
-# Licensed under Universal Permissive License. See LICENSE.txt.
-
-require_relative 'common'
-require_relative 'loaders'
-require_relative 'gen'
-
-
-def executable_bits_on(mode)
-  mode = mode.to_s(8).split('')
-  mode.size.times do |k|
-    m = mode[k].to_i(8)
-    # Applies to Unix-likes. Other system, check and handle.
-    m += 1 unless 3 < mode.size - k || m.zero? || m % 2 == 1
-    mode[k] = m
-  end
-  m = 0
-  mode.each do |v|
-    m = 8 * m + v
-  end
-  m
-end
-
-class Generator
-  def initialize(document_content, input_name, output_directory)
-    Gen.setup(document_content, input_name, output_directory)
-    Gen.loaders = Loaders.loaders
-  end
-
-  def context_binding
-    binding
-  end
-
-  def load(generator_names)
-    generator_names.each do |name|
-      idx = Gen.loaders.index { |loader| loader.call(name) }
-      return aargh("No loader could handle #{name}", 2) if idx.nil?
-    end
-    0
-  rescue StandardError => e
-    aargh(e.to_s, 2)
-  end
-
-  def generate(t)
-    t.generate(context_binding)
-  rescue Exception => e
-    aargh(e.to_s, 4)
-  end
-
-  def output_name(t, index)
-    name = t.output_name
-    name = "#{index}.txt" if name.nil?
-    File.join(Gen.outdir, name)
-  end
-
-  def save(name, contents, executable)
-    f = File.new(name, File::WRONLY | File::CREAT | File::TRUNC)
-    s = executable ? f.stat : nil
-    f.write(contents)
-    f.close
-    return unless executable
-    mode = executable_bits_on(s.mode)
-    File.chmod(mode, name) unless mode == s.mode
-  end
-
-  def run
-    # This allows tasks to be added while processing.
-    # Not intended to be done but might prove handy.
-    # Also exposes current task index in case new task is added in the middle.
-    Gen.task_index = 0
-    while Gen.task_index < Gen.tasks.size
-      Gen.t = Gen.tasks[Gen.task_index]
-      out = generate(Gen.t)
-      Gen.task_index += 1
-      next if Gen.t.discard # Check first to ignore result if no output.
-      return out if out.is_a?(Integer)
-      next if out.empty? # Allows no output but return value still checked.
-      name = output_name(Gen.t, Gen.task_index - 1)
-      begin
-        save(name, out, Gen.t.executable)
-      rescue StandardError => e
-        return aargh("Error writing output file: #{name}\n#{e}", 3)
-      end
-    end
-    0
-  end
-end

data/lib/helper.rb

@@ -1,94 +0,0 @@
-# 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 nearest 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
-    @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

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright © 2024 Ismo Kärkkäinen
-# Licensed under Universal Permissive License. See LICENSE.txt.
-
-
-# Original loader functions. These are accessible via Gen.loaders. New loaders
-# should be added there.
-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
-
-  YAML_PREFIX = 'yaml:'
-  YAML_EXTS = [ '.yaml', '.yml' ]
-
-  def self.yaml_loader(name)
-    d = name.downcase
-    if d.start_with?(YAML_PREFIX)
-      name = name.slice(YAML_PREFIX.size...name.size)
-    else
-      return false if (YAML_EXTS.index { |s| d.end_with?(s) }).nil?
-    end
-    n, sep, f = name.partition(':')
-    raise StandardError, "No name given." if n.empty?
-    raise StandardError, "No filename given." if f.empty?
-    doc = YAML.safe_load(File.read(f))
-    raise StandardError, "#{name} #{n} exists already." unless Gen.d.add(n, doc)
-    true
-  rescue Errno::ENOENT
-    raise StandardError, "Not found: #{f}\n#{e.to_s}"
-  rescue Exception => e
-    raise StandardError, "Failed to read as YAML: #{f}\n#{e.to_s}"
-  end
-
-  BIN_PREFIX = 'bin:'
-
-  def self.bin_loader(name)
-    return false unless name.downcase.start_with?(BIN_PREFIX)
-    n, sep, f = name.slice(BIN_PREFIX.size...name.size).partition(':')
-    raise StandardError, "No name given." if n.empty?
-    raise StandardError, "No filename given." if f.empty?
-    doc = IO.binread(f)
-    raise StandardError, "#{name} #{n} exists already." unless Gen.d.add(n, doc)
-    true
-  rescue Errno::ENOENT
-    raise StandardError, "Not found: #{f}\n#{e.to_s}"
-  rescue Exception => e
-    raise StandardError, "Failed to read #{f}\n#{e.to_s}"
-  end
-
-  def self.loaders
-    pre = @preloaders
-    [ method(:gem_loader), method(:ruby_loader), method(:yaml_loader), method(:bin_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.
-- #{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.
-- #{Loaders::BIN_PREFIX}name:filename : Loads binary file into Gen.d.name.
-)
-  end
-
-end

data/lib/output.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright © 2024 Ismo Kärkkäinen
-# Licensed under Universal Permissive License. See LICENSE.txt.
-
-require_relative 'task'
-
-
-class Output
-  # For indentation.
-  attr_accessor :indent_character, :indent_step
-  attr_accessor :tab, :tab_replaces_count
-  attr_accessor :last_indent
-
-  def initialize
-    @indent_character = ' '
-    @indent_step = 4
-    @tab = "\t"
-    @tab_replaces_count = 0
-    @last_indent = 0
-  end
-
-  def join(blocks, separator = "\n")
-    indented = []
-    blocks.flatten!
-    indent = 0
-    blocks.each do |block|
-      if block.nil?
-        indent = 0
-      elsif block.is_a?(Integer)
-        indent += block
-      elsif block.is_a?(TrueClass)
-        indent += @indent_step
-      elsif block.is_a?(FalseClass)
-        indent -= @indent_step
-      else
-        block = block.to_s unless block.is_a?(String)
-        if indent.zero?
-          indented.push(block)
-          next
-        end
-        if 0 < @tab_replaces_count
-          tabs = @tab * (indent / @tab_replaces_count)
-          chars = @indent_character * (indent % @tab_replaces_count)
-        else
-          tabs = ''
-          chars = @indent_character * indent
-        end
-        lines = block.lines(chomp: true)
-        lines.each do |line|
-          indented.push("#{tabs}#{chars}#{line}")
-        end
-      end
-    end
-    @last_indent = indent
-    indented.join(separator)
-  end
-end

data/lib/task.rb

@@ -1,101 +0,0 @@
-# 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