kinetic_sdk 5.0.19 → 5.0.21

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

@@ -1,169 +0,0 @@
-# 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.3.1/test/test_mime_types_cache.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-require 'mime/types'
-require 'minitest_helper'
-
-describe MIME::Types::Cache do
-  include Minitest::Hooks
-
-  MUTEX = Mutex.new
-
-  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') do |f| f.write(data) end
-      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.3.1/test/test_mime_types_class.rb

@@ -1,159 +0,0 @@
-# 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.3.1/test/test_mime_types_lazy.rb

@@ -1,49 +0,0 @@
-# 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.3.1/test/test_mime_types_loader.rb

@@ -1,32 +0,0 @@
-# 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/Licence.md

@@ -1,25 +0,0 @@
-## Licence
-
-- Copyright 2003–2020 Austin Ziegler and other contributors.
-
-The software in this repository is made available under the MIT license.
-
-### MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.