kwalify_to_json_schema 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dbf127bd97917313787d2e8627ab38a3ef403edbf32bf77af9b1be706525a71e
-  data.tar.gz: 2b055ce7452bd80faa88b40c33d11644779f2ada1a2b7b63a0c7a1470fe55a2c
+  metadata.gz: 2e3e11103f87d4445e81beb29fe9b36d3dc17c0e03b399d2d088d9b1fa8504d8
+  data.tar.gz: c2e09d2aa94ceb1a5588f9e175b402ee11a3260d6b1441471eec1f304e7b29d6
 SHA512:
-  metadata.gz: 03533367dd66aed289370d6aa7bfe03578dab440c59498bc030e8e4179d53917577e7064f12bc5e2ca30f32fda464fabf22c47424a70741a209669fef170d357
-  data.tar.gz: 00a4daafa64abeebac771e70b8809ad3475a8e97ca4bc8d6dc26a92735e25b2cb9ab573b876d79127e87146b5efd48c60206b11b0ad25edeee71b00493b24c0a
+  metadata.gz: '09fd74c1ade4d0e9389d46ec6d93d40d9ce797a34bc951eaf0354c3dfe2f2464c2a2849e65b4dc0ebaa682648816eb16b0b79c91ba56f4815d0ac309473e28d8'
+  data.tar.gz: e78af6fbb9e4c2cd3e17e4168abd3615b5e798ffb318a737b5978a8613af4548a7ac4a36bae783e228b2d9314e0f4815ce6172ccb6a1b3789f8bdde491c89abb

data/{home/sylvain/kwalify_to_json_schema/lib → lib}/kwalify_to_json_schema/cli.rb

@@ -25,11 +25,11 @@ module KwalifyToJsonSchema
 
     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,
+    option(*Options.cli_option(Options::ID))
+    option(*Options.cli_option(Options::TITLE))
+    option(*Options.cli_option(Options::DESCRIPTION))
+    option(*Options.cli_option(Options::ISSUES_TO_DESCRIPTION))
+    option Options::CUSTOM_PROCESSING,
            :type => :string,
            :desc => <<~DESC
              Allows to provide a pre/post processing file on handled schemas.
@@ -38,10 +38,8 @@ module KwalifyToJsonSchema
            DESC
 
     def convert(kwalify_schema_file, result_file)
-      opts = {
-        Options::ISSUES_TO_DESCRIPTION => options[:issues_to_description],
-        Options::CUSTOM_PROCESSING => custom_processing(options),
-      }
+      opts = options.dup
+      opts[Options::CUSTOM_PROCESSING] = custom_processing(options)
       KwalifyToJsonSchema.convert_file(kwalify_schema_file, result_file, opts)
     end
 
@@ -49,10 +47,7 @@ module KwalifyToJsonSchema
 
     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(*Options.cli_option(:issues_to_description))
     option :format,
            :type => :string,
            :enum => ["json", "yaml"],
@@ -63,7 +58,7 @@ module KwalifyToJsonSchema
            :default => false,
            :desc => "Process files recursively",
            :long_desc => ""
-    option :custom_processing,
+    option Options::CUSTOM_PROCESSING,
            :type => :string,
            :desc => <<~DESC
              Allows to provide a pre/post processing file on handled schemas.
@@ -98,7 +93,7 @@ module KwalifyToJsonSchema
         begin
           processing_class = Object.const_get :CustomProcessing
           custom_processing = processing_class.new
-        rescue NameError => e
+        rescue NameError
           raise "The 'CustomProcessing' module must be defined in #{pf}"
         end
       end

data/{home/sylvain/kwalify_to_json_schema/lib → lib}/kwalify_to_json_schema/converter.rb

@@ -19,13 +19,13 @@ module KwalifyToJsonSchema
     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                         |
+    # | 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. If not given the Kwalify description will be used if present|
+    # | :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)
@@ -46,6 +46,9 @@ module KwalifyToJsonSchema
         description << issues.map { |issue| "* #{issue}" }.join("\n")
       end
 
+      # Override description if given in option
+      json_schema["description"] = options.description if options.description
+
       postprocess(json_schema)
     end
 
@@ -56,7 +59,6 @@ module KwalifyToJsonSchema
         "$schema" => SCHEMA,
         "$id" => options.id,
         "title" => options.title,
-        "description" => options.description,
       }.reject { |k, v| v.nil? }
     end
 
@@ -152,7 +154,7 @@ module KwalifyToJsonSchema
         end
       end
 
-      new_issue "'unique' is not supported by JSON Schema" if kelem["unique"]
+      new_issue Limitations::UNIQUE_NOT_SUPPORTED if kelem["unique"]
 
       target
     end
@@ -173,6 +175,4 @@ module KwalifyToJsonSchema
       @issues << description
     end
   end
-
-
 end

data/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. If not given the Kwalify description will be used if present|
+  # | :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. If not given the Kwalify description will be used if present|
+  # | :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 → lib}/kwalify_to_json_schema/limitations.rb

@@ -1,8 +1,9 @@
 module KwalifyToJsonSchema
-  # Enumeration of known implementation limitation
+  # Enumeration of known implementation limitations
   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"
+    UNIQUE_NOT_SUPPORTED = "Kwalify 'unique' is not supported by JSON Schema and is ignored"
   end
 end

data/{home/sylvain/kwalify_to_json_schema/lib → lib}/kwalify_to_json_schema/options.rb

@@ -2,20 +2,20 @@ 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                         |
+    # | 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. If not given the Kwalify description will be used if present|
+    # | :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)
+    ID                    # The JSON schema identifier [string] (nil)
+    TITLE                 # The JSON schema title [string] (nil)
+    DESCRIPTION           # The JSON schema description. If not given the Kwalify description will be used if present [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
@@ -40,13 +40,13 @@ module KwalifyToJsonSchema
         default_value = eval(default_value)
 
         # Create read accessor
-        attr_reader_name = "#{name}#{type == "Boolean" ? "?" : ""}"
+        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,
+          name: name.to_sym,
           description: description,
           type: type,
           default_value: default_value,
@@ -55,6 +55,11 @@ module KwalifyToJsonSchema
       }.compact
     end
 
+    # Same as :parse but give a Hash with the name as key
+    def self.parse_hash
+      parse.map { |e| [e[:name], e] }.to_h
+    end
+
     # Setup the constants and methods for the options
     # Example: ID will lead to get ID constant and :id method
     def self.setup
@@ -69,6 +74,12 @@ module KwalifyToJsonSchema
       }
     end
 
+    # Get description for option name
+    def self.cli_option(name)
+      o = parse_hash[name]
+      [o[:name], :type => o[:type].to_sym, :default => o[:default_value], :desc => o[:description]]
+    end
+
     setup
   end
 end

data/{home/sylvain/kwalify_to_json_schema/lib → lib}/kwalify_to_json_schema/serialization.rb

@@ -25,7 +25,7 @@ module KwalifyToJsonSchema
 
     # @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
+      { "json" => Json, "yaml" => Yaml }[format] || Json
     end
 
     class Language

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kwalify_to_json_schema
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Sylvain Gamot
@@ -87,25 +87,21 @@ executables:
 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
+- lib/kwalify_to_json_schema.rb
+- lib/kwalify_to_json_schema/cli.rb
+- lib/kwalify_to_json_schema/converter.rb
+- lib/kwalify_to_json_schema/custom_processing.rb
+- lib/kwalify_to_json_schema/kwalify_to_json_schema.rb
+- lib/kwalify_to_json_schema/limitations.rb
+- lib/kwalify_to_json_schema/options.rb
+- lib/kwalify_to_json_schema/serialization.rb
+homepage: https://github.com/s-ga/kwalify_to_json_schema
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/s-ga/kwalify_to_json_schema/issues
+  source_code_uri: https://github.com/s-ga/kwalify_to_json_schema
 post_install_message: 
 rdoc_options: []
 require_paths:

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

@@ -1,51 +0,0 @@
-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/test/custom_processing.rb

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

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

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

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

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

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