kinetic_sdk 5.0.19 → 5.0.21

data/gems/mime-types-3.4.1/test/test_mime_types.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "mime/types"
+require "minitest_helper"
+
+describe MIME::Types do
+  def mime_types
+    @mime_types ||= MIME::Types.new.tap { |mt|
+      mt.add MIME::Type.new(["text/plain", %w[txt]]),
+        MIME::Type.new(["image/jpeg", %w[jpg jpeg]]),
+        MIME::Type.new("application/x-wordperfect6.1"),
+        MIME::Type.new(
+          "content-type" => "application/x-www-form-urlencoded",
+          "registered" => true
+        ),
+        MIME::Type.new(["application/x-gzip", %w[gz]]),
+        MIME::Type.new(
+          "content-type" => "application/gzip",
+          "extensions" => "gz",
+          "registered" => true
+        )
+    }
+  end
+
+  describe "is enumerable" do
+    it "correctly uses an Enumerable method like #any?" do
+      assert(mime_types.any? { |type| type.content_type == "text/plain" })
+    end
+
+    it "implements each with no parameters to return an Enumerator" do
+      assert_kind_of Enumerator, mime_types.each
+      assert_kind_of Enumerator, mime_types.map
+    end
+
+    it "will create a lazy enumerator" do
+      assert_kind_of Enumerator::Lazy, mime_types.lazy
+      assert_kind_of Enumerator::Lazy, mime_types.map.lazy
+    end
+
+    it "is countable with an enumerator" do
+      assert_equal 6, mime_types.each.count
+      assert_equal 6, mime_types.lazy.count
+    end
+  end
+
+  describe "#[]" do
+    it "can be searched with a MIME::Type" do
+      text_plain = MIME::Type.new("text/plain")
+      assert_includes mime_types[text_plain], "text/plain"
+      assert_equal 1, mime_types[text_plain].size
+    end
+
+    it "can be searched with a regular expression" do
+      assert_includes mime_types[/plain$/], "text/plain"
+      assert_equal 1, mime_types[/plain$/].size
+    end
+
+    it "sorts by priority with multiple matches" do
+      assert_equal %w[application/gzip application/x-gzip], mime_types[/gzip$/]
+      assert_equal 2, mime_types[/gzip$/].size
+    end
+
+    it "can be searched with a string" do
+      assert_includes mime_types["text/plain"], "text/plain"
+      assert_equal 1, mime_types["text/plain"].size
+    end
+
+    it "can be searched with the complete flag" do
+      assert_empty mime_types[
+        "application/x-www-form-urlencoded",
+        complete: true
+      ]
+      assert_includes mime_types["text/plain", complete: true], "text/plain"
+      assert_equal 1, mime_types["text/plain", complete: true].size
+    end
+
+    it "can be searched with the registered flag" do
+      assert_empty mime_types["application/x-wordperfect6.1", registered: true]
+      refute_empty mime_types[
+        "application/x-www-form-urlencoded",
+        registered: true
+      ]
+      refute_empty mime_types[/gzip/, registered: true]
+      refute_equal mime_types[/gzip/], mime_types[/gzip/, registered: true]
+    end
+
+    it "properly returns an empty result on a regular expression miss" do
+      assert_empty mime_types[/^foo/]
+      assert_empty mime_types[/^foo/, registered: true]
+      assert_empty mime_types[/^foo/, complete: true]
+    end
+  end
+
+  describe "#add" do
+    let(:eruby) { MIME::Type.new("application/x-eruby") }
+    let(:jinja) { MIME::Type.new("application/jinja2") }
+
+    it "successfully adds a new type" do
+      mime_types.add(eruby)
+      assert_equal mime_types["application/x-eruby"], [eruby]
+    end
+
+    it "complains about adding a duplicate type" do
+      mime_types.add(eruby)
+      assert_output "", /is already registered as a variant/ do
+        mime_types.add(eruby)
+      end
+      assert_equal mime_types["application/x-eruby"], [eruby]
+    end
+
+    it "does not complain about adding a duplicate type when quiet" do
+      mime_types.add(eruby)
+      assert_output "", "" do
+        mime_types.add(eruby, :silent)
+      end
+      assert_equal mime_types["application/x-eruby"], [eruby]
+    end
+
+    it "successfully adds from an array" do
+      mime_types.add([eruby, jinja])
+      assert_equal mime_types["application/x-eruby"], [eruby]
+      assert_equal mime_types["application/jinja2"], [jinja]
+    end
+
+    it "successfully adds from another MIME::Types" do
+      mt = MIME::Types.new
+      mt.add(mime_types)
+      assert_equal mime_types.count, mt.count
+
+      mime_types.each do |type|
+        assert_equal mt[type.content_type], [type]
+      end
+    end
+  end
+
+  describe "#type_for" do
+    it "finds all types for a given extension" do
+      assert_equal %w[application/gzip application/x-gzip],
+        mime_types.type_for("gz")
+    end
+
+    it "separates the extension from filenames" do
+      assert_equal %w[image/jpeg], mime_types.of(["foo.jpeg", "bar.jpeg"])
+    end
+
+    it "finds multiple extensions" do
+      assert_equal %w[image/jpeg text/plain],
+        mime_types.type_for(%w[foo.txt foo.jpeg])
+    end
+
+    it "does not find unknown extensions" do
+      keys = mime_types.instance_variable_get(:@extension_index).keys
+      assert_empty mime_types.type_for("zzz")
+      assert_equal keys, mime_types.instance_variable_get(:@extension_index).keys
+    end
+
+    it "modifying type extensions causes reindexing" do
+      plain_text = mime_types["text/plain"].first
+      plain_text.add_extensions("xtxt")
+      assert_includes mime_types.type_for("xtxt"), "text/plain"
+    end
+  end
+
+  describe "#count" do
+    it "can count the number of types inside" do
+      assert_equal 6, mime_types.count
+    end
+  end
+end

data/gems/mime-types-3.4.1/test/test_mime_types_cache.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "mime/types"
+require "minitest_helper"
+
+MUTEX = Mutex.new
+
+describe MIME::Types::Cache do
+  include Minitest::Hooks
+
+  def around
+    require "fileutils"
+
+    MUTEX.synchronize do
+      @cache_file = File.expand_path("../cache.tst", __FILE__)
+      ENV["RUBY_MIME_TYPES_CACHE"] = @cache_file
+      clear_cache_file
+
+      super
+
+      clear_cache_file
+      ENV.delete("RUBY_MIME_TYPES_CACHE")
+    end
+  end
+
+  def reset_mime_types
+    MIME::Types.instance_variable_set(:@__types__, nil)
+    MIME::Types.send(:load_default_mime_types)
+  end
+
+  def clear_cache_file
+    FileUtils.rm @cache_file if File.exist? @cache_file
+  end
+
+  describe ".load" do
+    it "does not use cache when RUBY_MIME_TYPES_CACHE is unset" do
+      ENV.delete("RUBY_MIME_TYPES_CACHE")
+      assert_nil MIME::Types::Cache.load
+    end
+
+    it "does not use cache when missing" do
+      assert_nil MIME::Types::Cache.load
+    end
+
+    it "registers the data to be updated by #add_extensions" do
+      MIME::Types::Cache.save
+      reset_mime_types
+      assert_equal([], MIME::Types.type_for("foo.additional"))
+      html = MIME::Types["text/html"][0]
+      html.add_extensions("additional")
+      assert_equal([html], MIME::Types.type_for("foo.additional"))
+    end
+
+    it "outputs an error when there is an invalid version" do
+      v = MIME::Types::Data::VERSION
+      MIME::Types::Data.send(:remove_const, :VERSION)
+      MIME::Types::Data.const_set(:VERSION, "0.0")
+      MIME::Types::Cache.save
+      MIME::Types::Data.send(:remove_const, :VERSION)
+      MIME::Types::Data.const_set(:VERSION, v)
+      MIME::Types.instance_variable_set(:@__types__, nil)
+      assert_output "", /MIME::Types cache: invalid version/ do
+        MIME::Types["text/html"]
+      end
+    end
+
+    it "outputs an error when there is a marshal file incompatibility" do
+      MIME::Types::Cache.save
+      data = File.binread(@cache_file).reverse
+      File.open(@cache_file, "wb") { |f| f.write(data) }
+      MIME::Types.instance_variable_set(:@__types__, nil)
+      assert_output "", /incompatible marshal file format/ do
+        MIME::Types["text/html"]
+      end
+    end
+  end
+
+  describe ".save" do
+    it "does not create cache when RUBY_MIME_TYPES_CACHE is unset" do
+      ENV.delete("RUBY_MIME_TYPES_CACHE")
+      assert_nil MIME::Types::Cache.save
+    end
+
+    it "creates the cache " do
+      assert_equal(false, File.exist?(@cache_file))
+      MIME::Types::Cache.save
+      assert_equal(true, File.exist?(@cache_file))
+    end
+
+    it "uses the cache" do
+      MIME::Types["text/html"].first.add_extensions("hex")
+      MIME::Types::Cache.save
+      MIME::Types.instance_variable_set(:@__types__, nil)
+
+      assert_includes MIME::Types["text/html"].first.extensions, "hex"
+
+      reset_mime_types
+    end
+  end
+end
+
+describe MIME::Types::Container do
+  it "marshals and unmarshals correctly" do
+    container = MIME::Types::Container.new
+    container.add("xyz", "abc")
+
+    # default proc should return Set[]
+    assert_equal(Set[], container["abc"])
+    assert_equal(Set["abc"], container["xyz"])
+
+    marshalled = Marshal.dump(container)
+    loaded_container = Marshal.load(marshalled)
+
+    # default proc should still return Set[]
+    assert_equal(Set[], loaded_container["abc"])
+    assert_equal(Set["abc"], container["xyz"])
+  end
+end

data/gems/mime-types-3.4.1/test/test_mime_types_class.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "mime/types"
+require "minitest_helper"
+
+describe MIME::Types, "registry" do
+  def setup
+    MIME::Types.send(:load_default_mime_types)
+  end
+
+  describe "is enumerable" do
+    it "correctly uses an Enumerable method like #any?" do
+      assert(MIME::Types.any? { |type| type.content_type == "text/plain" })
+    end
+
+    it "implements each with no parameters to return an Enumerator" do
+      assert_kind_of Enumerator, MIME::Types.each
+      assert_kind_of Enumerator, MIME::Types.map
+    end
+
+    it "will create a lazy enumerator" do
+      assert_kind_of Enumerator::Lazy, MIME::Types.lazy
+      assert_kind_of Enumerator::Lazy, MIME::Types.map.lazy
+    end
+
+    it "is countable with an enumerator" do
+      assert MIME::Types.each.count > 999
+      assert MIME::Types.lazy.count > 999
+    end
+  end
+
+  describe ".[]" do
+    it "can be searched with a MIME::Type" do
+      text_plain = MIME::Type.new("text/plain")
+      assert_includes MIME::Types[text_plain], "text/plain"
+      assert_equal 1, MIME::Types[text_plain].size
+    end
+
+    it "can be searched with a regular expression" do
+      assert_includes MIME::Types[/plain$/], "text/plain"
+      assert_equal 1, MIME::Types[/plain$/].size
+    end
+
+    it "sorts by priority with multiple matches" do
+      types = MIME::Types[/gzip$/].select { |t|
+        %w[application/gzip application/x-gzip multipart/x-gzip].include?(t)
+      }
+      # This is this way because of a new type ending with gzip that only
+      # appears in some data files.
+      assert_equal %w[application/gzip application/x-gzip multipart/x-gzip], types
+      assert_equal 3, types.size
+    end
+
+    it "can be searched with a string" do
+      assert_includes MIME::Types["text/plain"], "text/plain"
+      assert_equal 1, MIME::Types["text/plain"].size
+    end
+
+    it "can be searched with the complete flag" do
+      assert_empty MIME::Types[
+        "application/x-www-form-urlencoded",
+        complete: true
+      ]
+      assert_includes MIME::Types["text/plain", complete: true], "text/plain"
+      assert_equal 1, MIME::Types["text/plain", complete: true].size
+    end
+
+    it "can be searched with the registered flag" do
+      assert_empty MIME::Types["application/x-wordperfect6.1", registered: true]
+      refute_empty MIME::Types[
+        "application/x-www-form-urlencoded",
+        registered: true
+      ]
+      refute_empty MIME::Types[/gzip/, registered: true]
+      refute_equal MIME::Types[/gzip/], MIME::Types[/gzip/, registered: true]
+    end
+  end
+
+  describe ".type_for" do
+    it "finds all types for a given extension" do
+      assert_equal %w[application/gzip application/x-gzip],
+        MIME::Types.type_for("gz")
+    end
+
+    it "separates the extension from filenames" do
+      assert_equal %w[image/jpeg], MIME::Types.of(["foo.jpeg", "bar.jpeg"])
+    end
+
+    it "finds multiple extensions" do
+      assert_equal %w[image/jpeg text/plain],
+        MIME::Types.type_for(%w[foo.txt foo.jpeg])
+    end
+
+    it "does not find unknown extensions" do
+      assert_empty MIME::Types.type_for("zzz")
+    end
+
+    it "modifying type extensions causes reindexing" do
+      plain_text = MIME::Types["text/plain"].first
+      plain_text.add_extensions("xtxt")
+      assert_includes MIME::Types.type_for("xtxt"), "text/plain"
+    end
+  end
+
+  describe ".count" do
+    it "can count the number of types inside" do
+      assert MIME::Types.count > 999
+    end
+  end
+
+  describe ".add" do
+    def setup
+      MIME::Types.instance_variable_set(:@__types__, nil)
+      MIME::Types.send(:load_default_mime_types)
+    end
+
+    let(:eruby) { MIME::Type.new("application/x-eruby") }
+    let(:jinja) { MIME::Type.new("application/jinja2") }
+
+    it "successfully adds a new type" do
+      MIME::Types.add(eruby)
+      assert_equal MIME::Types["application/x-eruby"], [eruby]
+    end
+
+    it "complains about adding a duplicate type" do
+      MIME::Types.add(eruby)
+      assert_output "", /is already registered as a variant/ do
+        MIME::Types.add(eruby)
+      end
+      assert_equal MIME::Types["application/x-eruby"], [eruby]
+    end
+
+    it "does not complain about adding a duplicate type when quiet" do
+      MIME::Types.add(eruby)
+      assert_silent do
+        MIME::Types.add(eruby, :silent)
+      end
+      assert_equal MIME::Types["application/x-eruby"], [eruby]
+    end
+
+    it "successfully adds from an array" do
+      MIME::Types.add([eruby, jinja])
+      assert_equal MIME::Types["application/x-eruby"], [eruby]
+      assert_equal MIME::Types["application/jinja2"], [jinja]
+    end
+
+    it "successfully adds from another MIME::Types" do
+      old_count = MIME::Types.count
+
+      mt = MIME::Types.new
+      mt.add(eruby)
+
+      MIME::Types.add(mt)
+      assert_equal old_count + 1, MIME::Types.count
+
+      assert_equal MIME::Types[eruby.content_type], [eruby]
+    end
+  end
+end

data/gems/mime-types-3.4.1/test/test_mime_types_lazy.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "mime/types"
+require "minitest_helper"
+
+describe MIME::Types, "lazy loading" do
+  def setup
+    ENV["RUBY_MIME_TYPES_LAZY_LOAD"] = "true"
+  end
+
+  def teardown
+    reset_mime_types
+    ENV.delete("RUBY_MIME_TYPES_LAZY_LOAD")
+  end
+
+  def reset_mime_types
+    MIME::Types.instance_variable_set(:@__types__, nil)
+    MIME::Types.send(:load_default_mime_types)
+  end
+
+  describe ".lazy_load?" do
+    it "is true when RUBY_MIME_TYPES_LAZY_LOAD is set" do
+      assert_output "", /RUBY_MIME_TYPES_LAZY_LOAD/ do
+        assert_equal true, MIME::Types.send(:lazy_load?)
+      end
+    end
+
+    it "is nil when RUBY_MIME_TYPES_LAZY_LOAD is unset" do
+      ENV["RUBY_MIME_TYPES_LAZY_LOAD"] = nil
+      assert_output "", "" do
+        assert_nil MIME::Types.send(:lazy_load?)
+      end
+    end
+
+    it "is false when RUBY_MIME_TYPES_LAZY_LOAD is false" do
+      ENV["RUBY_MIME_TYPES_LAZY_LOAD"] = "false"
+      assert_output "", /RUBY_MIME_TYPES_LAZY_LOAD/ do
+        assert_equal false, MIME::Types.send(:lazy_load?)
+      end
+    end
+  end
+
+  it "loads lazily when RUBY_MIME_TYPES_LAZY_LOAD is set" do
+    MIME::Types.instance_variable_set(:@__types__, nil)
+    assert_nil MIME::Types.instance_variable_get(:@__types__)
+    refute_nil MIME::Types["text/html"].first
+    refute_nil MIME::Types.instance_variable_get(:@__types__)
+  end
+end

data/gems/mime-types-3.4.1/test/test_mime_types_loader.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "mime/types"
+require "minitest_helper"
+
+describe MIME::Types::Loader do
+  def setup
+    @path = File.expand_path("../fixture", __FILE__)
+    @loader = MIME::Types::Loader.new(@path)
+    @bad_path = File.expand_path("../bad-fixtures", __FILE__)
+  end
+
+  def assert_correctly_loaded(types)
+    assert_includes(types, "application/1d-interleaved-parityfec")
+    assert_equal(%w[webm], types["audio/webm"].first.extensions)
+    refute(types["audio/webm"].first.registered?)
+
+    assert_equal("Fixes a bug with IE6 and progressive JPEGs",
+      types["image/pjpeg"].first.docs)
+
+    assert(types["audio/vnd.qcelp"].first.obsolete?)
+    assert_equal("audio/QCELP", types["audio/vnd.qcelp"].first.use_instead)
+  end
+
+  it "loads YAML files correctly" do
+    assert_correctly_loaded @loader.load_yaml
+  end
+
+  it "loads JSON files correctly" do
+    assert_correctly_loaded @loader.load_json
+  end
+end

data/gems/{mime-types-data-3.2021.0225 → mime-types-data-3.2022.0105}/Code-of-Conduct.md

@@ -4,10 +4,10 @@
 
 In the interest of fostering an open and welcoming environment, we as
 contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age,
-body size, disability, ethnicity, gender identity and expression, level of
-experience, nationality, personal appearance, race, religion, or sexual
-identity and orientation.
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of
+experience, nationality, personal appearance, race, religion, or sexual identity
+and orientation.
 
 ## Our Standards
 
@@ -37,20 +37,20 @@ Project maintainers are responsible for clarifying the standards of acceptable
 behavior and are expected to take appropriate and fair corrective action in
 response to any instances of unacceptable behavior.
 
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
+Project maintainers have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, or to ban temporarily or permanently any
+contributor for other behaviors that they deem inappropriate, threatening,
+offensive, or harmful.
 
 ## Scope
 
 This Code of Conduct applies both within project spaces and in public spaces
 when an individual is representing the project or its community. Examples of
 representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an
-appointed representative at an online or offline event. Representation of a
-project may be further defined and clarified by project maintainers.
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
 
 ## Enforcement
 

data/gems/{mime-types-data-3.2021.0225 → mime-types-data-3.2022.0105}/Contributing.md

@@ -1,7 +1,7 @@
 ## Contributing
 
 Contributions to mime-types-data is encouraged in any form: a bug report, new
-MIME type defintions, or additional code to help manage the MIME types. As with
+MIME type definitions, or additional code to help manage the MIME types. As with
 many of my projects, I have a few suggestions for improving the chance of
 acceptance of your code contributions:
 
@@ -26,12 +26,12 @@ other languages.
 The Ruby mime-types gem loads its data from files encoded in the `data`
 directory in this gem by loading `mime-types-data` and reading
 MIME::Types::Data::PATH. These files are compiled files from the collection of
-data in the `types` directory. Pull requests that include changes to these
-files will require amendment to revert these files.
+data in the `types` directory. Pull requests that include changes to these files
+will require amendment to revert these files.
 
 New or modified MIME types should be edited in the appropriate YAML file under
-`types`. The format is as shown below for the `application/xml` MIME type
-in `types/application.yml`.
+`types`. The format is as shown below for the `application/xml` MIME type in
+`types/application.yml`.
 
 ```yaml
 - !ruby/object:MIME::Type
@@ -43,7 +43,7 @@ in `types/application.yml`.
   references:
     - IANA
     - RFC3023
-  xrefs: !ruby/hash:MIME::Types::Container
+  xrefs:
     rfc:
       - rfc3023
   registered: true
@@ -51,10 +51,10 @@ in `types/application.yml`.
 
 There are other fields that can be added, matching the fields discussed in the
 documentation for MIME::Type. Pull requests for MIME types should just contain
-the changes to the YAML files for the new or modified MIME types; I will
-convert the YAML files to JSON prior to a new release. I would rather not have
-to verify that the JSON matches the YAML changes, which is why it is not
-necessary to convert for the pull request.
+the changes to the YAML files for the new or modified MIME types; I will convert
+the YAML files to JSON prior to a new release. I would rather not have to verify
+that the JSON matches the YAML changes, which is why it is not necessary to
+convert for the pull request.
 
 If you are making a change for a private fork, use `rake convert:yaml:json` to
 convert the YAML to JSON, or `rake convert:yaml:columnar` to convert it to the
@@ -70,6 +70,21 @@ $ rake mime:iana
 $ rake mime:apache
 ```
 
+##### A Note on Provisional Types
+
+The file `types/provisional-standard-types.yaml` contains the provisionally
+registered types from IANA. Per IANA,
+
+> This registry, unlike some other provisional IANA registries, is only for
+> temporary use. Entries in this registry are either finalized and moved to the
+> main media types registry or are abandoned and deleted. Entries in this
+> registry are suitable for use for development and test purposes only.
+
+The provisional types file is rewritten when updated, so pull requests to
+manually promote or customize provisional types (such as with extensions). It is
+recommended that any updates required to the data be performed in your
+application if you require provisional types.
+
 ### Development Dependencies
 
 mime-types-data uses Ryan Davis’s {Hoe}[https://github.com/seattlerb/hoe] to
@@ -132,10 +147,10 @@ Here's the most direct way to get your work merged into the project:
 The release process needs automation; as it includes generating code and
 committing to the repository, it is not clear how this will happen safely.
 
-1. Review any outstanding issues or pull requests to see if anything needs to
-   be addressed. This is necessary because there is currently no automated
-   source for extensions for the thousands of MIME entries. (Suggestions and/or
-   pull requests for same would be deeply appreciated.)
+1. Review any outstanding issues or pull requests to see if anything needs to be
+   addressed. This is necessary because there is currently no automated source
+   for extensions for the thousands of MIME entries. (Suggestions and/or pull
+   requests for same would be deeply appreciated.)
 2. `bundle install`
 3. `bundle exec rake mime:apache`
 4. `bundle exec rake mime:iana`
@@ -145,18 +160,18 @@ committing to the repository, it is not clear how this will happen safely.
    category.)
 6. `bundle exec rake convert`
 7. `bundle exec rake update:version`
-8. Write up the changes in History.md. If any PRs have been merged, these
-   should be noted specifically.
+8. Write up the changes in History.md. If any PRs have been merged, these should
+   be noted specifically.
 9. Commit the changes and push to GitHub.
 10. `bundle exec rake release VERSION=newversion`
 
 ### Automating the Release
 
-If anyone wishes to provide suggestions on automation, this would be a
-two-phase process:
+If anyone wishes to provide suggestions on automation, this would be a two-phase
+process:
 
-1. A system would need to periodically create PRs to the GitHub repository
-   with the output of the following commands (steps 2, 3, and 4):
+1. A system would need to periodically create PRs to the GitHub repository with
+   the output of the following commands (steps 2, 3, and 4):
 
    ```sh
    bundle install
@@ -198,6 +213,8 @@ Thanks to everyone else who has contributed to mime-types:
 - Henrik Hodne
 - Jeremy Evans
 - John Gardner
+- Jon Sneyers
+- Jonas Petersen
 - Juanito Fatas
 - Keerthi Siva
 - Ken Ip