mime-types 1.17.2 → 3.0

data/lib/mime/types/columnar.rb

@@ -0,0 +1,142 @@
+module MIME
+  class Types
+  end
+end
+
+require 'mime/type/columnar'
+
+# MIME::Types::Columnar is used to extend a MIME::Types container to load data
+# by columns instead of from JSON or YAML. Column loads of MIME types loaded
+# through the columnar store are synchronized with a Mutex.
+#
+# MIME::Types::Columnar is not intended to be used directly, but will be added
+# to an instance of MIME::Types when it is loaded with
+# MIME::Types::Loader#load_columnar.
+module MIME::Types::Columnar
+  LOAD_MUTEX = Mutex.new # :nodoc:
+
+  def self.extended(obj) # :nodoc:
+    super
+    obj.instance_variable_set(:@__mime_data__, [])
+    obj.instance_variable_set(:@__files__, Set.new)
+  end
+
+  # Load the first column data file (type and extensions).
+  def load_base_data(path) #:nodoc:
+    @__root__ = path
+
+    each_file_line('content_type', false) do |line|
+      line = line.split
+      content_type = line.shift
+      extensions = line
+      # content_type, *extensions = line.split
+
+      type = MIME::Type::Columnar.new(self, content_type, extensions)
+      @__mime_data__ << type
+      add(type)
+    end
+
+    self
+  end
+
+  private
+
+  def each_file_line(name, lookup = true)
+    LOAD_MUTEX.synchronize do
+      next if @__files__.include?(name)
+
+      i = -1
+      column = File.join(@__root__, "mime.#{name}.column")
+
+      IO.readlines(column, encoding: 'UTF-8'.freeze).each do |line|
+        line.chomp!
+
+        if lookup
+          type = @__mime_data__[i += 1] or next
+          yield type, line
+        else
+          yield line
+        end
+      end
+
+      @__files__ << name
+    end
+  end
+
+  def load_encoding
+    each_file_line('encoding') do |type, line|
+      pool ||= {}
+      line.freeze
+      type.instance_variable_set(:@encoding, (pool[line] ||= line))
+    end
+  end
+
+  def load_docs
+    each_file_line('docs') do |type, line|
+      type.instance_variable_set(:@docs, opt(line))
+    end
+  end
+
+  def load_preferred_extension
+    each_file_line('pext') do |type, line|
+      type.instance_variable_set(:@preferred_extension, opt(line))
+    end
+  end
+
+  def load_flags
+    each_file_line('flags') do |type, line|
+      line = line.split
+      type.instance_variable_set(:@obsolete, flag(line.shift))
+      type.instance_variable_set(:@registered, flag(line.shift))
+      type.instance_variable_set(:@signature, flag(line.shift))
+    end
+  end
+
+  def load_xrefs
+    each_file_line('xrefs') { |type, line|
+      type.instance_variable_set(:@xrefs, dict(line, array: true))
+    }
+  end
+
+  def load_friendly
+    each_file_line('friendly') { |type, line|
+      type.instance_variable_set(:@friendly, dict(line))
+    }
+  end
+
+  def load_use_instead
+    each_file_line('use_instead') do |type, line|
+      type.instance_variable_set(:@use_instead, opt(line))
+    end
+  end
+
+  def dict(line, array: false)
+    if line == '-'.freeze
+      {}
+    else
+      line.split('|'.freeze).each_with_object({}) { |l, h|
+        k, v = l.split('^'.freeze)
+        v = nil if v.empty?
+        h[k] = array ? Array(v) : v
+      }
+    end
+  end
+
+  def arr(line)
+    if line == '-'.freeze
+      []
+    else
+      line.split('|'.freeze).flatten.compact.uniq
+    end
+  end
+
+  def opt(line)
+    line unless line == '-'.freeze
+  end
+
+  def flag(line)
+    line == '1'.freeze ? true : false
+  end
+end
+
+require 'mime/types' unless defined?(MIME::Types::VERSION)

data/lib/mime/types/container.rb

@@ -0,0 +1,30 @@
+require 'set'
+
+# MIME::Types requires a container Hash with a default values for keys
+# resulting in an empty array (<tt>[]</tt>), but this cannot be dumped through
+# Marshal because of the presence of that default Proc. This class exists
+# solely to satisfy that need.
+class MIME::Types::Container < Hash # :nodoc:
+  def initialize
+    super
+    self.default_proc = ->(h, k) { h[k] = Set.new }
+  end
+
+  def marshal_dump
+    {}.merge(self)
+  end
+
+  def marshal_load(hash)
+    self.default_proc = ->(h, k) { h[k] = Set.new }
+    merge!(hash)
+  end
+
+  def encode_with(coder)
+    each { |k, v| coder[k] = v.to_a }
+  end
+
+  def init_with(coder)
+    self.default_proc = ->(h, k) { h[k] = Set.new }
+    coder.map.each { |k, v| self[k] = Set[*v] }
+  end
+end

data/lib/mime/types/deprecations.rb

@@ -0,0 +1,32 @@
+# -*- ruby encoding: utf-8 -*-
+
+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/lib/mime/types/full.rb

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

data/lib/mime/types/loader.rb

@@ -0,0 +1,148 @@
+# -*- 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)
+    # begin
+    #   require 'mime/lazy_types'
+    #   @container.extend(MIME::LazyTypes)
+    # end
+  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/lib/mime/types/logger.rb

@@ -0,0 +1,37 @@
+# -*- 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(_1, _2 = nil, _3 = nil)
+        super nil
+        @logdev = WarnLogDevice.new
+        @formatter = ->(_s, _d, _p, m) { m }
+      end
+    end
+
+    self.logger = WarnLogger.new(nil)
+  end
+end

data/lib/mime/types/registry.rb

@@ -0,0 +1,81 @@
+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_method :of, :type_for
+
+  # MIME::Types#add against the default MIME::Types registry.
+  def add(*types)
+    __types__.add(*types)
+  end
+
+  private
+
+  def lazy_load?
+    (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)
+    @__types__ = MIME::Types::Cache.load
+    unless @__types__
+      @__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