mimemagic-dorian 0.5.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 060e2ae0726ea36fcb9f30276d9a4337f2a59b76a8dc0c0f9bc2d747966a850a
+  data.tar.gz: afc690980aaed5df5e70a6794a34189d380ac71392877c61aa7846c49ee71ee0
+SHA512:
+  metadata.gz: d141cc2c0bb627b671771e64f3ab309784ac0d42b2bbfff7d73e1c480632cd994520ae320c5ae08386f0bc812cfbf5875902c87fe9bfcc019f207653b424fcc6
+  data.tar.gz: bfbdfa6941490d426dad7dec017de72f92b6312be59b89730c87162027309ada8174b72b9ec70b88b7c51db3171befc77167e44d9990700be12c637bea7c0a35

data/.gitignore

@@ -0,0 +1,20 @@
+*.swp
+*.gem
+Gemfile.lock
+.bundle
+
+# doc
+.yardoc
+doc/
+
+# mac junk
+._*
+
+# annoying emacs backups
+.\#*
+\#*\#
+
+vendor
+
+# don't include generated files
+lib/mimemagic/path.rb

data/.travis.yml

@@ -0,0 +1,21 @@
+language: ruby
+jobs:
+  include:
+    - rvm: 1.9.3
+    - rvm: 2.0.0
+    - rvm: 2.1
+    - rvm: 2.2
+    - rvm: 2.3
+    - rvm: 2.4
+      env: RUBYOPT="--enable-frozen-string-literal"
+    - rvm: 2.5
+      env: RUBYOPT="--enable-frozen-string-literal"
+    - rvm: ruby-head
+      env: RUBYOPT="--enable-frozen-string-literal"
+before_install:
+  # 1. The pre-installed Bundler version on Travis is very old; causes 1.9.3 build issues
+  # 2. Bundler 2.0 is not supported by the whole matrix
+  - gem install bundler -v'< 2'
+
+script:
+  -  bundle exec rake

data/.yardopts

@@ -0,0 +1,6 @@
+--markup-provider=redcarpet
+--markup=markdown
+--no-private
+- README.md
+- LICENSE
+- CHANGELOG.md

data/CHANGELOG.md

@@ -0,0 +1,216 @@
+# Changelog
+
+## 0.5.4
+
+This gem implements [PR
+#175](https://github.com/mimemagicrb/mimemagic/issues/175) upstream,
+from 2023-08-09. It will be dissolved if/when the patch is ever
+merged.
+
+### Added
+
+* `.binary?` predicate will tell if the input (`IO`, `String`, file
+  extension, path, type, whatever) is binary
+* `#binary?` instance method likewise
+* `.default_type` will return either text/plain or
+  application/octet-stream depending on whether the input is perceived
+  to be binary
+* `#aliases` (and `.aliases`) will return the list of aliases for a
+  given type
+* `#alias?` predicate will determine if a given type is an alias of a
+  canonical type
+* `#canonical` (and `.canonical`) will return a canonical type for a
+  (potentially aliased) type
+* `#parents` will return the immediate parent types of the given type
+* `#lineage` will return the entire (flattened) inheritance hierarchy
+  of the given type, including itself
+* fancy new `MimeMagic[…]` constructor will instantiate from a type or
+  file extension
+* constructor now handles type parameters; `params` accessor
+* explicit `#inspect` method shows abridged diagnostic representation
+* `default:` keyword parameter on `.by_extension`, `.by_path`,
+  `.by_magic`, `.all_by_magic` will guarantee a return value when
+  truthy (either the result of `.default_type` for the given input or
+  a user-supplied value)
+
+### Fixed
+
+* internal database now contains aliases and the canonical type identifier
+* normalized all the documentation to YARD
+
+## 0.4.3
+
+???
+
+## 0.4.2
+
+???
+
+## 0.4.1
+
+### Breaking Changes
+
+Remove `mimemagic/overlay` as it contains outdated, little used, data.
+
+## 0.3.7 (2021-03-25)
+
+You will now need to ensure you have a copy of the fd.o shared MIME
+types information available before installing this gem. More details
+can be found in the readme.
+
+### Added
+
+None
+
+### Fixed
+
+None
+## 0.4.3
+
+* Improve the development/test experience (@coldnebo, @kachick)
+
+* Ensure the gem works in environments with gem caching (@haines)
+
+* Add support for MacPorts installed dependencies (@brlanier)
+
+* Allow using a dummy XML file in cases where the gem is just a transient
+  dependency. (@Scharrels)
+
+
+## 0.4.2
+
+* Resolve issues parsing the version of freedesktop.org.xml shipped with
+  Ubuntu Trusty.
+
+* Make Rake a runtime dependency.
+
+* Fix the test suite.
+
+* Relax the dependency on Nokogiri to something less specific in order
+to avoid conflicting with other dependencies in people's applications.
+
+## 0.4.1
+
+
+## 0.4.0
+
+Yanked release.
+
+## 0.3.10
+
+* Improve the development/test experience (@coldnebo, @kachick)
+
+* Ensure the gem works in environments with gem caching (@haines)
+
+* Add support for MacPorts installed dependencies (@brlanier)
+
+* Allow using a dummy XML file in cases where the gem is just a transient
+  dependency. (@Scharrels)
+
+## 0.3.9 (2021-03-25)
+
+* Resolve issues parsing the version of freedesktop.org.xml shipped with
+  Ubuntu Trusty.
+
+* Reintroduce overlays, since it seems at least some people were using
+  them.
+  
+* Make Rake a runtime dependency.
+
+* Fix the test suite.
+## 0.3.8 (2021-03-25)
+
+Relax the dependency on Nokogiri to something less specific in order
+to avoid conflicting with other dependencies in people's applications.
+
+## 0.3.7 (2021-03-25)
+
+Add a dependency on having a preinstalled version of the fd.o shared
+MIME types info to resolve licensing concerns, and allow this gem to
+remain MIT licensed.
+
+See the readme for details on ensuring you have a copy of the database
+available at install time.
+## 0.3.6 (2021-03-23)
+
+Yanked release, relicensing to GPL due to licensing concerns.
+## 0.3.5 (2020-05-04)
+
+Mimetype extensions are now ordered by freedesktop.org's priority
+
+## 0.3.4 (2020-01-28)
+
+Added frozen string literal comments
+
+## 0.3.3 (2018-12-20)
+
+Upgrade to shared-mime-info-1.10
+
+## 0.3.2 (2016-08-02)
+
+### Breaking Changes
+
+None
+
+### Added
+
+- [#37](https://github.com/minad/mimemagic/pull/37)
+  A convenient way to get all possible mime types by magic
+
+### Fixed
+
+- [#40](https://github.com/minad/mimemagic/pull/40),
+  [#41](https://github.com/minad/mimemagic/pull/41)
+  Performance improvements
+- [#38](https://github.com/minad/mimemagic/pull/38)
+  Updated to shared-mime-info 1.6
+
+## 0.3.1 (2016-01-04)
+
+No release notes yet. Contributions welcome.
+
+## 0.3.0 (2015-03-25)
+
+No release notes yet. Contributions welcome.
+
+## 0.2.1 (2013-07-29)
+
+No release notes yet. Contributions welcome.
+
+## 0.2.0 (2012-10-19)
+
+No release notes yet. Contributions welcome.
+
+## 0.1.9 (2012-09-20)
+
+No release notes yet. Contributions welcome.
+
+## 0.1.8 (2009-05-08)
+
+No release notes yet. Contributions welcome.
+
+## 0.1.7 (2009-05-08)
+
+No release notes yet. Contributions welcome.
+
+## 0.1.5 (2009-05-08)
+
+No release notes yet. Contributions welcome.
+
+## 0.1.4 (2009-05-08)
+
+No release notes yet. Contributions welcome.
+
+## 0.1.3 (2009-05-08)
+
+No release notes yet. Contributions welcome.
+
+## 0.1.2 (2009-05-08)
+
+No release notes yet. Contributions welcome.
+
+## 0.1.1 (2009-05-08)
+
+No release notes yet. Contributions welcome.
+
+

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org/'
+gemspec
+
+gem 'yard'
+gem 'redcarpet'
+gem 'github-markup'

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011 Daniel Mendler
+
+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.

data/README.md

@@ -0,0 +1,71 @@
+> This version of `mimemagic` implements [PR #175](https://github.com/mimemagicrb/mimemagic/pull/175) upstream. It will be dissolved if/when that patch is merged.
+
+MimeMagic is a library to detect the mime type of a file by extension or by content. It uses the mime database
+provided by freedesktop.org (see http://freedesktop.org/wiki/Software/shared-mime-info/).
+
+[![Gem Version](https://img.shields.io/gem/v/mimemagic-dorian.svg)](http://rubygems.org/gems/mimemagic-dorian)
+
+Dependencies
+============
+
+You will require a copy of the Freedesktop.org shared-mime-info database to be available. If you're on Linux,
+it's probably available via your package manager, and will probably be in the location it's being looked for
+when the gem is installed.
+
+macOS users can install the database via Homebrew with `brew install shared-mime-info`.
+
+Should you be unable to use a package manager you can obtain a copy of the needed file by extracting it from
+the Debian package. This process will also work on a Windows machine.
+
+1. Download the package from https://packages.debian.org/sid/amd64/shared-mime-info/download
+2. Ensure the command line version of 7-Zip is installed
+3. `7z x -so shared-mime-info_2.0-1_amd64.deb data.tar | 7z e -sidata.tar "./usr/share/mime/packages/freedesktop.org.xml"`
+
+
+Place the file `freedesktop.org.xml` in an appropriate location, and then set the environment variable
+`FREEDESKTOP_MIME_TYPES_PATH` to that path. Once that has been done the gem should install successfully. Please
+note that the gem will depend upon the file remaining in that location at run time.
+
+Usage
+=====
+
+```ruby
+require 'mimemagic'
+MimeMagic.by_extension('html').text?
+MimeMagic.by_extension('.html').child_of? 'text/plain'
+MimeMagic.by_path('filename.txt')
+MimeMagic.by_magic(File.open('test.html'))
+# etc...
+```
+
+You can add your own magic with `MimeMagic.add`.
+
+API
+===
+
+http://www.rubydoc.info/gems/mimemagic-dorian/
+
+Tests
+=====
+
+```console
+$ bundle install
+
+$ bundle exec rake test
+```
+
+Authors
+=======
+
+[The author of this patch](https://github.com/doriantaylor) is [Dorian Taylor](https://doriantaylor.com/).
+
+Original authors:
+
+* Daniel Mendler
+* Jon Wood
+* [MimeMagic Contributors](https://github.com/mimemagicrb/mimemagic/graphs/contributors)
+
+LICENSE
+=======
+
+{file:LICENSE MIT}

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake/testtask'
+require 'rake/clean'
+
+namespace :ext do
+  load 'ext/mimemagic/Rakefile'
+end
+CLOBBER.include("lib/mimemagic/path.rb")
+
+task :default => %w(test)
+
+desc 'Run tests with minitest'
+Rake::TestTask.new("test" => "ext:default") do |t|
+  t.libs << 'test'
+  t.pattern = 'test/*_test.rb'
+end
+
+desc 'Generate mime tables'
+task :tables => 'lib/mimemagic/tables.rb'
+file 'lib/mimemagic/tables.rb' => FileList['script/freedesktop.org.xml'] do |f|
+  sh "script/generate-mime.rb #{f.prerequisites.join(' ')} > #{f.name}"
+end
+

data/ext/mimemagic/Rakefile

@@ -0,0 +1,38 @@
+require "rubygems"
+require "rake/clean"
+
+def locate_mime_database
+  possible_paths = [
+    (File.expand_path(ENV["FREEDESKTOP_MIME_TYPES_PATH"]) if ENV["FREEDESKTOP_MIME_TYPES_PATH"]),
+    "/usr/local/share/mime/packages/freedesktop.org.xml",
+    "/opt/homebrew/share/mime/packages/freedesktop.org.xml",
+    "/opt/local/share/mime/packages/freedesktop.org.xml",
+    "/usr/share/mime/packages/freedesktop.org.xml"
+  ].compact
+  path = possible_paths.find { |candidate| File.exist?(candidate) }
+
+  return path unless path.nil?
+  raise(<<-ERROR.gsub(/^ {3}/, ""))
+   Could not find MIME type database in the following locations: #{possible_paths}
+
+   Ensure you have either installed the shared-mime-info package for your distribution, or
+   obtain a version of freedesktop.org.xml and set FREEDESKTOP_MIME_TYPES_PATH to the location
+   of that file.
+  ERROR
+end
+
+desc "Build a file pointing at the database"
+task :default do
+  mime_database_path = locate_mime_database
+  target_dir = "#{ENV.fetch("RUBYARCHDIR", "../lib")}/mimemagic"
+  mkdir_p target_dir
+
+  open("#{target_dir}/path.rb", "w") do |f|
+    f.print(<<~SOURCE
+      class MimeMagic
+        DATABASE_PATH="#{mime_database_path}"
+      end
+      SOURCE
+    )
+  end
+end

data/lib/mimemagic/tables.rb

@@ -0,0 +1,168 @@
+# -*- coding: binary -*-
+# frozen_string_literal: true
+# Generated from script/freedesktop.org.xml
+require 'nokogiri'
+require 'mimemagic/path'
+
+class MimeMagic
+  EXTENSIONS = {}
+  TYPES = {}
+  MAGIC = []
+
+  def self.str2int(s)
+    return s.to_i(16) if s[0..1].downcase == '0x'
+    return s.to_i(8) if s[0..0].downcase == '0'
+    s.to_i(10)
+  end
+
+  def self.get_matches(parent)
+    parent.elements.map {|match|
+      if match['mask']
+        nil
+      else
+        type = match['type']
+        value = match['value']
+        offset = match['offset'].split(':').map {|x| x.to_i }
+        offset = offset.size == 2 ? offset[0]..offset[1] : offset[0]
+        case type
+        when 'string'
+          # This *one* pattern match, in the entirety of fd.o's mime types blows up the parser
+          # because of the escape character \c, so right here we have a hideous hack to
+          # accommodate that.
+          if value == '\chapter'
+            '\chapter'
+          else
+            value.gsub!(/\\(x[\dA-Fa-f]{1,2}|0\d{1,3}|\d{1,3}|.)/) {
+              eval("\"\\#{$1}\"")
+            }
+          end
+        when 'big16'
+          value = str2int(value)
+          value = ((value >> 8).chr + (value & 0xFF).chr)
+        when 'big32'
+          value = str2int(value)
+          value = (((value >> 24) & 0xFF).chr + ((value >> 16) & 0xFF).chr + ((value >> 8) & 0xFF).chr + (value & 0xFF).chr)
+        when 'little16'
+          value = str2int(value)
+          value = ((value & 0xFF).chr + (value >> 8).chr)
+        when 'little32'
+          value = str2int(value)
+          value = ((value & 0xFF).chr + ((value >> 8) & 0xFF).chr + ((value >> 16) & 0xFF).chr + ((value >> 24) & 0xFF).chr)
+        when 'host16' # use little endian
+          value = str2int(value)
+          value = ((value & 0xFF).chr + (value >> 8).chr)
+        when 'host32' # use little endian
+          value = str2int(value)
+          value = ((value & 0xFF).chr + ((value >> 8) & 0xFF).chr + ((value >> 16) & 0xFF).chr + ((value >> 24) & 0xFF).chr)
+        when 'byte'
+          value = str2int(value)
+          value = value.chr
+        end
+        children = get_matches(match)
+        children.empty? ? [offset, value] : [offset, value, children]
+      end
+    }.compact
+  end
+
+  def self.open_mime_database
+    path = MimeMagic::DATABASE_PATH
+    File.open(path)
+  end
+
+  def self.parse_database
+    file = open_mime_database
+
+    doc = Nokogiri::XML(file)
+    extensions = {}
+    types = {}
+    magics = []
+    (doc/'mime-info/mime-type').each do |mime|
+      comments = Hash[*(mime/'comment').map {|comment| [comment['xml:lang'], comment.inner_text] }.flatten]
+      type = mime['type']
+      subclass = (mime/'sub-class-of').map{|x| x['type']}
+      exts = (mime/'glob').map do |x|
+        x['pattern'] =~ /^\*\.([^\[\]]+)$/ ? $1.downcase : nil
+      end.compact
+
+      (mime/'magic').each do |magic|
+        priority = magic['priority'].to_i
+        matches = get_matches(magic)
+        magics << [priority, type, matches]
+      end
+
+      aliases = (mime/'alias/@type').map { |a| a.value.downcase.strip.freeze }
+
+      # XXX uhh do we only use the type if it has a file extension??
+      unless exts.empty?
+        exts.each { |x| extensions[x] ||= type }
+        types[type] = [exts, subclass, comments[nil], type, aliases]
+        # don't add the aliases yet; we do that below
+      end
+    end
+
+    magics = magics.sort {|a,b| [-a[0],a[1]] <=> [-b[0],b[1]] }
+
+    common_types = [
+      "image/jpeg",                                                              # .jpg
+      "image/png",                                                               # .png
+      "image/gif",                                                               # .gif
+      "image/tiff",                                                              # .tiff
+      "image/bmp",                                                               # .bmp
+      "image/vnd.adobe.photoshop",                                               # .psd
+      "image/webp",                                                              # .webp
+      "image/svg+xml",                                                           # .svg
+
+      "video/x-msvideo",                                                         # .avi
+      "video/x-ms-wmv",                                                          # .wmv
+      "video/mp4",                                                               # .mp4, .m4v
+      "video/quicktime",                                                         # .mov
+      "video/mpeg",                                                              # .mpeg
+      "video/ogg",                                                               # .ogv
+      "video/webm",                                                              # .webm
+      "video/x-matroska",                                                        # .mkv
+      "video/x-flv",                                                             # .flv
+
+      "audio/mpeg",                                                              # .mp3
+      "audio/x-wav",                                                             # .wav
+      "audio/aac",                                                               # .aac
+      "audio/flac",                                                              # .flac
+      "audio/mp4",                                                               # .m4a
+      "audio/ogg",                                                               # .ogg
+
+      "application/pdf",                                                         # .pdf
+      "application/msword",                                                      # .doc
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.document", # .docx
+      "application/vnd.ms-powerpoint",                                           # .pps
+      "application/vnd.openxmlformats-officedocument.presentationml.slideshow",  # .ppsx
+      "application/vnd.ms-excel",                                                # .pps
+      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",       # .ppsx
+    ]
+
+    common_magics = common_types.map do |common_type|
+      magics.find { |_, type, _| type == common_type }
+    end
+
+    magics = (common_magics.compact + magics).uniq
+
+    extensions.keys.sort.each do |key|
+      EXTENSIONS[key] = extensions[key]
+    end
+
+    types.keys.sort.each do |key|
+      exts, parents, comment, canon, aliases = *types[key]
+
+      parents.sort!
+      aliases.sort!
+
+      # we are copying it i guess
+      t = TYPES[key] = [exts, parents, comment, canon, aliases].freeze
+
+      # now do the aliases oops they'll be out of order oh well
+      aliases.each { |a| TYPES[a] = t }
+    end
+
+    magics.each do |priority, type, matches|
+      MAGIC << [type, matches]
+    end
+  end
+end

data/lib/mimemagic/version.rb

@@ -0,0 +1,5 @@
+class MimeMagic
+  # MimeMagic version string
+  # @api public
+  VERSION = '0.5.4'
+end

data/lib/mimemagic.rb

@@ -0,0 +1,446 @@
+# frozen_string_literal: true
+
+require 'mimemagic/tables'
+require 'mimemagic/version'
+
+require 'stringio'
+
+MimeMagic.parse_database
+
+# Mime type detection
+class MimeMagic
+  attr_reader :type, :mediatype, :subtype, :params
+
+  # Initialize a new MIME type by its string representation.
+  #
+  # @param type [#to_s] the type to parse.
+  #
+  def initialize(type)
+    @type, *params = type.to_s.strip.split(/(?:\s*;\s*)+/) # chop off params
+    @type.downcase! # normalize the case
+    # split parameter-value pairs if present
+    @params = params.map { |x| x.split(/\s*=\s*/, 2) } unless params.empty?
+    @mediatype, @subtype = @type.split ?/, 2 # split major and minor
+  end
+
+  # Syntactic sugar alias for constructor. No-op if `type` is already
+  # a {MimeMagic} object. The argument is treated as a file extension
+  # if it doesn't contain a `/`, and may return `nil` if it doesn't
+  # resolve.
+  #
+  # @param type [#to_s] a string-like object representing a MIME type
+  #  or file extension.
+  #
+  # @return [MimeMagic, nil] the instantiated object.
+  #
+  def self.[] type
+    # try noop first
+    return type if type.is_a? self
+
+    # now we handle the string
+    type = type.to_s.strip
+    # empty string should be default
+    return default_type if type.empty?
+
+    # this may return null
+    return by_extension type unless type.include? ?/
+
+    # otherwise pass to constructor
+    new type
+  end
+
+  # Add a custom MIME type to the internal dictionary.
+  #
+  # @param type [#to_s] the type
+  # @param extensions [Array<#to_s>] file extensions
+  # @param parents [Array<#to_s>] parent types
+  # @param magic [Array] MIME "magic" specification
+  # @param aliases [Array<#to_s>] alternative names for the type
+  # @param comment [#to_s] a comment
+  #
+  def self.add type,
+      extensions: [], parents: [], magic: [], comment: nil, aliases: []
+    type = type.to_s.strip.downcase
+    extensions = [extensions].flatten.compact
+    aliases = [[aliases] || []].flatten.compact
+    t = TYPES[type] = [extensions, [parents].flatten.compact,
+                   comment, type, aliases]
+    aliases.each { |a| TYPES[a] = t }
+    extensions.each {|ext| EXTENSIONS[ext] ||= type }
+
+    MAGIC.unshift [type, magic] if magic
+
+    true # output is ignored
+  end
+
+  # Removes a MIME type from the dictionary. You might want to do this if
+  # you're seeing impossible conflicts (for instance, application/x-gmc-link).
+  #
+  # @note All associated extensions and magic are removed too.
+  #
+  # @param type [#to_s] the type to remove.
+  #
+  def self.remove(type)
+    EXTENSIONS.delete_if {|ext, t| t == type }
+    MAGIC.delete_if {|t, m| t == type }
+    TYPES.delete(type)
+
+    true # output is also ignored
+  end
+
+  # Returns true if type is a text format.
+  def text?; mediatype == 'text' || descendant_of?('text/plain'); end
+
+  # Determine if the type is an image.
+  def image?; mediatype == 'image'; end
+
+  # Determine if the type is audio.
+  def audio?; mediatype == 'audio'; end
+
+  # Determine if the type is video.
+  def video?; mediatype == 'video'; end
+
+  # Get string list of file extensions.
+  #
+  # @return [Array<String>] associated file extensions.
+  #
+  def extensions
+    TYPES.fetch(type, [[]]).first.map { |e| e.to_s.dup }
+  end
+
+  # Get MIME comment.
+  #
+  # @return [nil, String] the comment
+  #
+  def comment
+    TYPES.fetch(type, [nil, nil, nil])[2].to_s.dup
+  end
+
+  # Return the canonical type. Returns `nil` if the type is unknown to
+  # the registry.
+  #
+  # @return [MimeMagic, nil] the canonical type, if present.
+  #
+  def canonical
+    t = TYPES[type.downcase] or return
+    return self if type == t[3]
+    self.class.new t[3]
+  end
+
+  # Return the type's aliases.
+  #
+  # @return [Array<MimeMagic>] the aliases, if any.
+  #
+  def aliases
+    TYPES.fetch(type.downcase, [nil, nil, nil, nil, []])[4].map do |t|
+      self.class.new t
+    end
+  end
+
+  # Determine if the type is an alias.
+  #
+  # @return [false, true] whether the type is an alias.
+  #
+  def alias?
+    type != canonical.type
+  end
+
+  # Returns true if the ancestor type is anywhere in the subject
+  # type's lineage. Always returns `false` if either `self` or
+  # `ancestor` are unknown to the type registry.
+  #
+  # @param ancestor [MimeType,#to_s] the candidate ancestor type
+  #
+  # @return [true, false] whether `self` is a descendant of `ancestor`
+  #
+  def descendant_of? ancestor
+    # always false if we don't know what this is
+    return unless c = canonical
+
+    # ancestor canonical could be nil which will be false
+    c.lineage.include? self.class[ancestor].canonical
+  end
+
+  # Returns true if type is child of parent type. Behaves the same as
+  # #descendant_of? if `recurse` is true, which is the default.
+  #
+  # @param parent [#to_s] a candidate parent type
+  # @param recurse [true, false] whether to recurse
+  #
+  # @return [true, false] whether `self` is a child of `parent`
+  #
+  def child_of?(parent, recurse: true)
+    return descendant_of? parent if recurse
+    return unless c = canonical
+    c.parents.include? self.class[parent].canonical
+  end
+
+  # Fetches the immediate parent types.
+  #
+  # @return [Array<MimeMagic>] the type's parents
+  #
+  def parents
+    out = TYPES.fetch(type.to_s.downcase, [nil, []])[1].map do |x|
+      self.class.new x
+    end
+    # add this unless we're it
+    out << self.class.new('application/octet-stream') if
+      out.empty? and type.downcase != 'application/octet-stream'
+
+    out.uniq
+  end
+
+  # Fetches the entire inheritance hierarchy for the given MIME type.
+  #
+  # @return [Array<MimeMagic>] the type's lineage
+  #
+  def lineage
+    ([canonical || self] + parents.map { |t| t.lineage }.flatten).uniq
+  end
+
+  alias_method :ancestor_types, :lineage
+
+  # Determine if the _type_ is a descendant of `text/plain`. Not to be
+  # confused with the class method {.binary?}, which concerns
+  # arbitrary input.
+  #
+  # @return [true, false, nil] whether the type is binary.
+  #
+  def binary?
+    not lineage.include? 'text/plain'
+  end
+
+  # Compare the equality of the type with another (or plain string).
+  #
+  # @param other [#to_s] the other to test
+  #
+  # @return [false, true] whether the two are equal.
+  #
+  def eql?(other)
+    # coerce the rhs
+    other = self.class[other] || self.class.default_type
+
+    # check for an exact match
+    return true if type == other.type
+
+    # now canonicalize both sides and check
+    lhs = canonical
+    rhs = other.canonical
+
+    lhs && rhs && lhs.type == rhs.type
+  end
+
+  alias_method :==, :eql?
+
+  # Return the object's (the underlying type string) hash.
+  #
+  # @return [Integer] the hash value.
+  #
+  def hash
+    type.hash
+  end
+
+  # Return the type as a string.
+  #
+  # @return [String] the type, as a string.
+  #
+  def to_s
+    type
+  end
+
+  # Return a diagnostic representation of the object.
+  #
+  # @return [String] a string representing the object.
+  #
+  def inspect
+    out = @type
+    out = [out, @params.map { |x| x.join ?= }].join ?; if
+      @params and !@params.empty?
+    %q[<%s "%s">] % [self.class, out]
+  end
+
+  # Look up MIME type by file extension. When `default` is true or a
+  # value, this method will always return a value.
+  #
+  # @param path [#to_s]
+  # @param default [false, true, #to_s, MimeMagic] a default fallback type
+  #
+  # @return [nil, MimeMagic] the type, if found.
+  #
+  def self.by_extension ext, default: false
+    ext = ext.to_s.downcase.delete_prefix ?.
+    default = coerce_default '', default
+    mime = EXTENSIONS[ext]
+    mime ? new(mime) : default
+  end
+
+  # Look up MIME type by file path. When `default` is true or a value,
+  # this method will always return a value.
+  #
+  # @param path [#to_s] the file/path to check
+  # @param default [false, true, #to_s, MimeMagic] a default fallback type
+  #
+  # @return [nil, MimeMagic] the type, if found.
+  #
+  def self.by_path path, default: false
+    by_extension(File.extname(path), default: default)
+  end
+
+  # Look up MIME type by magic content analysis. When `default` is true or a
+  # value, this method will always return a value.
+  #
+  # @note This is a relatively slow operation.
+  #
+  # @param io [#read, #to_s] the IO/String-like object to check for magic
+  # @param default [false, true, #to_s, MimeMagic] a default fallback type
+  #
+  # @return [nil, MimeMagic] a matching type, if found.
+  #
+  def self.by_magic io, default: false
+    default = coerce_default io, default
+    mime = magic_match(io, :find) or return default
+    new mime.first
+  end
+
+  # Return all matching MIME types by magic content analysis. When
+  # `default` is true or a value, the result will never be empty.
+  #
+  # @note This is a relatively slow operation.
+  #
+  # @param io [#read, #to_s] the IO/String-like object to check for magic
+  # @param default [false, true, #to_s, MimeMagic] a default fallback type
+  #
+  # @return [Array<MimeMagic>] all matching types
+  #
+  def self.all_by_magic io, default: false
+    default = coerce_default io, default
+    out = magic_match(io, :select).map { |mime| new mime.first }
+    out << default if out.empty? and default
+    out
+  end
+
+  # Returns true if type is child of parent type.
+  #
+  # @param child [#to_s] a candidate child type
+  # @param parent [#to_s] a candidate parent type
+  #
+  # @return [true, false] whether `self` is a child of `parent`
+  #
+  def self.child?(child, parent, recurse: true)
+    self[child].child_of? parent, recurse: recurse
+  end
+
+  # Return the canonical type.
+  #
+  # @param type [#to_s] the type to test
+  #
+  # @return [MimeMagic, nil] the canonical type, if present.
+  #
+  def self.canonical type
+    self[type].canonical
+  end
+
+  # Return the type's aliases.
+  #
+  # @param type [#to_s] the type to check
+  #
+  # @return [Array<MimeMagic>] the aliases, if any.
+  #
+  def self.aliases type
+    self[type].aliases
+  end
+
+  # Determine if an _input_ is binary. Not to be confused with the
+  # instance method {#binary?}, which concerns the _type_.
+  #
+  # @param thing [#read, #to_s] the IO-like or String-like thing to
+  #  test; can also be a file name/path/extension or MIME type.
+  #
+  # @return [true, false, nil] whether the input is binary (`nil` if
+  #  indeterminate).
+  #
+  def self.binary? thing
+    sample = ''
+
+    # get some stuff out of the IO or get a substring
+    if thing.is_a? MimeMagic
+      return thing.binary?
+    elsif %i[seek tell read].all? { |m| thing.respond_to? m }
+      pos = thing.tell
+      thing.seek 0, 0
+      sample = thing.read(256).to_s # handle empty
+      thing.seek pos
+    elsif thing.respond_to? :to_s
+      str = thing.to_s
+      # if it contains a slash it could be either a path or mimetype
+      test = if str.include? ?/
+               canonical(str) || by_extension(str.split(?.).last)
+             else
+               by_extension str.split(?.).last
+             end
+
+      return test.binary? if test
+
+      sample = str[0, 256]
+    else
+      # nil if we don't know what this thing is
+      return
+    end
+
+    # consider this to be 'binary' if empty
+    return true if sample.empty?
+    # control codes minus ordinary whitespace
+    /[\x0-\x8\xe-\x1f\x7f]/n.match? sample.b
+  end
+
+  # Return either `application/octet-stream` or `text/plain` depending
+  # on whether the thing is binary.
+  #
+  # @param thing [#read, #to_s] the thing (IO-like, String-like, MIME type,
+  #
+  # @return [MimeMagic] the default type
+  #
+  def self.default_type thing = nil
+    return new 'application/octet-stream' unless thing
+    new(binary?(thing) ? 'application/octet-stream' : 'text/plain')
+  end
+
+  private
+
+  def self.coerce_default thing, default
+    case default
+    when nil, false then nil
+    when true then default_type thing
+    when MimeMagic then default
+    when String, -> x { x.respond_to? :to_s } then new default
+    else default_type thing
+    end
+  end
+
+  def self.magic_match(io, method)
+    return magic_match(StringIO.new(io.to_s), method) unless io.respond_to?(:read)
+
+    io.binmode if io.respond_to?(:binmode)
+    io.set_encoding(Encoding::BINARY) if io.respond_to?(:set_encoding)
+    buffer = "".encode(Encoding::BINARY)
+
+    MAGIC.send(method) { |type, matches| magic_match_io(io, matches, buffer) }
+  end
+
+  def self.magic_match_io(io, matches, buffer)
+    matches.any? do |offset, value, children|
+      match =
+        if Range === offset
+          io.read(offset.begin, buffer)
+          x = io.read(offset.end - offset.begin + value.bytesize, buffer)
+          x && x.include?(value)
+        else
+          io.read(offset, buffer)
+          io.read(value.bytesize, buffer) == value
+        end
+      io.rewind
+      match && (!children || magic_match_io(io, children, buffer))
+    end
+  end
+
+end

data/mimemagic.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/lib/mimemagic/version'
+require 'date'
+
+Gem::Specification.new do |s|
+  s.name = 'mimemagic-dorian'
+  s.version = MimeMagic::VERSION
+
+  s.authors = ['Dorian Taylor', 'Daniel Mendler', 'Jon Wood']
+  s.date = Date.today.to_s
+  s.email = ['code@doriantaylor.com', 'mail@daniel-mendler.de', 'jon@blankpad.net']
+
+  s.files         = `git ls-files`.split("\n").reject { |f| f.match(%r{^(test|script)/}) }
+  s.require_paths = %w(lib)
+  s.extensions = %w(ext/mimemagic/Rakefile)
+
+  s.summary = 'Fast mime detection by extension or content (DORIAN PATCH)'
+  s.description = <<~EOS
+  Fast MIME detection by extension or content (Uses freedesktop.org.xml
+  shared-mime-info database). This fork implements PR #175 on the upstream
+  gem and will be dissolved if/when that patch is merged.
+  EOS
+  s.homepage = 'https://github.com/doriantaylor/rb-mimemagic'
+  s.license = 'MIT'
+
+  s.add_dependency('nokogiri', '~> 1')
+  s.add_dependency('rake')
+
+  s.add_development_dependency('minitest', '~> 5.14')
+
+  if s.respond_to?(:metadata)
+    s.metadata['changelog_uri'] = "https://github.com/doriantaylor/rb-mimemagic/blob/fork-gem/CHANGELOG.md"
+    s.metadata['source_code_uri'] = "https://github.com/doriantaylor/rb-mimemagic"
+    s.metadata['bug_tracker_uri'] = "https://github.com/doriantaylor/rb-mimemagic/issues"
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: mimemagic-dorian
+version: !ruby/object:Gem::Version
+  version: 0.5.4
+platform: ruby
+authors:
+- Dorian Taylor
+- Daniel Mendler
+- Jon Wood
+bindir: bin
+cert_chain: []
+date: 2026-06-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.14'
+description: |
+  Fast MIME detection by extension or content (Uses freedesktop.org.xml
+  shared-mime-info database). This fork implements PR #175 on the upstream
+  gem and will be dissolved if/when that patch is merged.
+email:
+- code@doriantaylor.com
+- mail@daniel-mendler.de
+- jon@blankpad.net
+executables: []
+extensions:
+- ext/mimemagic/Rakefile
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- ".yardopts"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- ext/mimemagic/Rakefile
+- lib/mimemagic.rb
+- lib/mimemagic/tables.rb
+- lib/mimemagic/version.rb
+- mimemagic.gemspec
+homepage: https://github.com/doriantaylor/rb-mimemagic
+licenses:
+- MIT
+metadata:
+  changelog_uri: https://github.com/doriantaylor/rb-mimemagic/blob/fork-gem/CHANGELOG.md
+  source_code_uri: https://github.com/doriantaylor/rb-mimemagic
+  bug_tracker_uri: https://github.com/doriantaylor/rb-mimemagic/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Fast mime detection by extension or content (DORIAN PATCH)
+test_files: []