suzuko 0.1.7

data/vendor/bundle/ruby/2.0.0/gems/mime-types-2.6.2/lib/mime/types/cache.rb

@@ -0,0 +1,80 @@
+# -*- ruby encoding: utf-8 -*-
+
+class 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-version basis; a cache file for
+  # version 2.0 will not be reused with version 2.0.1.
+  class Cache
+    class << self
+      # 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::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
+        return 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(types.data_version, Marshal.dump(types))))
+        end
+      end
+    end
+  end
+
+  # 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 Container < Hash # :nodoc:
+    def initialize
+      super
+      self.default_proc = ->(h, k) { h[k] = [] }
+    end
+
+    def marshal_dump
+      {}.merge(self)
+    end
+
+    def marshal_load(hash)
+      self.default_proc = ->(h, k) { h[k] = [] }
+      self.merge!(hash)
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/mime-types-2.6.2/lib/mime/types/columnar.rb

@@ -0,0 +1,160 @@
+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(:@__attributes__, [])
+  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|
+      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 @__attributes__.include?(name)
+
+      File.open(File.join(@__root__, "mime.#{name}.column"), 'r:UTF-8') do |f|
+        i = -1
+
+        f.each_line do |line|
+          line.chomp!
+
+          if lookup
+            type = @__mime_data__[i += 1] or next
+            yield type, line
+          else
+            yield line
+          end
+        end
+      end
+
+      @__attributes__ << name
+    end
+  end
+
+  def load_encoding
+    pool = {}
+    each_file_line('encoding') do |type, line|
+      line.freeze
+      type.encoding = (pool[line] ||= line)
+    end
+  end
+
+  def load_docs
+    each_file_line('docs') do |type, line|
+      type.docs = arr(line)
+    end
+  end
+
+  def load_obsolete
+    each_file_line('obsolete') do |type, line|
+      type.obsolete = bool(line)
+    end
+  end
+
+  def load_references
+    each_file_line('references') do |type, line|
+      type.instance_variable_set(:@references, arr(line))
+    end
+  end
+
+  def load_registered
+    each_file_line('registered') do |type, line|
+      type.registered = bool(line)
+    end
+  end
+
+  def load_signature
+    each_file_line('signature') do |type, line|
+      type.signature = bool(line)
+    end
+  end
+
+  def load_system
+    each_file_line('system') do |type, line|
+      type.system = (line unless line == '-'.freeze)
+    end
+  end
+
+  def load_xrefs
+    each_file_line('xrefs') { |type, line| type.xrefs = dict(line) }
+  end
+
+  def load_friendly
+    each_file_line('friendly') { |type, line|
+      v = dict(line)
+      type.friendly = v.empty? ? nil : v
+    }
+  end
+
+  def load_use_instead
+    each_file_line('use_instead') do |type, line|
+      type.use_instead = (line unless line == '-'.freeze)
+    end
+  end
+
+  def dict(line)
+    if line == '-'.freeze
+      {}
+    else
+      line.split('|'.freeze).each_with_object({}) { |l, h|
+        k, v = l.split('^'.freeze)
+        v = [ nil ] if v.empty?
+        h[k] = v
+      }
+    end
+  end
+
+  def arr(line)
+    if line == '-'.freeze
+      []
+    else
+      line.split('|'.freeze).flatten.compact.uniq
+    end
+  end
+
+  def bool(line)
+    line == '1'.freeze ? true : false
+  end
+end
+
+unless MIME::Types.private_method_defined?(:load_mode)
+  class << MIME::Types
+    private
+
+    def load_mode
+      { columnar: true }
+    end
+  end
+
+  require 'mime/types'
+end

data/vendor/bundle/ruby/2.0.0/gems/mime-types-2.6.2/lib/mime/types/deprecations.rb

@@ -0,0 +1,53 @@
+# -*- 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
+
+  class << self
+    # MIME::InvalidContentType was moved to MIME::Type::InvalidContentType.
+    # Provide a single warning about this fact in the interim.
+    def const_missing(name) # :nodoc:
+      case name.to_s
+      when 'InvalidContentType'
+        warn_about_moved_constants(name)
+        MIME::Type.const_get(name.to_sym)
+      else
+        super
+      end
+    end
+
+    private
+
+    def warn_about_moved_constants(name)
+      MIME::Types.logger.warn <<-warning.chomp
+#{caller[1]}: MIME::#{name} is deprecated. Use MIME::Type::#{name} instead.
+      warning
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/mime-types-2.6.2/lib/mime/types/loader.rb

@@ -0,0 +1,280 @@
+# -*- ruby encoding: utf-8 -*-
+
+module MIME; end
+class MIME::Types; end
+
+require 'mime/types/loader_path'
+
+# 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::Loader::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 v1 registry format loaders.
+  def initialize(path = nil, container = nil)
+    path = path || ENV['RUBY_MIME_TYPES_DATA'] || MIME::Types::Loader::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 either the v1
+  # format or 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
+
+  # Loads a MIME::Types registry from files found in +path+ that are in the
+  # v1 data format. The file search for this will exclude both JSON
+  # (<tt>*.json</tt>) and YAML (<tt>*.yml</tt> or <tt>*.yaml</tt>) files.
+  #
+  # This method has been deprecated and will be removed from mime-types 3.0.
+  def load_v1
+    MIME::Types.deprecated(self.class, __method__)
+    Dir[v1_path].sort.each do |f|
+      next if f =~ /\.(?:ya?ml|json|column)$/
+      container.add(self.class.load_from_v1(f, true), true)
+    end
+    container
+  end
+
+  # Raised when a V1 format file is discovered. This exception will be removed
+  # for mime-types 3.0.
+  BadV1Format = Class.new(Exception)
+
+  class << self
+    # Loads the default MIME::Type registry.
+    def load(options = { columnar: false })
+      new.load(options)
+    end
+
+    # Build the type list from a file in the format:
+    #
+    #   [*][!][os:]mt/st[<ws>@ext][<ws>:enc][<ws>'url-list][<ws>=docs]
+    #
+    # == *
+    # An unofficial MIME type. This should be used if and only if the MIME type
+    # is not properly specified (that is, not under either x-type or
+    # vnd.name.type).
+    #
+    # == !
+    # An obsolete MIME type. May be used with an unofficial MIME type.
+    #
+    # == os:
+    # Platform-specific MIME type definition.
+    #
+    # == mt
+    # The media type.
+    #
+    # == st
+    # The media subtype.
+    #
+    # == <ws>@ext
+    # The list of comma-separated extensions.
+    #
+    # == <ws>:enc
+    # The encoding.
+    #
+    # == <ws>'url-list
+    # The list of comma-separated URLs.
+    #
+    # == <ws>=docs
+    # The documentation string.
+    #
+    # That is, everything except the media type and the subtype is optional. The
+    # more information that's available, though, the richer the values that can
+    # be provided.
+    #
+    # This method has been deprecated and will be removed in mime-types 3.0.
+    def load_from_v1(filename, __internal__ = false)
+      MIME::Types.deprecated(self.class, __method__) unless __internal__
+      data = read_file(filename).split($/)
+      mime = MIME::Types.new
+      data.each_with_index { |line, index|
+        item = line.chomp.strip
+        next if item.empty?
+
+        m = V1_FORMAT.match(item)
+
+        unless m
+          MIME::Types.logger.warn <<-EOS
+#{filename}:#{index + 1}: Parsing error in v1 MIME type definition.
+=> #{line}
+          EOS
+          fail BadV1Format, line
+        end
+
+        unregistered, obsolete, platform, mediatype, subtype, extensions,
+          encoding, urls, docs, _ = *m.captures
+
+        next if mediatype.nil?
+
+        extensions &&= extensions.split(/,/)
+        urls &&= urls.split(/,/)
+
+        if docs.nil?
+          use_instead = nil
+        else
+          use_instead = docs.scan(%r{use-instead:(\S+)}).flatten.first
+          docs = docs.gsub(%r{use-instead:\S+}, '').squeeze(' \t')
+        end
+
+        mime_type = MIME::Type.new("#{mediatype}/#{subtype}") do |t|
+          t.extensions  = extensions
+          t.encoding    = encoding
+          t.system      = platform
+          t.obsolete    = obsolete
+          t.registered  = false if unregistered
+          t.use_instead = use_instead
+          t.docs        = docs
+
+          # This is being removed. Cheat to silence it for now.
+          t.instance_variable_set :@references,
+                                  Array(urls).flatten.compact.uniq
+        end
+
+        mime.add_type(mime_type, true)
+      }
+      mime
+    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 either the v1
+    # format or 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:-') { |f| f.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
+
+  def v1_path
+    File.join(path, '*')
+  end
+
+  # The regular expression used to match a v1-format file-based MIME type
+  # definition.
+  #
+  # This constant has been deprecated and will be removed in mime-types 3.0.
+  V1_FORMAT = # :nodoc:
+    %r{\A\s*
+    ([*])?                                        # 0:    Unregistered?
+    (!)?                                          # 1:    Obsolete?
+    (?:(\w+):)?                                   # 2:    Platform marker
+    ([-\w.+]+)/([-\w.+]*)                         # 3, 4: Media Type
+    (?:\s+@(\S+))?                                # 5:    Extensions
+    (?:\s+:(base64|7bit|8bit|quoted\-printable))? # 6:    Encoding
+    (?:\s+'(\S+))?                                # 7:    URL list
+    (?:\s+=(.+))?                                 # 8:    Documentation
+    (?:\s*([#].*)?)?                              #       Comments
+    \s*
+    \z
+    }x
+
+  private_constant :V1_FORMAT if respond_to? :private_constant
+end

data/vendor/bundle/ruby/2.0.0/gems/mime-types-2.6.2/lib/mime/types/loader_path.rb

@@ -0,0 +1,15 @@
+# -*- ruby encoding: utf-8 -*-
+
+class MIME::Types::Loader
+  # The path that will be used for loading the MIME::Types data. The default
+  # location is __FILE__/../../../../data, which is where the data lives
+  # in the gem installation of the mime-types library.
+  #
+  # The MIME::Types::Loader will load all JSON or columnar files contained in
+  # this path.
+  #
+  # System repackagers note: this is the constant that you would change if
+  # you repackage mime-types for your system. It is recommended that the
+  # path be something like /usr/share/ruby/mime-types/.
+  PATH = File.expand_path('../../../../data', __FILE__)
+end

data/vendor/bundle/ruby/2.0.0/gems/mime-types-2.6.2/lib/mime/types/logger.rb

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