kinetic_sdk 0.1.1

data/gems/mime-types-3.1/lib/mime/types/cache.rb

@@ -0,0 +1,56 @@
+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
+    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(MIME::Types::Data::VERSION, Marshal.dump(types)))
+      )
+    end
+  end
+end

data/gems/mime-types-3.1/lib/mime/types/columnar.rb

@@ -0,0 +1 @@
+require 'mime/types'

data/gems/mime-types-3.1/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/gems/mime-types-3.1/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/gems/mime-types-3.1/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
+    end
+  end
+end
+
+require 'mime/types'

data/gems/mime-types-3.1/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/gems/mime-types-3.1/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/gems/mime-types-3.1/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

data/gems/mime-types-3.1/lib/mime/types.rb

@@ -0,0 +1,228 @@
+##
+module MIME
+  ##
+  class Types
+  end
+end
+
+require 'mime/type'
+
+# MIME::Types is a registry of MIME types. It is both a class (created with
+# MIME::Types.new) and a default registry (loaded automatically or through
+# interactions with MIME::Types.[] and MIME::Types.type_for).
+#
+# == The Default mime-types Registry
+#
+# The default mime-types registry is loaded automatically when the library
+# is required (<tt>require 'mime/types'</tt>), but it may be lazily loaded
+# (loaded on first use) with the use of the environment variable
+# +RUBY_MIME_TYPES_LAZY_LOAD+ having any value other than +false+. The
+# initial startup is about 14× faster (~10 ms vs ~140 ms), but the
+# registry will be loaded at some point in the future.
+#
+# The default mime-types registry can also be loaded from a Marshal cache
+# file specific to the version of MIME::Types being loaded. This will be
+# handled automatically with the use of a file referred to in the
+# environment variable +RUBY_MIME_TYPES_CACHE+. MIME::Types will attempt to
+# load the registry from this cache file (MIME::Type::Cache.load); if it
+# cannot be loaded (because the file does not exist, there is an error, or
+# the data is for a different version of mime-types), the default registry
+# will be loaded from the normal JSON version and then the cache file will
+# be *written* to the location indicated by +RUBY_MIME_TYPES_CACHE+. Cache
+# file loads just over 4½× faster (~30 ms vs ~140 ms).
+# loads.
+#
+# Notes:
+# * The loading of the default registry is *not* atomic; when using a
+#   multi-threaded environment, it is recommended that lazy loading is not
+#   used and mime-types is loaded as early as possible.
+# * Cache files should be specified per application in a multiprocess
+#   environment and should be initialized during deployment or before
+#   forking to minimize the chance that the multiple processes will be
+#   trying to write to the same cache file at the same time, or that two
+#   applications that are on different versions of mime-types would be
+#   thrashing the cache.
+# * Unless cache files are preinitialized, the application using the
+#   mime-types cache file must have read/write permission to the cache file.
+#
+# == Usage
+#  require 'mime/types'
+#
+#  plaintext = MIME::Types['text/plain']
+#  print plaintext.media_type           # => 'text'
+#  print plaintext.sub_type             # => 'plain'
+#
+#  puts plaintext.extensions.join(" ")  # => 'asc txt c cc h hh cpp'
+#
+#  puts plaintext.encoding              # => 8bit
+#  puts plaintext.binary?               # => false
+#  puts plaintext.ascii?                # => true
+#  puts plaintext.obsolete?             # => false
+#  puts plaintext.registered?           # => true
+#  puts plaintext == 'text/plain'       # => true
+#  puts MIME::Type.simplified('x-appl/x-zip') # => 'appl/zip'
+#
+class MIME::Types
+  # The release version of Ruby MIME::Types
+  VERSION = MIME::Type::VERSION
+
+  include Enumerable
+
+  # Creates a new MIME::Types registry.
+  def initialize
+    @type_variants    = Container.new
+    @extension_index  = Container.new
+  end
+
+  # Returns the number of known type variants.
+  def count
+    @type_variants.values.inject(0) { |a, e| a + e.size }
+  end
+
+  def inspect # :nodoc:
+    "#<#{self.class}: #{count} variants, #{@extension_index.count} extensions>"
+  end
+
+  # Iterates through the type variants.
+  def each
+    if block_given?
+      @type_variants.each_value { |tv| tv.each { |t| yield t } }
+    else
+      enum_for(:each)
+    end
+  end
+
+  @__types__ = nil
+
+  # Returns a list of MIME::Type objects, which may be empty. The optional
+  # flag parameters are <tt>:complete</tt> (finds only complete MIME::Type
+  # objects) and <tt>:registered</tt> (finds only MIME::Types that are
+  # registered). It is possible for multiple matches to be returned for
+  # either type (in the example below, 'text/plain' returns two values --
+  # one for the general case, and one for VMS systems).
+  #
+  #   puts "\nMIME::Types['text/plain']"
+  #   MIME::Types['text/plain'].each { |t| puts t.to_a.join(", ") }
+  #
+  #   puts "\nMIME::Types[/^image/, complete: true]"
+  #   MIME::Types[/^image/, :complete => true].each do |t|
+  #     puts t.to_a.join(", ")
+  #   end
+  #
+  # If multiple type definitions are returned, returns them sorted as
+  # follows:
+  #   1. Complete definitions sort before incomplete ones;
+  #   2. IANA-registered definitions sort before LTSW-recorded
+  #      definitions.
+  #   3. Current definitions sort before obsolete ones;
+  #   4. Obsolete definitions with use-instead clauses sort before those
+  #      without;
+  #   5. Obsolete definitions use-instead clauses are compared.
+  #   6. Sort on name.
+  def [](type_id, complete: false, registered: false)
+    matches = case type_id
+              when MIME::Type
+                @type_variants[type_id.simplified]
+              when Regexp
+                match(type_id)
+              else
+                @type_variants[MIME::Type.simplified(type_id)]
+              end
+
+    prune_matches(matches, complete, registered).sort { |a, b|
+      a.priority_compare(b)
+    }
+  end
+
+  # Return the list of MIME::Types which belongs to the file based on its
+  # filename extension. If there is no extension, the filename will be used
+  # as the matching criteria on its own.
+  #
+  # This will always return a merged, flatten, priority sorted, unique array.
+  #
+  #   puts MIME::Types.type_for('citydesk.xml')
+  #     => [application/xml, text/xml]
+  #   puts MIME::Types.type_for('citydesk.gif')
+  #     => [image/gif]
+  #   puts MIME::Types.type_for(%w(citydesk.xml citydesk.gif))
+  #     => [application/xml, image/gif, text/xml]
+  def type_for(filename)
+    Array(filename).flat_map { |fn|
+      @extension_index[fn.chomp.downcase[/\.?([^.]*?)$/, 1]]
+    }.compact.inject(:+).sort { |a, b|
+      a.priority_compare(b)
+    }
+  end
+  alias_method :of, :type_for
+
+  # Add one or more MIME::Type objects to the set of known types. If the
+  # type is already known, a warning will be displayed.
+  #
+  # The last parameter may be the value <tt>:silent</tt> or +true+ which
+  # will suppress duplicate MIME type warnings.
+  def add(*types)
+    quiet = ((types.last == :silent) or (types.last == true))
+
+    types.each do |mime_type|
+      case mime_type
+      when true, false, nil, Symbol
+        nil
+      when MIME::Types
+        variants = mime_type.instance_variable_get(:@type_variants)
+        add(*variants.values.inject(:+).to_a, quiet)
+      when Array
+        add(*mime_type, quiet)
+      else
+        add_type(mime_type, quiet)
+      end
+    end
+  end
+
+  # Add a single MIME::Type object to the set of known types. If the +type+ is
+  # already known, a warning will be displayed. The +quiet+ parameter may be a
+  # truthy value to suppress that warning.
+  def add_type(type, quiet = false)
+    if !quiet and @type_variants[type.simplified].include?(type)
+      MIME::Types.logger.warn <<-warning
+Type #{type} is already registered as a variant of #{type.simplified}.
+      warning
+    end
+
+    add_type_variant!(type)
+    index_extensions!(type)
+  end
+
+  private
+
+  def add_type_variant!(mime_type)
+    @type_variants[mime_type.simplified] << mime_type
+  end
+
+  def reindex_extensions!(mime_type)
+    return unless @type_variants[mime_type.simplified].include?(mime_type)
+    index_extensions!(mime_type)
+  end
+
+  def index_extensions!(mime_type)
+    mime_type.extensions.each { |ext| @extension_index[ext] << mime_type }
+  end
+
+  def prune_matches(matches, complete, registered)
+    matches.delete_if { |e| !e.complete? } if complete
+    matches.delete_if { |e| !e.registered? } if registered
+    matches
+  end
+
+  def match(pattern)
+    @type_variants.select { |k, _|
+      k =~ pattern
+    }.values.inject(:+)
+  end
+end
+
+require 'mime/types/cache'
+require 'mime/types/container'
+require 'mime/types/loader'
+require 'mime/types/logger'
+require 'mime/types/_columnar'
+require 'mime/types/registry'

data/gems/mime-types-3.1/lib/mime-types.rb

@@ -0,0 +1 @@
+require 'mime/types'

data/gems/mime-types-3.1/test/bad-fixtures/malformed

@@ -0,0 +1,9 @@
+!application.smil @smi,smil :8bit 'IANA,RFC4536 =use-instead:application/smil+xml
+!audio/vnd.qcelp @qcp 'IANA,RFC3625 =use-instead:audio/QCELP
+*!image/bmp @bmp =use-instead:image/x-bmp
+*application/acad 'LTSW
+*audio/webm @webm '{WebM=http://www.webmproject.org/code/specs/container/}
+*image/pjpeg :base64 =Fixes a bug with IE6 and progressive JPEGs
+application/1d-interleaved-parityfec 'IANA,RFC6015
+audio/1d-interleaved-parityfec 'IANA,RFC6015
+mac:application/x-apple-diskimage @dmg

data/gems/mime-types-3.1/test/fixture/json.json

@@ -0,0 +1 @@
+[{"content-type":"application/smil","encoding":"8bit","extensions":["smi","smil"],"obsolete":true,"use-instead":"application/smil+xml","registered":true},{"content-type":"audio/vnd.qcelp","encoding":"base64","extensions":["qcp"],"obsolete":true,"use-instead":"audio/QCELP","registered":true},{"content-type":"image/bmp","encoding":"base64","extensions":["bmp"],"obsolete":true,"use-instead":"image/x-bmp","registered":false},{"content-type":"application/acad","encoding":"base64","registered":false},{"content-type":"audio/webm","encoding":"base64","extensions":["webm"],"registered":false},{"content-type":"image/pjpeg","docs":"Fixes a bug with IE6 and progressive JPEGs","encoding":"base64","registered":false},{"content-type":"application/1d-interleaved-parityfec","encoding":"base64","registered":true},{"content-type":"audio/1d-interleaved-parityfec","encoding":"base64","registered":true},{"content-type":"application/x-apple-diskimage","encoding":"base64","extensions":["dmg"],"registered":false}]

data/gems/mime-types-3.1/test/fixture/old-data

@@ -0,0 +1,9 @@
+!application/smil @smi,smil :8bit 'IANA,RFC4536 =use-instead:application/smil+xml
+!audio/vnd.qcelp @qcp 'IANA,RFC3625 =use-instead:audio/QCELP
+*!image/bmp @bmp =use-instead:image/x-bmp
+*application/acad 'LTSW
+*audio/webm @webm '{WebM=http://www.webmproject.org/code/specs/container/}
+*image/pjpeg :base64 =Fixes a bug with IE6 and progressive JPEGs
+application/1d-interleaved-parityfec 'IANA,RFC6015
+audio/1d-interleaved-parityfec 'IANA,RFC6015
+mac:application/x-apple-diskimage @dmg