kwalify_to_json_schema 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dbf127bd97917313787d2e8627ab38a3ef403edbf32bf77af9b1be706525a71e
+  data.tar.gz: 2b055ce7452bd80faa88b40c33d11644779f2ada1a2b7b63a0c7a1470fe55a2c
+SHA512:
+  metadata.gz: 03533367dd66aed289370d6aa7bfe03578dab440c59498bc030e8e4179d53917577e7064f12bc5e2ca30f32fda464fabf22c47424a70741a209669fef170d357
+  data.tar.gz: 00a4daafa64abeebac771e70b8809ad3475a8e97ca4bc8d6dc26a92735e25b2cb9ab573b876d79127e87146b5efd48c60206b11b0ad25edeee71b00493b24c0a

data/bin/kwalify_to_json_schema

@@ -0,0 +1,4 @@
+#!/usr/bin/ruby
+require "kwalify_to_json_schema"
+
+KwalifyToJsonSchema::Cli.start

data/home/sylvain/kwalify_to_json_schema/lib/kwalify_to_json_schema.rb

@@ -0,0 +1,11 @@
+require "json"
+require "yaml"
+require "thor"
+require "coderay"
+require_relative "kwalify_to_json_schema/kwalify_to_json_schema"
+require_relative "kwalify_to_json_schema/serialization"
+require_relative "kwalify_to_json_schema/options"
+require_relative "kwalify_to_json_schema/limitations"
+require_relative "kwalify_to_json_schema/converter"
+require_relative "kwalify_to_json_schema/custom_processing"
+require_relative "kwalify_to_json_schema/cli"

data/home/sylvain/kwalify_to_json_schema/lib/kwalify_to_json_schema/cli.rb

@@ -0,0 +1,108 @@
+module KwalifyToJsonSchema
+  class Cli < Thor
+    ###############################################################################################################
+    CUSTOM_PROCESSING_CODE_DOC = <<~CODE
+      class CustomProcessing
+          # The method will be called before conversion allowing to customize the input Kwalify schema.
+          # The implementation have to return the modified schema.
+          # The default implemention don't modify the schema.
+          # @param kwalify_schema {Hash}
+          # @return modified schema
+          def preprocess(kwalify_schema)
+            # TODO return modified schema
+          end
+          
+          # The method will be called after the conversion allowing to customize the output JSON schema.
+          # The implementation have to return the modified schema.
+          # The default implemention don't modify the schema.
+          # @param json_schema {Hash}
+          # @return modified schema
+          def postprocess(json_schema)
+            # TODO return modified schema
+          end
+      end
+    CODE
+
+    desc "convert KWALIFY_SCHEMA_FILE, RESULT_FILE",
+         "Convert a Kwalify schema file to a JSON schema file. The result file extension will decide the format: .json or .yaml"
+    option :issues_to_description,
+           :type => :boolean,
+           :default => false,
+           :desc => "Will append any conversion issue to the schema description"
+    option :custom_processing,
+           :type => :string,
+           :desc => <<~DESC
+             Allows to provide a pre/post processing file on handled schemas.
+             The given Ruby file have to provide the following class:
+             #{CodeRay.scan(CUSTOM_PROCESSING_CODE_DOC, :ruby).encode :terminal}
+           DESC
+
+    def convert(kwalify_schema_file, result_file)
+      opts = {
+        Options::ISSUES_TO_DESCRIPTION => options[:issues_to_description],
+        Options::CUSTOM_PROCESSING => custom_processing(options),
+      }
+      KwalifyToJsonSchema.convert_file(kwalify_schema_file, result_file, opts)
+    end
+
+    ###############################################################################################################
+
+    desc "convert_dir KWALIFY_SCHEMA_DIR, RESULT_DIR",
+         "Convert all the Kwalify schema from a directory to a JSON schema"
+    option :issues_to_description,
+           :type => :boolean,
+           :default => false,
+           :desc => "Will append any conversion issue to the schema description"
+    option :format,
+           :type => :string,
+           :enum => ["json", "yaml"],
+           :default => "json",
+           :desc => "Select the output file format"
+    option :recursive,
+           :type => :boolean,
+           :default => false,
+           :desc => "Process files recursively",
+           :long_desc => ""
+    option :custom_processing,
+           :type => :string,
+           :desc => <<~DESC
+             Allows to provide a pre/post processing file on handled schemas.
+             The given Ruby file have to provide the following class:
+             #{CodeRay.scan(CUSTOM_PROCESSING_CODE_DOC, :ruby).encode :terminal}
+           DESC
+
+    def convert_dir(kwalify_schema_dir, result_dir)
+      opts = {
+        Options::ISSUES_TO_DESCRIPTION => options[:issues_to_description],
+        Options::CUSTOM_PROCESSING => custom_processing(options),
+      }
+
+      path = [kwalify_schema_dir, options["recursive"] ? "**" : nil, "*.yaml"].compact
+      Dir.glob(File.join(*path)).each { |kwalify_schema_file|
+        result_file = File.join(result_dir, File.basename(kwalify_schema_file, File.extname(kwalify_schema_file))) + ".#{options["format"]}"
+        KwalifyToJsonSchema.convert_file(kwalify_schema_file, result_file, opts)
+      }
+    end
+
+    def self.exit_on_failure?
+      false
+    end
+
+    private
+
+    def custom_processing(options)
+      pf = options[:custom_processing]
+      custom_processing = nil
+      if pf
+        require File.expand_path(pf)
+        begin
+          processing_class = Object.const_get :CustomProcessing
+          custom_processing = processing_class.new
+        rescue NameError => e
+          raise "The 'CustomProcessing' module must be defined in #{pf}"
+        end
+      end
+      custom_processing
+    end
+  end
+end

data/home/sylvain/kwalify_to_json_schema/lib/kwalify_to_json_schema/converter.rb

@@ -0,0 +1,178 @@
+module KwalifyToJsonSchema
+
+  # Heart of conversion implementation
+  #
+  # Example of use:
+  #
+  # kwalify_schema = YAML.load(File.read("kwalify_schema.yaml"))
+  #
+  # converter = KwalifyToJsonSchema::Converter.new(options)
+  # json_schema = converter.exec(kwalify_schema)
+  #
+  # File.write("json_schema.json", JSON.pretty_generate(json_schema))
+  class Converter
+    SCHEMA = "http://json-schema.org/draft-07/schema#"
+
+    # The options given used to initialized the converter
+    attr_reader :options
+    # Give the list of issues encontered while converting as array of strings.
+    attr_reader :issues
+
+    # Converter options:
+    # | Name                  | Type   | Default value| Description                                         |
+    # |-----------------------|--------|--------------|-----------------------------------------------------|
+    # | :id                   | String | nil          | The JSON schema identifier                          |
+    # | :title                | String | nil          | The JSON schema title                               |
+    # | :description          | String | nil          | The JSON schema description                         |
+    # | :issues_to_description| Boolean| false        | To append the issuses to the JSON schema description|
+    # | :custom_processing    | Object | nil          | To customize the conversion                         |
+    # --
+    def initialize(options_hash = {})
+      @options = Options.new(options_hash)
+      @issues = []
+    end
+
+    # Execute the conversion process
+    # @param kwalify_schema Kwalify schema as Hash or YAML string to be converted as Hash
+    # @return JSON schema as Hash
+    def exec(kwalify_schema)
+      kwalify_schema = YAML.load(kwalify_schema) if kwalify_schema.is_a? String
+      kwalify_schema = preprocess(kwalify_schema.dup)
+
+      json_schema = process(root, kwalify_schema)
+      if issues.any? && options.issues_to_description?
+        description = json_schema["description"] ||= ""
+        description << "Issues when converting from Kwalify:\n"
+        description << issues.map { |issue| "* #{issue}" }.join("\n")
+      end
+
+      postprocess(json_schema)
+    end
+
+    private
+
+    def root
+      {
+        "$schema" => SCHEMA,
+        "$id" => options.id,
+        "title" => options.title,
+        "description" => options.description,
+      }.reject { |k, v| v.nil? }
+    end
+
+    # @param target Json schema target
+    # @param kelem Kwalify element
+    def process(target, kelem)
+
+      # Add description if available
+      target["description"] = kelem["desc"] if kelem["desc"]
+
+      case ktype = kelem["type"]
+      when "map"
+        target["type"] = "object"
+        target["additionalProperties"] = false
+        mapping = kelem["mapping"]
+        required = []
+        if mapping.is_a? Hash
+          properties = target["properties"] = {}
+          mapping.each_pair { |name, e|
+            process(properties[name] = {}, e)
+            required << name if e["required"] == true
+          }
+          target["required"] = required unless required.empty?
+        end
+      when "seq"
+        target["type"] = "array"
+        sequence = kelem["sequence"]
+        if sequence.is_a? Array
+          process(target["items"] = {}, sequence.first)
+        end
+      when "str"
+        target["type"] = "string"
+      when "int"
+        target["type"] = "integer"
+      when "float", "number"
+        target["type"] = "number"
+      when "text"
+        # Use one of
+        target["oneOf"] = [
+          { "type" => "string" },
+          { "type" => "number" },
+        ]
+      when "bool"
+        target["type"] = "boolean"
+      when "date"
+        # TODO
+        new_issue Limitations::DATE_TYPE_NOT_IMPLEMENTED
+      when "time"
+        # TODO
+        new_issue Limitations::TIME_TYPE_NOT_IMPLEMENTED
+      when "timestamp"
+        # TODO
+        new_issue Limitations::TIMESTAMP_TYPE_NOT_IMPLEMENTED
+      when "scalar"
+        # Use one of
+        target["oneOf"] = [
+          { "type" => "string" },
+          { "type" => "number" },
+          { "type" => "integer" },
+          { "type" => "boolean" },
+        ]
+      when "any"
+        # Don't put type
+      else
+        new_issue("Unknown Kwalify type #{ktype}")
+      end
+
+      target["enum"] = kelem["enum"] if kelem["enum"]
+      if range = kelem["range"]
+        target["minimum"] = range["min"] if range["min"]
+        target["maximum"] = range["max"] if range["max"]
+        if range["min-ex"]
+          target["minimum"] = range["min-ex"]
+          target["exclusiveMinimum"] = true
+        end
+        if range["max-ex"]
+          target["maximum"] = range["max-ex"]
+          target["exclusiveMaximum"] = true
+        end
+      end
+      if pa = kelem["pattern"]
+        # Remove leading and trailing slash
+        target["pattern"] = pa.sub(/^\//, "").sub(/\/$/, "")
+      end
+
+      if length = kelem["length"]
+        case ktype
+        when "str", "text"
+          target["minLength"] = length["min"] if length["min"]
+          target["maxLength"] = length["max"] if length["max"]
+          target["minLength"] = length["min-ex"] + 1 if length["min-ex"]
+          target["maxLength"] = length["max-ex"] + -1 if length["max-ex"]
+        end
+      end
+
+      new_issue "'unique' is not supported by JSON Schema" if kelem["unique"]
+
+      target
+    end
+
+    def preprocess(kwalify_schema)
+      ep = options.custom_processing
+      return kwalify_schema unless ep.respond_to? :preprocess
+      kwalify_schema = ep.preprocess(kwalify_schema.dup)
+    end
+
+    def postprocess(json_schema)
+      ep = options.custom_processing
+      return json_schema unless ep.respond_to? :postprocess
+      ep.postprocess(json_schema)
+    end
+
+    def new_issue(description)
+      @issues << description
+    end
+  end
+
+
+end

data/home/sylvain/kwalify_to_json_schema/lib/kwalify_to_json_schema/custom_processing.rb

@@ -0,0 +1,14 @@
+module KwalifyToJsonSchema
+  # Template class for custom processing
+  class CustomProcessing
+    # The method will be called before conversion allowing to customize the input Kwalify schema.
+    # The implementation have to return the modified schema.
+    # The default implemention don't modify the schema.
+    def preproces(kwalify_schema); kwalify_schema; end
+
+    # The method will be called after the conversion allowing to customize the output JSON schema.
+    # The implementation have to return the modified schema.
+    # The default implemention don't modify the schema.
+    def postprocess(json_schema); json_schema; end
+  end
+end

data/home/sylvain/kwalify_to_json_schema/lib/kwalify_to_json_schema/kwalify_to_json_schema.rb

@@ -0,0 +1,51 @@
+module KwalifyToJsonSchema
+
+  # Convert a Kwalify schema file to JSON .schema.
+  # The destination file can be JSON or YAML.
+  # The file extension is used to select the format: .json or .yaml.
+  # Other extension will fallback to JSON.
+  # Converter options:
+  # | Name                  | Type   | Default value| Description                                         |
+  # |-----------------------|--------|--------------|-----------------------------------------------------|
+  # | :id                   | String | nil          | The JSON schema identifier                          |
+  # | :title                | String | nil          | The JSON schema title                               |
+  # | :description          | String | nil          | The JSON schema description                         |
+  # | :issues_to_description| Boolean| false        | To append the issuses to the JSON schema description|
+  # | :custom_processing    | Object | nil          | To customize the conversion                         |
+  # --
+  # @param source Path to Kwalify YAML schema
+  # @param dest Path to resulting JSON schema
+  def self.convert_file(source, dest, options = {})
+    # Get a converter
+    converter = Converter.new(options)
+    # Convert
+    converted = converter.exec(Serialization.deserialize_from_file(source))
+    # Serialize
+    Serialization.serialize_to_file(dest, converted)
+  end
+
+  # Convert a Kwalify schema string to JSON .schema.
+  # The source and destination strings can be JSON or YAML.
+  # Other extension will fallback to JSON.
+  # Converter options:
+  # | Name                  | Type   | Default value| Description                                         |
+  # |-----------------------|--------|--------------|-----------------------------------------------------|
+  # | :id                   | String | nil          | The JSON schema identifier                          |
+  # | :title                | String | nil          | The JSON schema title                               |
+  # | :description          | String | nil          | The JSON schema description                         |
+  # | :issues_to_description| Boolean| false        | To append the issuses to the JSON schema description|
+  # | :custom_processing    | Object | nil          | To customize the conversion                         |
+  # --
+  # @param kwalify_schema Kwalify schema as YAML or JSON
+  # @param source_format format of the source schema
+  # @param dest_format format of the destination schema
+  # @param options
+  def self.convert_string(kwalify_schema, source_format = "yaml", dest_format = "json", options = {})
+    # Get a converter
+    converter = Converter.new(options)
+    # Convert
+    converted = converter.exec(Serialization.deserialize_from_string(kwalify_schema, source_format))
+    # Serialize
+    Serialization.serialize_to_string(converted, dest_format)
+  end
+end

data/home/sylvain/kwalify_to_json_schema/lib/kwalify_to_json_schema/limitations.rb

@@ -0,0 +1,8 @@
+module KwalifyToJsonSchema
+  # Enumeration of known implementation limitation
+  module Limitations
+    DATE_TYPE_NOT_IMPLEMENTED = "Kwalify 'date' type is not supported and is ignored"
+    TIME_TYPE_NOT_IMPLEMENTED = "Kwalify 'time' type is not supported and is ignored"
+    TIMESTAMP_TYPE_NOT_IMPLEMENTED = "Kwalify 'timestamp' type is not supported and is ignored"
+  end
+end

data/home/sylvain/kwalify_to_json_schema/lib/kwalify_to_json_schema/options.rb

@@ -0,0 +1,74 @@
+module KwalifyToJsonSchema
+  # The possible options for the conversion and the associated accessors
+  class Options
+    # Converter options:
+    # | Name                  | Type   | Default value| Description                                         |
+    # |-----------------------|--------|--------------|-----------------------------------------------------|
+    # | :id                   | String | nil          | The JSON schema identifier                          |
+    # | :title                | String | nil          | The JSON schema title                               |
+    # | :description          | String | nil          | The JSON schema description                         |
+    # | :issues_to_description| Boolean| false        | To append the issuses to the JSON schema description|
+    # | :custom_processing    | Object | nil          | To customize the conversion                         |
+    # --
+    DECLARATION = %q(
+    ID                    # The JSON schema identifier [String] (nil)
+    TITLE                 # The JSON schema title [String] (nil)
+    DESCRIPTION           # The JSON schema description [String] (nil)
+    ISSUES_TO_DESCRIPTION # To append the issuses to the JSON schema description [Boolean] (false)
+    CUSTOM_PROCESSING     # To customize the conversion [Object] (nil)
+    )
+
+    # The options as Hash
+    attr_reader :options_hash
+
+    def initialize(options_hash)
+      @options_hash = options_hash
+    end
+
+    # Parse options declaration text and give an array of Hash
+    def self.parse
+      DECLARATION.lines.map { |l|
+        next nil if l.strip.empty?
+
+        # Parse line
+        const_name, comment = l.split("#", 2).map(&:strip)
+        name = const_name.downcase.to_s
+        description = comment.split("[").first.strip
+        # Get type and default value
+        m = comment.match(/\[(.+)\].*\((.+)\)/)
+        type, default_value = m.captures
+        default_value = eval(default_value)
+
+        # Create read accessor
+        attr_reader_name = "#{name}#{type == "Boolean" ? "?" : ""}"
+
+        # Array entry as Hash for the option
+        {
+          const_name: const_name,
+          const_name_full: "#{Options.name}::#{const_name}",
+          name: name,
+          description: description,
+          type: type,
+          default_value: default_value,
+          attr_reader_name: attr_reader_name,
+        }
+      }.compact
+    end
+
+    # Setup the constants and methods for the options
+    # Example: ID will lead to get ID constant and :id method
+    def self.setup
+      parse.each { |o|
+        # Create constant
+        const_set o[:const_name], o[:name]
+
+        # Create read accessor
+        define_method(o[:attr_reader_name]) {
+          options_hash[o[:name]] || o[:default_value]
+        }
+      }
+    end
+
+    setup
+  end
+end

data/home/sylvain/kwalify_to_json_schema/lib/kwalify_to_json_schema/serialization.rb

@@ -0,0 +1,45 @@
+module KwalifyToJsonSchema
+
+  # Abstract JSON/YAML serialization/deserialization
+  module Serialization
+    def self.deserialize_from_file(file)
+      serialization_for_file(file).deserialize(File.read(file))
+    end
+
+    def self.serialize_to_file(file, object)
+      File.write(file, serialization_for_file(file).serialize(object))
+    end
+
+    def self.deserialize_from_string(string, format = "yaml")
+      serialization_for_format(format).deserialize(string)
+    end
+
+    def self.serialize_to_string(object, format = "json")
+      serialization_for_format(format).serialize(object)
+    end
+
+    # @return a Hash giving serialization/deserialization module and methods for a given file extension (.json/.yaml)
+    def self.serialization_for_file(file)
+      serialization_for_format(File.extname(file)[1..-1])
+    end
+
+    # @return a Hash giving serialization/deserialization module and methods for a format (json/yaml)
+    def self.serialization_for_format(format)
+      serializer = { "json" => Json, "yaml" => Yaml }[format] || Json
+    end
+
+    class Language
+      def self.normalize(string); serialize(deserialize(string)); end
+    end
+
+    class Json < Language
+      def self.serialize(object); JSON.pretty_generate(object); end
+      def self.deserialize(string); JSON.parse(string); end
+    end
+
+    class Yaml < Language
+      def self.serialize(object); YAML.dump(object); end
+      def self.deserialize(string); YAML.load(string); end
+    end
+  end
+end

data/home/sylvain/kwalify_to_json_schema/test/custom_processing.rb

@@ -0,0 +1,14 @@
+# Customization of Kwalify to JSON schema
+class CustomProcessing
+  def preprocess(kwalify_schema)
+    # Remove and keep the wrapping name
+    head = kwalify_schema.first
+    @name = head.first
+    head.last
+  end
+
+  def postprocess(json_schema)
+    # Restore the wrapping name
+    { @name => json_schema }
+  end
+end

data/home/sylvain/kwalify_to_json_schema/test/test_kwalify_to_json_schema.rb

@@ -0,0 +1,75 @@
+require "minitest/autorun"
+require "json-schema"
+require_relative "../lib/kwalify_to_json_schema"
+
+module KwalifyToJsonSchema
+  class Test < Minitest::Test
+    @@debug = false
+    @@tmpdir = Dir.mktmpdir
+
+    [
+      { test_group: "conversion", cli_options: [] },
+      { test_group: "custom_processing", cli_options: ["--custom-processing", File.join(__dir__, "custom_processing.rb")] },
+    ].each { |entry|
+      test_group = entry[:test_group]
+      cli_options = entry[:cli_options]
+
+      # Create a test method for every Kwalify schema
+      Dir.glob(File.join(__dir__, test_group, "kwalify", "*.yaml")).each { |source|
+        test_file_base = File.basename(source, File.extname(source))
+        test_name_base = test_file_base.gsub("#", "_")
+        expected_formats = %w(json yaml)
+
+        # Define a method for the test JSON output
+        define_method("test_#{test_group}_#{test_name_base}_output".to_sym) {
+          formats_done = 0
+          expected_formats.map { |expected_format|
+            output_file = test_file_base + ".#{expected_format}"
+            expected = File.join(File.join(__dir__, test_group, "json_schema", expected_format, output_file))
+
+            next unless File.exist?(expected)
+            formats_done += 1
+
+            ser = KwalifyToJsonSchema::Serialization::serialization_for_format(expected_format)
+            dest = File.join(@@tmpdir, output_file)
+
+            args = ["convert", source, dest]
+            # Add issues to description if filename include "#issues_to_description"
+            args << "--issues_to_description" if output_file.include?("#issues_to_description")
+            args.concat cli_options
+
+            # Convert
+            # KwalifyToJsonSchema.convert_file(source, dest, options)
+            KwalifyToJsonSchema::Cli.start(args)
+
+            # Validate schema
+            validate_json_schema_file(dest)
+
+            if @@debug
+              puts test_name_base
+              puts ser.normalize(File.read(dest))
+            end
+            # Compare to expected result
+            assert_equal(
+              ser.normalize(File.read(expected)),
+              ser.normalize(File.read(dest))
+            )
+          }
+
+          skip "None of the expected #{expected_formats.join(", ")} result for test #{test_name_base} was found" if formats_done == 0
+        }
+      }
+    }
+
+    def validate_json_schema_file(schema_file)
+      schema = KwalifyToJsonSchema::Serialization::deserialize_from_file(schema_file)
+      validate_json_schema(schema)
+    end
+
+    def validate_json_schema(schema)
+      # FIXME draft7 is not available in current json-schema gem
+      metaschema = JSON::Validator.validator_for_name("draft4").metaschema
+      JSON::Validator.validate!(metaschema, schema)
+    end
+  end
+end

data/home/sylvain/kwalify_to_json_schema/tools/all.rb

@@ -0,0 +1,4 @@
+require_relative "../lib/kwalify_to_json_schema"
+require_relative "doc_template"
+require_relative "limitations"
+require_relative "options"

data/home/sylvain/kwalify_to_json_schema/tools/doc_template.rb

@@ -0,0 +1,13 @@
+require "erb"
+
+module DocTemplate
+  def self.render(template_file, dest_file)
+    template = ERB.new(File.read(template_file), nil, "-")
+    File.write(dest_file, template.result(get_binding(template_file)))
+  end
+
+  def self.get_binding(template_file)
+    template_dir = File.dirname template_file
+    binding
+  end
+end

data/home/sylvain/kwalify_to_json_schema/tools/limitations.rb

@@ -0,0 +1,19 @@
+require_relative "../lib/kwalify_to_json_schema/limitations"
+
+# Gives implementation limitations
+module Limitations
+
+  # @return list of limitation as array of strings
+  def self.list
+    KwalifyToJsonSchema::Limitations.constants.map { |cst|
+      KwalifyToJsonSchema::Limitations.const_get(cst)
+    }
+  end
+
+  # @return limitation as markdown text
+  def self.markdown
+    list.map { |l|
+      "* #{l}"
+    }.join("\n")
+  end
+end

data/home/sylvain/kwalify_to_json_schema/tools/options.rb

@@ -0,0 +1,96 @@
+require "yaml"
+require_relative "../lib/kwalify_to_json_schema/options"
+
+# Gives implementation limitations
+module Options
+
+  # @return list of limitation as array of strings
+  def self.list
+    KwalifyToJsonSchema::Options.parse
+  end
+
+  # @return limitation as markdown text
+  def self.ascii_table(formatting = ["%s"] * 4)
+    header = ["Name", "Type", "Default value", "Description"]
+
+    nb_cols = header.length
+
+    table = [header] +
+            [[""] * nb_cols] +
+            list.map { |o|
+              [
+                formatting[0] % o[:name].to_sym.inspect,
+                formatting[1] % o[:type],
+                formatting[2] % o[:default_value].inspect,
+                formatting[3] % o[:description],
+              ]
+            }
+    nb_rows = table.length
+
+    cols_max_length = (0..nb_cols - 1).map { |c|
+      (0..nb_rows - 1).map { |r|
+        cell = table[r][c]
+        cell.length
+      }.max
+    }
+
+    table.map.each_with_index { |row, r|
+      row.map.each_with_index { |cell, c|
+        max_length = cols_max_length[c]
+        if r == 1
+          "|-" + cell + ("-" * (max_length - cell.length))
+        else
+          "| " + cell + (" " * (max_length - cell.length))
+        end
+      }.join + "|"
+    }.join "\n"
+  end
+
+  def self.markdown
+    ascii_table [
+      "`%s`",
+      "`%s`",
+      "`%s`",
+      "_%s_",
+    ]
+  end
+
+  def self.inject_as_code_comment(file)
+    new_lines = []
+    state = :init
+    count = 0
+
+    options_start = "Converter options:"
+    options_stop = "--"
+
+    File.read(file).each_line { |line|
+      if line.strip.start_with? "#"
+        content = line.strip[1..-1].strip
+        case state
+        when :init
+          new_lines << line
+          if content == options_start
+            count += 1
+            state = :in_options
+            padding = line.index("#")
+            new_lines.concat(ascii_table.lines.map { |l| "#{" " * padding}# #{l.chomp}\n" })
+          end
+        when :in_options
+          if content.start_with? options_stop
+            new_lines << line
+            state = :init
+          end
+        end
+      else
+        state = :error unless state == :init
+        new_lines << line
+      end
+    }
+
+    if state == :error
+      puts "Missing '#{options_stop}' delimiter after '#{options_start}' in file://#{file}"
+    else
+      File.write(file, new_lines.join) if count > 0
+    end
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: kwalify_to_json_schema
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sylvain Gamot
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-06-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: coderay
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: kwalify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.2
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 12.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 12.3.0
+description: Allows to convert Kwalify schemas to JSON schemas Draft 7
+email: ''
+executables:
+- kwalify_to_json_schema
+extensions: []
+extra_rdoc_files: []
+files:
+- "/home/sylvain/kwalify_to_json_schema/lib/kwalify_to_json_schema.rb"
+- "/home/sylvain/kwalify_to_json_schema/lib/kwalify_to_json_schema/cli.rb"
+- "/home/sylvain/kwalify_to_json_schema/lib/kwalify_to_json_schema/converter.rb"
+- "/home/sylvain/kwalify_to_json_schema/lib/kwalify_to_json_schema/custom_processing.rb"
+- "/home/sylvain/kwalify_to_json_schema/lib/kwalify_to_json_schema/kwalify_to_json_schema.rb"
+- "/home/sylvain/kwalify_to_json_schema/lib/kwalify_to_json_schema/limitations.rb"
+- "/home/sylvain/kwalify_to_json_schema/lib/kwalify_to_json_schema/options.rb"
+- "/home/sylvain/kwalify_to_json_schema/lib/kwalify_to_json_schema/serialization.rb"
+- "/home/sylvain/kwalify_to_json_schema/test/custom_processing.rb"
+- "/home/sylvain/kwalify_to_json_schema/test/test_kwalify_to_json_schema.rb"
+- "/home/sylvain/kwalify_to_json_schema/tools/all.rb"
+- "/home/sylvain/kwalify_to_json_schema/tools/doc_template.rb"
+- "/home/sylvain/kwalify_to_json_schema/tools/limitations.rb"
+- "/home/sylvain/kwalify_to_json_schema/tools/options.rb"
+- bin/kwalify_to_json_schema
+homepage: https://rubygems.org/gems/kwalify_to_json_schema
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Kwalify schemas to JSON schemas conversion
+test_files: []