husc 0.2.1 → 0.2.2

data/vendor/bundle/gems/mime-types-3.3.1/lib/mime/types/cache.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-MIME::Types::Cache = Struct.new(:version, :data) # :nodoc:
-
-# Caching of MIME::Types registries is advisable if you will be loading
-# the default registry relatively frequently. With the class methods on
-# MIME::Types::Cache, any MIME::Types registry can be marshaled quickly
-# and easily.
-#
-# The cache is invalidated on a per-data-version basis; a cache file for
-# version 3.2015.1118 will not be reused with version 3.2015.1201.
-class << MIME::Types::Cache
-  # Attempts to load the cache from the file provided as a parameter or in
-  # the environment variable +RUBY_MIME_TYPES_CACHE+. Returns +nil+ if the
-  # file does not exist, if the file cannot be loaded, or if the data in
-  # the cache version is different than this version.
-  def load(cache_file = nil)
-    cache_file ||= ENV['RUBY_MIME_TYPES_CACHE']
-    return nil unless cache_file and File.exist?(cache_file)
-
-    cache = Marshal.load(File.binread(cache_file))
-    if cache.version == MIME::Types::Data::VERSION
-      Marshal.load(cache.data)
-    else
-      MIME::Types.logger.warn <<-WARNING.chomp
-Could not load MIME::Types cache: invalid version
-      WARNING
-      nil
-    end
-  rescue => e
-    MIME::Types.logger.warn <<-WARNING.chomp
-Could not load MIME::Types cache: #{e}
-    WARNING
-    nil
-  end
-
-  # Attempts to save the types provided to the cache file provided.
-  #
-  # If +types+ is not provided or is +nil+, the cache will contain the
-  # current MIME::Types default registry.
-  #
-  # If +cache_file+ is not provided or is +nil+, the cache will be written
-  # to the file specified in the environment variable
-  # +RUBY_MIME_TYPES_CACHE+. If there is no cache file specified either
-  # directly or through the environment, this method will return +nil+
-  def save(types = nil, cache_file = nil)
-    cache_file ||= ENV['RUBY_MIME_TYPES_CACHE']
-    return nil unless cache_file
-
-    types ||= MIME::Types.send(:__types__)
-
-    File.open(cache_file, 'wb') do |f|
-      f.write(
-        Marshal.dump(new(MIME::Types::Data::VERSION, Marshal.dump(types)))
-      )
-    end
-  end
-end

data/vendor/bundle/gems/mime-types-3.3.1/lib/mime/types/columnar.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require 'mime/types'

data/vendor/bundle/gems/mime-types-3.3.1/lib/mime/types/container.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-require 'forwardable'
-
-# MIME::Types requires a serializable keyed container that returns an empty Set
-# on a key miss. Hash#default_value cannot be used because, while it traverses
-# the Marshal format correctly, it won't survive any other serialization
-# format (plus, a default of a mutable object resuls in a shared mess).
-# Hash#default_proc cannot be used without a wrapper because it prevents
-# Marshal serialization (and doesn't survive the round-trip).
-class MIME::Types::Container #:nodoc:
-  extend Forwardable
-
-  def initialize(hash = {})
-    @container = {}
-    merge!(hash)
-  end
-
-  def [](key)
-    container[key] || EMPTY_SET
-  end
-
-  def []=(key, value)
-    container[key] =
-      case value
-      when Set
-        value
-      else
-        Set[*value]
-      end
-  end
-
-  def merge(other)
-    self.class.new(other)
-  end
-
-  def merge!(other)
-    tap {
-      other = other.kind_of?(MIME::Types::Container) ? other.container : other
-      container.merge!(other)
-      normalize
-    }
-  end
-
-  def to_hash
-    container
-  end
-
-  def_delegators :@container,
-                 :==,
-                 :count,
-                 :each,
-                 :each_value,
-                 :empty?,
-                 :flat_map,
-                 :keys,
-                 :select,
-                 :values
-
-  def add(key, value)
-    (container[key] ||= Set.new).add(value)
-  end
-
-  def marshal_dump
-    {}.merge(container)
-  end
-
-  def marshal_load(hash)
-    @container = hash
-  end
-
-  def encode_with(coder)
-    container.each { |k, v| coder[k] = v.to_a }
-  end
-
-  def init_with(coder)
-    @container = {}
-    coder.map.each { |k, v| container[k] = Set[*v] }
-  end
-
-  protected
-
-  attr_accessor :container
-
-  def normalize
-    container.each do |k, v|
-      next if v.kind_of?(Set)
-
-      container[k] = Set[*v]
-    end
-  end
-
-  EMPTY_SET = Set.new.freeze
-  private_constant :EMPTY_SET
-end

data/vendor/bundle/gems/mime-types-3.3.1/lib/mime/types/deprecations.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require 'mime/types/logger'
-
-# The namespace for MIME applications, tools, and libraries.
-module MIME
-  ##
-  class Types
-    # Used to mark a method as deprecated in the mime-types interface.
-    def self.deprecated(klass, sym, message = nil, &block) # :nodoc:
-      level = case klass
-              when Class, Module
-                '.'
-              else
-                klass = klass.class
-                '#'
-              end
-      message = case message
-                when :private, :protected
-                  "and will be #{message}"
-                when nil
-                  'and will be removed'
-                else
-                  message
-                end
-      MIME::Types.logger.warn <<-WARNING.chomp
-#{caller[1]}: #{klass}#{level}#{sym} is deprecated #{message}.
-      WARNING
-      block.call if block
-    end
-  end
-end

data/vendor/bundle/gems/mime-types-3.3.1/lib/mime/types/full.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-##
-module MIME
-  ##
-  class Types
-    unless private_method_defined?(:load_mode)
-      class << self
-        private
-
-        def load_mode
-          { columnar: false }
-        end
-      end
-    end
-  end
-end
-
-require 'mime/types'

data/vendor/bundle/gems/mime-types-3.3.1/lib/mime/types/loader.rb

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-# -*- ruby encoding: utf-8 -*-
-
-##
-module MIME; end
-##
-class MIME::Types; end
-
-require 'mime/types/data'
-
-# This class is responsible for initializing the MIME::Types registry from
-# the data files supplied with the mime-types library.
-#
-# The Loader will use one of the following paths:
-# 1.  The +path+ provided in its constructor argument;
-# 2.  The value of ENV['RUBY_MIME_TYPES_DATA']; or
-# 3.  The value of MIME::Types::Data::PATH.
-#
-# When #load is called, the +path+ will be searched recursively for all YAML
-# (.yml or .yaml) files. By convention, there is one file for each media
-# type (application.yml, audio.yml, etc.), but this is not required.
-class MIME::Types::Loader
-  # The path that will be read for the MIME::Types files.
-  attr_reader :path
-  # The MIME::Types container instance that will be loaded. If not provided
-  # at initialization, a new MIME::Types instance will be constructed.
-  attr_reader :container
-
-  # Creates a Loader object that can be used to load MIME::Types registries
-  # into memory, using YAML, JSON, or Columnar registry format loaders.
-  def initialize(path = nil, container = nil)
-    path = path || ENV['RUBY_MIME_TYPES_DATA'] || MIME::Types::Data::PATH
-    @container = container || MIME::Types.new
-    @path = File.expand_path(path)
-  end
-
-  # Loads a MIME::Types registry from YAML files (<tt>*.yml</tt> or
-  # <tt>*.yaml</tt>) recursively found in +path+.
-  #
-  # It is expected that the YAML objects contained within the registry array
-  # will be tagged as <tt>!ruby/object:MIME::Type</tt>.
-  #
-  # Note that the YAML format is about 2½ times *slower* than the JSON format.
-  #
-  # NOTE: The purpose of this format is purely for maintenance reasons.
-  def load_yaml
-    Dir[yaml_path].sort.each do |f|
-      container.add(*self.class.load_from_yaml(f), :silent)
-    end
-    container
-  end
-
-  # Loads a MIME::Types registry from JSON files (<tt>*.json</tt>)
-  # recursively found in +path+.
-  #
-  # It is expected that the JSON objects will be an array of hash objects.
-  # The JSON format is the registry format for the MIME types registry
-  # shipped with the mime-types library.
-  def load_json
-    Dir[json_path].sort.each do |f|
-      types = self.class.load_from_json(f)
-      container.add(*types, :silent)
-    end
-    container
-  end
-
-  # Loads a MIME::Types registry from columnar files recursively found in
-  # +path+.
-  def load_columnar
-    require 'mime/types/columnar' unless defined?(MIME::Types::Columnar)
-    container.extend(MIME::Types::Columnar)
-    container.load_base_data(path)
-
-    container
-  end
-
-  # Loads a MIME::Types registry. Loads from JSON files by default
-  # (#load_json).
-  #
-  # This will load from columnar files (#load_columnar) if <tt>columnar:
-  # true</tt> is provided in +options+ and there are columnar files in +path+.
-  def load(options = { columnar: false })
-    if options[:columnar] && !Dir[columnar_path].empty?
-      load_columnar
-    else
-      load_json
-    end
-  end
-
-  class << self
-    # Loads the default MIME::Type registry.
-    def load(options = { columnar: false })
-      new.load(options)
-    end
-
-    # Loads MIME::Types from a single YAML file.
-    #
-    # It is expected that the YAML objects contained within the registry
-    # array will be tagged as <tt>!ruby/object:MIME::Type</tt>.
-    #
-    # Note that the YAML format is about 2½ times *slower* than the JSON
-    # format.
-    #
-    # NOTE: The purpose of this format is purely for maintenance reasons.
-    def load_from_yaml(filename)
-      begin
-        require 'psych'
-      rescue LoadError
-        nil
-      end
-      require 'yaml'
-      YAML.load(read_file(filename))
-    end
-
-    # Loads MIME::Types from a single JSON file.
-    #
-    # It is expected that the JSON objects will be an array of hash objects.
-    # The JSON format is the registry format for the MIME types registry
-    # shipped with the mime-types library.
-    def load_from_json(filename)
-      require 'json'
-      JSON.parse(read_file(filename)).map { |type| MIME::Type.new(type) }
-    end
-
-    private
-
-    def read_file(filename)
-      File.open(filename, 'r:UTF-8:-', &:read)
-    end
-  end
-
-  private
-
-  def yaml_path
-    File.join(path, '*.y{,a}ml')
-  end
-
-  def json_path
-    File.join(path, '*.json')
-  end
-
-  def columnar_path
-    File.join(path, '*.column')
-  end
-end

data/vendor/bundle/gems/mime-types-3.3.1/lib/mime/types/logger.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-# -*- ruby encoding: utf-8 -*-
-
-require 'logger'
-
-##
-module MIME
-  ##
-  class Types
-    class << self
-      # Configure the MIME::Types logger. This defaults to an instance of a
-      # logger that passes messages (unformatted) through to Kernel#warn.
-      attr_accessor :logger
-    end
-
-    class WarnLogger < ::Logger #:nodoc:
-      class WarnLogDevice < ::Logger::LogDevice #:nodoc:
-        def initialize(*)
-        end
-
-        def write(m)
-          Kernel.warn(m)
-        end
-
-        def close
-        end
-      end
-
-      def initialize(_one, _two = nil, _three = nil)
-        super nil
-        @logdev = WarnLogDevice.new
-        @formatter = ->(_s, _d, _p, m) { m }
-      end
-    end
-
-    self.logger = WarnLogger.new(nil)
-  end
-end

data/vendor/bundle/gems/mime-types-3.3.1/lib/mime/types/registry.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-class << MIME::Types
-  include Enumerable
-
-  ##
-  def new(*) # :nodoc:
-    super.tap do |types|
-      __instances__.add types
-    end
-  end
-
-  # MIME::Types#[] against the default MIME::Types registry.
-  def [](type_id, complete: false, registered: false)
-    __types__[type_id, complete: complete, registered: registered]
-  end
-
-  # MIME::Types#count against the default MIME::Types registry.
-  def count
-    __types__.count
-  end
-
-  # MIME::Types#each against the default MIME::Types registry.
-  def each
-    if block_given?
-      __types__.each { |t| yield t }
-    else
-      enum_for(:each)
-    end
-  end
-
-  # MIME::Types#type_for against the default MIME::Types registry.
-  def type_for(filename)
-    __types__.type_for(filename)
-  end
-  alias of type_for
-
-  # MIME::Types#add against the default MIME::Types registry.
-  def add(*types)
-    __types__.add(*types)
-  end
-
-  private
-
-  def lazy_load?
-    return unless ENV.key?('RUBY_MIME_TYPES_LAZY_LOAD')
-
-    MIME::Types.logger.warn <<-WARNING.chomp
-Lazy loading ($RUBY_MIME_TYPES_LAZY_LOAD) is deprecated and will be removed.
-    WARNING
-
-    (lazy = ENV['RUBY_MIME_TYPES_LAZY_LOAD']) && (lazy != 'false')
-  end
-
-  def __types__
-    (defined?(@__types__) and @__types__) or load_default_mime_types
-  end
-
-  unless private_method_defined?(:load_mode)
-    def load_mode
-      { columnar: true }
-    end
-  end
-
-  def load_default_mime_types(mode = load_mode)
-    if (@__types__ = MIME::Types::Cache.load)
-      __instances__.add(@__types__)
-    else
-      @__types__ = MIME::Types::Loader.load(mode)
-      MIME::Types::Cache.save(@__types__)
-    end
-    @__types__
-  end
-
-  def __instances__
-    @__instances__ ||= Set.new
-  end
-
-  def reindex_extensions(type)
-    __instances__.each do |instance|
-      instance.send(:reindex_extensions!, type)
-    end
-    true
-  end
-end
-
-##
-class MIME::Types
-  load_default_mime_types(load_mode) unless lazy_load?
-end