mimetyper 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 602ca434a098ef893ef34c2329c90dfe9919c8b585224065484bc3e2cb422c8d
+  data.tar.gz: ed6c204d3a4b91ed432a723be994690107a0e71288f9eca6bf46c9c390f46e39
+SHA512:
+  metadata.gz: d2502c55d94e8b1656a1b955f7ac2f5f53aaa35dbdc095cdb768fc311912cf11ba7cf0c6b83ebf41193043691ffde2c2a4b585a66226157fe997e2bae309fb18
+  data.tar.gz: a75262f588369afe7882dd09ddb21f9eccd50c954b61198acf72a94ad580174632ef78a2448f07a12805ce582d06379cd9457a941973961176f64d127044612e

data/.gitignore

@@ -0,0 +1,206 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+Gemfile.lock
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+## RubyMine/IntelliJ
+.idea/
+*.iml
+*.ipr
+*.iws
+
+## VSCode
+.vscode/
+*.code-workspace
+
+## macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+Icon
+._*
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+## Windows
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+*.stackdump
+[Dd]esktop.ini
+$RECYCLE.BIN/
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+*.lnk
+
+## Linux
+*~
+.fuse_hidden*
+.directory
+.Trash-*
+.nfs*
+
+## Vim
+[._]*.s[a-v][a-z]
+[._]*.sw[a-p]
+[._]s[a-rt-v][a-z]
+[._]ss[a-gi-z]
+[._]sw[a-p]
+Session.vim
+Sessionx.vim
+.netrwhist
+tags
+[._]*.un~
+
+## Emacs
+\#*\#
+/.emacs.desktop
+/.emacs.desktop.lock
+*.elc
+auto-save-list
+tramp
+.\#*
+.org-id-locations
+*_archive
+*_flymake.*
+/eshell/history
+/eshell/lastdir
+/elpa/
+*.rel
+/auto/
+.cask/
+dist/
+flycheck_*.el
+.projectile
+.dir-locals.el
+/network-security.data
+
+## Ruby specific
+*.rbc
+capybara-*.html
+.rspec
+/db/*.sqlite3
+/db/*.sqlite3-journal
+/db/*.sqlite3-[0-9]*
+/public/system
+/coverage/
+/spec/tmp
+*.orig
+rerun.txt
+pickle-email-*.html
+.byebug_history
+
+## Bundler
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+.ruby-version
+.ruby-gemset
+.rvmrc
+
+## Testing
+/test/reports/
+/test/tmp/
+/test/version_tmp/
+/spec/reports/
+
+## Environment variables
+.env
+.env.local
+.env.*.local
+
+## Logs
+*.log
+/log/*
+!/log/.keep
+
+## Temporary files
+/tmp/*
+!/tmp/.keep
+*.tmp
+*.bak
+*.swp
+*~.nib
+
+## Build artifacts
+/build/
+/dist/
+/out/
+
+## Gem build artifacts
+*.gem
+*.rbc
+.bundle
+.config
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+
+## Documentation
+.yardoc
+_yardoc
+doc/
+rdoc/
+
+## Code coverage
+coverage
+.nyc_output
+
+## Debugger
+.byebug_history
+.pry_history
+
+## Node (in case of any JS tooling)
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+## CTags
+tags
+TAGS
+
+## Other
+.rake_tasks~
+.sass-cache
+.jekyll-cache/
+.jekyll-metadata
+
+DEPLOY.md

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake", "~> 13.0"
+gem "minitest", "~> 5.0"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024
+
+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,163 @@
+# MimeTyper
+
+A pure Ruby MIME type detection library focused on accuracy and reliability. MimeTyper uses magic byte detection and file extensions to accurately identify file types without any external dependencies.
+
+## Features
+
+- **Pure Ruby** - No external dependencies or C extensions
+- **Comprehensive** - Supports 150+ file types including images, documents, audio, video, archives, and more
+- **Accurate** - Uses magic byte detection for reliable type identification
+- **Fast** - Optimized for performance with minimal file reading
+- **Simple API** - Easy to use with just three methods
+- **Reliable** - Extensive test coverage ensures accuracy
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mimetyper'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install mimetyper
+```
+
+## Usage
+
+MimeTyper provides three simple methods for MIME type detection:
+
+### Detect from file path
+
+```ruby
+require 'mimetyper'
+
+# Detects MIME type using magic bytes first, falls back to extension
+MimeTyper.from_file('document.pdf')
+# => "application/pdf"
+
+MimeTyper.from_file('photo.jpg')
+# => "image/jpeg"
+
+MimeTyper.from_file('unknown.bin')
+# => "application/octet-stream"
+```
+
+### Detect from data
+
+```ruby
+# Detect MIME type from binary data
+data = File.read('image.png', mode: 'rb')
+MimeTyper.from_data(data)
+# => "image/png"
+
+# Optionally provide a filename for fallback detection
+unknown_data = "\x00\x01\x02"
+MimeTyper.from_data(unknown_data, filename: 'file.txt')
+# => "text/plain"
+```
+
+### Detect from extension only
+
+```ruby
+# Direct extension lookup (less accurate than magic byte detection)
+MimeTyper.from_extension('mp4')
+# => "video/mp4"
+
+MimeTyper.from_extension('.docx')
+# => "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+```
+
+## Supported Types
+
+MimeTyper supports a comprehensive range of file types:
+
+### Images
+- JPEG, PNG, GIF, WebP, BMP, ICO, TIFF
+- SVG, HEIC, AVIF, JP2
+- PSD (Photoshop), XCF (GIMP)
+
+### Documents
+- PDF, RTF
+- Microsoft Office: DOC, DOCX, XLS, XLSX, PPT, PPTX
+- OpenDocument: ODT, ODS, ODP
+
+### Audio
+- MP3, WAV, FLAC, OGG, M4A
+- MIDI, AIFF, WMA, AAC, OPUS
+
+### Video
+- MP4, AVI, MOV, WebM, MKV
+- FLV, MPEG, 3GP, WMV
+
+### Archives
+- ZIP, RAR, 7Z, TAR
+- GZIP, BZIP2, XZ
+
+### Programming
+- Source code files (Ruby, Python, JavaScript, Java, Go, etc.)
+- JSON, XML, YAML, TOML
+- HTML, CSS
+
+### Fonts
+- TTF, OTF, WOFF, WOFF2, EOT
+
+### Executables
+- EXE, DLL, ELF, Mach-O
+- JAR, APK, DEX
+
+### Databases
+- SQLite
+
+## How It Works
+
+MimeTyper uses a two-tier detection approach:
+
+1. **Magic Byte Detection**: Reads the first few bytes of a file to identify unique file signatures (magic bytes). This is the most reliable method.
+
+2. **Extension Fallback**: If magic byte detection fails or is inconclusive, falls back to file extension mapping.
+
+The library maintains a comprehensive database of:
+- Magic byte signatures with specific offsets
+- File extension mappings
+- Special detection logic for complex formats (Office documents, media containers, etc.)
+
+## Performance
+
+MimeTyper is designed for performance:
+- Reads only the first 4KB of files for detection
+- Magic bytes are checked in order of popularity
+- Efficient binary string matching
+
+## Accuracy and Reliability
+
+- Extensive test coverage with real-world file samples
+- Handles edge cases like:
+  - Office Open XML format detection (DOCX vs ZIP)
+  - Different video container formats
+  - Text encoding detection
+  - Malformed or truncated files
+
+## Default Behavior
+
+When MimeTyper cannot determine a specific MIME type, it returns `"application/octet-stream"` as a safe default.
+
+## Thread Safety
+
+MimeTyper is thread-safe. All methods are stateless and can be called concurrently from multiple threads.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/vancuren/mimetyper.
+
+## License
+
+The gem is available as open source under the terms of the MIT License.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/lib/mimetyper/mime_database.rb

@@ -0,0 +1,422 @@
+module MimeTyper
+  module MimeDatabase
+    MAGIC_BYTES = [
+      # Images
+      { magic: "\xFF\xD8\xFF".b, offset: 0, mime: "image/jpeg", extensions: %w[jpg jpeg jpe jif jfif jfi] },
+      { magic: "\x89PNG\r\n\x1A\n".b, offset: 0, mime: "image/png", extensions: %w[png] },
+      { magic: "GIF87a".b, offset: 0, mime: "image/gif", extensions: %w[gif] },
+      { magic: "GIF89a".b, offset: 0, mime: "image/gif", extensions: %w[gif] },
+      { magic: "BM".b, offset: 0, mime: "image/bmp", extensions: %w[bmp dib] },
+      { magic: "\x00\x00\x01\x00".b, offset: 0, mime: "image/vnd.microsoft.icon", extensions: %w[ico] },
+      { magic: "\x00\x00\x02\x00".b, offset: 0, mime: "image/vnd.microsoft.icon", extensions: %w[ico cur] },
+      { magic: "II\x2A\x00".b, offset: 0, mime: "image/tiff", extensions: %w[tif tiff] },
+      { magic: "MM\x00\x2A".b, offset: 0, mime: "image/tiff", extensions: %w[tif tiff] },
+      { magic: "RIFF".b, offset: 0, check: ->(data) { data[8,4] == "WEBP".b }, mime: "image/webp", extensions: %w[webp] },
+      { magic: "\x00\x00\x00\x0C\x6A\x50\x20\x20\x0D\x0A\x87\x0A".b, offset: 0, mime: "image/jp2", extensions: %w[jp2 j2k jpf jpm jpg2 j2c jpc jpx mj2] },
+      { magic: "\x00\x00\x00\x20\x66\x74\x79\x70\x68\x65\x69\x63".b, offset: 0, mime: "image/heic", extensions: %w[heic] },
+      { magic: "\x00\x00\x00\x20\x66\x74\x79\x70\x61\x76\x69\x66".b, offset: 0, mime: "image/avif", extensions: %w[avif] },
+
+      # Documents
+      { magic: "%PDF".b, offset: 0, mime: "application/pdf", extensions: %w[pdf] },
+      { magic: "\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1".b, offset: 0, mime: "application/vnd.ms-office", extensions: %w[doc xls ppt msi msg] },
+      { magic: "PK\x03\x04".b, offset: 0, mime: "application/zip", extensions: %w[zip], check: ->(data) { !docx_check(data) && !xlsx_check(data) && !pptx_check(data) && !odt_check(data) } },
+      { magic: "PK\x03\x04".b, offset: 0, mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document", extensions: %w[docx], check: ->(data) { docx_check(data) } },
+      { magic: "PK\x03\x04".b, offset: 0, mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", extensions: %w[xlsx], check: ->(data) { xlsx_check(data) } },
+      { magic: "PK\x03\x04".b, offset: 0, mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation", extensions: %w[pptx], check: ->(data) { pptx_check(data) } },
+      { magic: "PK\x03\x04".b, offset: 0, mime: "application/vnd.oasis.opendocument.text", extensions: %w[odt], check: ->(data) { odt_check(data) } },
+      { magic: "PK\x05\x06".b, offset: 0, mime: "application/zip", extensions: %w[zip] },
+      { magic: "PK\x07\x08".b, offset: 0, mime: "application/zip", extensions: %w[zip] },
+      { magic: "{\\rtf".b, offset: 0, mime: "application/rtf", extensions: %w[rtf] },
+      { magic: "\x7B\x5C\x72\x74\x66\x31".b, offset: 0, mime: "application/rtf", extensions: %w[rtf] },
+
+      # Archives
+      { magic: "Rar!\x1A\x07\x00".b, offset: 0, mime: "application/x-rar-compressed", extensions: %w[rar] },
+      { magic: "Rar!\x1A\x07\x01\x00".b, offset: 0, mime: "application/x-rar-compressed", extensions: %w[rar] },
+      { magic: "\x1F\x8B\x08".b, offset: 0, mime: "application/gzip", extensions: %w[gz gzip] },
+      { magic: "BZh".b, offset: 0, mime: "application/x-bzip2", extensions: %w[bz2 boz] },
+      { magic: "\x37\x7A\xBC\xAF\x27\x1C".b, offset: 0, mime: "application/x-7z-compressed", extensions: %w[7z] },
+      { magic: "\xFD\x37\x7A\x58\x5A\x00".b, offset: 0, mime: "application/x-xz", extensions: %w[xz] },
+      { magic: "ustar".b, offset: 257, mime: "application/x-tar", extensions: %w[tar] },
+      { magic: "MSCF".b, offset: 0, mime: "application/vnd.ms-cab-compressed", extensions: %w[cab] },
+
+      # Audio
+      { magic: "ID3".b, offset: 0, mime: "audio/mpeg", extensions: %w[mp3] },
+      { magic: "\xFF\xFB".b, offset: 0, mime: "audio/mpeg", extensions: %w[mp3] },
+      { magic: "\xFF\xF3".b, offset: 0, mime: "audio/mpeg", extensions: %w[mp3] },
+      { magic: "\xFF\xF2".b, offset: 0, mime: "audio/mpeg", extensions: %w[mp3] },
+      { magic: "OggS".b, offset: 0, mime: "audio/ogg", extensions: %w[ogg oga ogv] },
+      { magic: "RIFF".b, offset: 0, check: ->(data) { data[8,4] == "WAVE".b }, mime: "audio/wav", extensions: %w[wav] },
+      { magic: "fLaC".b, offset: 0, mime: "audio/flac", extensions: %w[flac] },
+      { magic: "\x00\x00\x00\x20\x66\x74\x79\x70\x4D\x34\x41".b, offset: 0, mime: "audio/mp4", extensions: %w[m4a] },
+      { magic: "MThd".b, offset: 0, mime: "audio/midi", extensions: %w[mid midi] },
+
+      # Video
+      { magic: "\x00\x00\x00\x14\x66\x74\x79\x70\x69\x73\x6F\x6D".b, offset: 0, mime: "video/mp4", extensions: %w[mp4 m4v] },
+      { magic: "\x00\x00\x00\x18\x66\x74\x79\x70\x6D\x70\x34\x32".b, offset: 0, mime: "video/mp4", extensions: %w[mp4 m4v] },
+      { magic: "\x00\x00\x00\x1C\x66\x74\x79\x70\x4D\x53\x4E\x56".b, offset: 0, mime: "video/mp4", extensions: %w[mp4] },
+      { magic: "\x00\x00\x00\x20\x66\x74\x79\x70\x69\x73\x6F\x6D".b, offset: 0, mime: "video/mp4", extensions: %w[mp4] },
+      { magic: "\x00\x00\x00\x18\x66\x74\x79\x70\x33\x67\x70\x35".b, offset: 0, mime: "video/3gpp", extensions: %w[3gp 3gpp] },
+      { magic: "\x00\x00\x00\x14\x66\x74\x79\x70\x71\x74\x20\x20".b, offset: 0, mime: "video/quicktime", extensions: %w[mov qt] },
+      { magic: "\x00\x00\x00\x20\x66\x74\x79\x70\x71\x74\x20\x20".b, offset: 0, mime: "video/quicktime", extensions: %w[mov qt] },
+      { magic: "RIFF".b, offset: 0, check: ->(data) { data[8,4] == "AVI ".b }, mime: "video/x-msvideo", extensions: %w[avi] },
+      { magic: "\x1A\x45\xDF\xA3".b, offset: 0, mime: "video/webm", extensions: %w[webm mkv], check: ->(data) { webm_check(data) } },
+      { magic: "FLV".b, offset: 0, mime: "video/x-flv", extensions: %w[flv] },
+      { magic: "\x00\x00\x01\xBA".b, offset: 0, mime: "video/mpeg", extensions: %w[mpg mpeg] },
+      { magic: "\x00\x00\x01\xB3".b, offset: 0, mime: "video/mpeg", extensions: %w[mpg mpeg] },
+
+      # Fonts
+      { magic: "\x00\x01\x00\x00".b, offset: 0, mime: "font/ttf", extensions: %w[ttf] },
+      { magic: "OTTO".b, offset: 0, mime: "font/otf", extensions: %w[otf] },
+      { magic: "wOFF".b, offset: 0, mime: "font/woff", extensions: %w[woff] },
+      { magic: "wOF2".b, offset: 0, mime: "font/woff2", extensions: %w[woff2] },
+      { magic: "\x00\x00\x01\x00".b, offset: 0, check: ->(data) { data[4,2] == "\x00\x00".b }, mime: "application/vnd.ms-fontobject", extensions: %w[eot] },
+
+      # Executables
+      { magic: "MZ".b, offset: 0, mime: "application/x-msdownload", extensions: %w[exe dll com bat msi] },
+      { magic: "\x7FELF".b, offset: 0, mime: "application/x-executable", extensions: %w[elf axf bin o so] },
+      { magic: "\xCA\xFE\xBA\xBE".b, offset: 0, mime: "application/java-vm", extensions: %w[class] },
+      { magic: "\xCE\xFA\xED\xFE".b, offset: 0, mime: "application/x-mach-binary", extensions: %w[dylib] },
+      { magic: "\xCF\xFA\xED\xFE".b, offset: 0, mime: "application/x-mach-binary", extensions: %w[dylib] },
+      { magic: "\xFE\xED\xFA\xCE".b, offset: 0, mime: "application/x-mach-binary", extensions: %w[dylib] },
+      { magic: "\xFE\xED\xFA\xCF".b, offset: 0, mime: "application/x-mach-binary", extensions: %w[dylib] },
+      { magic: "PK\x03\x04".b, offset: 0, mime: "application/java-archive", extensions: %w[jar], check: ->(data) { jar_check(data) } },
+      { magic: "PK\x03\x04".b, offset: 0, mime: "application/vnd.android.package-archive", extensions: %w[apk], check: ->(data) { apk_check(data) } },
+      { magic: "dex\n035\x00".b, offset: 0, mime: "application/x-android-dex", extensions: %w[dex] },
+
+      # Database
+      { magic: "SQLite format 3\x00".b, offset: 0, mime: "application/x-sqlite3", extensions: %w[sqlite sqlite3 db db3 s3db sl3] },
+
+      # Text formats
+      { magic: "<!DOCTYPE".b, offset: 0, mime: "text/html", extensions: %w[html htm], check: ->(data) { html_check(data) } },
+      { magic: "<html".b, offset: 0, mime: "text/html", extensions: %w[html htm] },
+      { magic: "<HTML".b, offset: 0, mime: "text/html", extensions: %w[html htm] },
+      { magic: "<?xml".b, offset: 0, mime: "text/xml", extensions: %w[xml xsl xslt], check: ->(data) { !svg_check(data) } },
+      { magic: "<svg".b, offset: 0, mime: "image/svg+xml", extensions: %w[svg svgz] },
+      { magic: "<?xml".b, offset: 0, mime: "image/svg+xml", extensions: %w[svg svgz], check: ->(data) { svg_check(data) } },
+      { magic: "{".b, offset: 0, mime: "application/json", extensions: %w[json], check: ->(data) { json_check(data) } },
+      { magic: "[".b, offset: 0, mime: "application/json", extensions: %w[json], check: ->(data) { json_check(data) } },
+      { magic: "%!PS".b, offset: 0, mime: "application/postscript", extensions: %w[ps eps ai] },
+      { magic: "%!PS-Adobe-".b, offset: 0, check: ->(data) { data[11,3] == "EPS".b }, mime: "application/eps", extensions: %w[eps epsf epsi] },
+
+      # Other
+      { magic: "LZIP".b, offset: 0, mime: "application/x-lzip", extensions: %w[lz] },
+      { magic: "\x1F\x9D".b, offset: 0, mime: "application/x-compress", extensions: %w[Z] },
+      { magic: "\x1F\xA0".b, offset: 0, mime: "application/x-compress", extensions: %w[Z] },
+      { magic: "-----BEGIN".b, offset: 0, mime: "application/x-pem-file", extensions: %w[pem crt cer key] },
+      { magic: "\x89HDF\r\n\x1A\n".b, offset: 0, mime: "application/x-hdf", extensions: %w[hdf hdf4 h4] },
+      { magic: "CDF\x01".b, offset: 0, mime: "application/x-netcdf", extensions: %w[nc cdf] },
+      { magic: "8BPS".b, offset: 0, mime: "image/vnd.adobe.photoshop", extensions: %w[psd psb] },
+      { magic: "gimp xcf ".b, offset: 0, mime: "image/x-xcf", extensions: %w[xcf] },
+      { magic: "II\xBC\x00".b, offset: 0, mime: "image/vnd.djvu", extensions: %w[djvu djv] },
+      { magic: "AT&TFORM".b, offset: 0, mime: "image/vnd.djvu", extensions: %w[djvu djv] },
+      { magic: "BLENDER".b, offset: 0, mime: "application/x-blender", extensions: %w[blend] },
+      { magic: "!<arch>\n".b, offset: 0, mime: "application/x-archive", extensions: %w[a ar lib] },
+      { magic: "OggS".b, offset: 0, check: ->(data) { data[28,8] == "\x01vorbis".b }, mime: "audio/ogg", extensions: %w[ogg oga] },
+      { magic: "OggS".b, offset: 0, check: ->(data) { data[28,7] == "\x80theora".b }, mime: "video/ogg", extensions: %w[ogv ogg] },
+      { magic: "ftyp".b, offset: 4, mime: "video/mp4", extensions: %w[mp4 m4v f4v] },
+      { magic: "moov".b, offset: 4, mime: "video/quicktime", extensions: %w[mov qt] },
+      { magic: "free".b, offset: 4, mime: "video/quicktime", extensions: %w[mov qt] },
+      { magic: "mdat".b, offset: 4, mime: "video/quicktime", extensions: %w[mov qt] },
+      { magic: "wide".b, offset: 4, mime: "video/quicktime", extensions: %w[mov qt] },
+      { magic: "pnot".b, offset: 4, mime: "video/quicktime", extensions: %w[mov qt] },
+      { magic: "skip".b, offset: 4, mime: "video/quicktime", extensions: %w[mov qt] },
+    ].freeze
+
+    # Extension-only fallback mappings for when magic bytes don't match
+    EXTENSION_MAP = {
+      # Text
+      "txt" => "text/plain",
+      "text" => "text/plain",
+      "log" => "text/plain",
+      "csv" => "text/csv",
+      "tsv" => "text/tab-separated-values",
+      "html" => "text/html",
+      "htm" => "text/html",
+      "xhtml" => "application/xhtml+xml",
+      "xml" => "text/xml",
+      "css" => "text/css",
+      "js" => "application/javascript",
+      "mjs" => "application/javascript",
+      "json" => "application/json",
+      "jsonld" => "application/ld+json",
+      "yaml" => "text/yaml",
+      "yml" => "text/yaml",
+      "toml" => "application/toml",
+      "ini" => "text/plain",
+      "cfg" => "text/plain",
+      "conf" => "text/plain",
+      "properties" => "text/plain",
+
+      # Programming languages
+      "c" => "text/x-c",
+      "cc" => "text/x-c++",
+      "cpp" => "text/x-c++",
+      "cxx" => "text/x-c++",
+      "h" => "text/x-c",
+      "hpp" => "text/x-c++",
+      "cs" => "text/x-csharp",
+      "java" => "text/x-java",
+      "py" => "text/x-python",
+      "rb" => "text/x-ruby",
+      "go" => "text/x-go",
+      "rs" => "text/x-rust",
+      "swift" => "text/x-swift",
+      "kt" => "text/x-kotlin",
+      "scala" => "text/x-scala",
+      "php" => "text/x-php",
+      "pl" => "text/x-perl",
+      "lua" => "text/x-lua",
+      "r" => "text/x-r",
+      "m" => "text/x-objc",
+      "mm" => "text/x-objc++",
+      "sql" => "application/sql",
+      "sh" => "application/x-sh",
+      "bash" => "application/x-sh",
+      "zsh" => "application/x-sh",
+      "fish" => "application/x-sh",
+      "ps1" => "application/x-powershell",
+      "bat" => "application/x-bat",
+      "cmd" => "application/x-bat",
+
+      # Markup
+      "md" => "text/markdown",
+      "markdown" => "text/markdown",
+      "rst" => "text/x-rst",
+      "adoc" => "text/asciidoc",
+      "latex" => "text/x-latex",
+
+      # Data
+      "ics" => "text/calendar",
+      "vcf" => "text/vcard",
+
+      # Images (fallback)
+      "svg" => "image/svg+xml",
+      "svgz" => "image/svg+xml",
+      "ico" => "image/vnd.microsoft.icon",
+      "webp" => "image/webp",
+      "bmp" => "image/bmp",
+      "jpg" => "image/jpeg",
+      "jpeg" => "image/jpeg",
+      "jpe" => "image/jpeg",
+      "png" => "image/png",
+      "gif" => "image/gif",
+      "tif" => "image/tiff",
+      "tiff" => "image/tiff",
+      "psd" => "image/vnd.adobe.photoshop",
+      "xcf" => "image/x-xcf",
+      "heic" => "image/heic",
+      "heif" => "image/heif",
+      "avif" => "image/avif",
+      "jxl" => "image/jxl",
+
+      # Audio (fallback)
+      "mp3" => "audio/mpeg",
+      "m4a" => "audio/mp4",
+      "wav" => "audio/wav",
+      "flac" => "audio/flac",
+      "ogg" => "audio/ogg",
+      "oga" => "audio/ogg",
+      "opus" => "audio/opus",
+      "wma" => "audio/x-ms-wma",
+      "aac" => "audio/aac",
+      "mid" => "audio/midi",
+      "midi" => "audio/midi",
+      "aiff" => "audio/aiff",
+      "aif" => "audio/aiff",
+      "aifc" => "audio/aiff",
+      "ape" => "audio/x-ape",
+      "wv" => "audio/wavpack",
+      "amr" => "audio/amr",
+
+      # Video (fallback)
+      "mp4" => "video/mp4",
+      "m4v" => "video/mp4",
+      "mkv" => "video/x-matroska",
+      "webm" => "video/webm",
+      "mov" => "video/quicktime",
+      "qt" => "video/quicktime",
+      "avi" => "video/x-msvideo",
+      "wmv" => "video/x-ms-wmv",
+      "flv" => "video/x-flv",
+      "mpg" => "video/mpeg",
+      "mpeg" => "video/mpeg",
+      "m2v" => "video/mpeg",
+      "3gp" => "video/3gpp",
+      "3g2" => "video/3gpp2",
+      "f4v" => "video/mp4",
+      "asf" => "video/x-ms-asf",
+      "rm" => "application/vnd.rn-realmedia",
+      "rmvb" => "application/vnd.rn-realmedia-vbr",
+      "vob" => "video/dvd",
+
+      # Documents (fallback)
+      "pdf" => "application/pdf",
+      "doc" => "application/vnd.ms-office",
+      "docx" => "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      "xls" => "application/vnd.ms-office",
+      "xlsx" => "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      "ppt" => "application/vnd.ms-powerpoint",
+      "pptx" => "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+      "odt" => "application/vnd.oasis.opendocument.text",
+      "ods" => "application/vnd.oasis.opendocument.spreadsheet",
+      "odp" => "application/vnd.oasis.opendocument.presentation",
+      "rtf" => "application/rtf",
+      "tex" => "application/x-tex",
+
+      # Archives (fallback)
+      "zip" => "application/zip",
+      "rar" => "application/x-rar-compressed",
+      "7z" => "application/x-7z-compressed",
+      "tar" => "application/x-tar",
+      "gz" => "application/gzip",
+      "bz2" => "application/x-bzip2",
+      "xz" => "application/x-xz",
+      "z" => "application/x-compress",
+      "lz" => "application/x-lzip",
+      "lzma" => "application/x-lzma",
+      "lzo" => "application/x-lzop",
+      "rz" => "application/x-rzip",
+      "sz" => "application/x-snappy",
+      "deb" => "application/vnd.debian.binary-package",
+      "rpm" => "application/x-rpm",
+      "jar" => "application/java-archive",
+      "war" => "application/java-archive",
+      "ear" => "application/java-archive",
+      "apk" => "application/vnd.android.package-archive",
+      "dmg" => "application/x-apple-diskimage",
+      "iso" => "application/x-iso9660-image",
+      "img" => "application/octet-stream",
+
+      # Fonts (fallback)
+      "ttf" => "font/ttf",
+      "otf" => "font/otf",
+      "woff" => "font/woff",
+      "woff2" => "font/woff2",
+      "eot" => "application/vnd.ms-fontobject",
+      "ttc" => "font/collection",
+      "pfb" => "font/type1",
+      "pfm" => "font/type1",
+
+      # Executables (fallback)
+      "exe" => "application/x-msdownload",
+      "dll" => "application/x-msdownload",
+      "so" => "application/x-sharedlib",
+      "dylib" => "application/x-mach-binary",
+      "class" => "application/java-vm",
+      "dex" => "application/x-android-dex",
+
+      # Other
+      "swf" => "application/x-shockwave-flash",
+      "xap" => "application/x-silverlight-app",
+      "ipa" => "application/x-ios-app",
+      "crx" => "application/x-chrome-extension",
+      "xpi" => "application/x-xpinstall",
+      "epub" => "application/epub+zip",
+      "mobi" => "application/x-mobipocket-ebook",
+      "azw" => "application/vnd.amazon.ebook",
+      "azw3" => "application/vnd.amazon.ebook",
+    }.freeze
+
+    module_function
+
+    def docx_check(data)
+      return false if data.size < 30
+      # Check for common DOCX internal file signatures
+      data.include?("word/".b) || data.include?("Word.Document".b) ||
+        data.include?("[Content_Types].xml".b) && (data.include?("word/document.xml".b) || data.include?("word/".b))
+    end
+
+    def xlsx_check(data)
+      return false if data.size < 30
+      # Check for common XLSX internal file signatures
+      data.include?("xl/".b) || data.include?("Excel".b) ||
+        data.include?("[Content_Types].xml".b) && (data.include?("xl/workbook.xml".b) || data.include?("xl/".b))
+    end
+
+    def pptx_check(data)
+      return false if data.size < 30
+      # Check for common PPTX internal file signatures
+      data.include?("ppt/".b) || data.include?("PowerPoint".b) ||
+        data.include?("[Content_Types].xml".b) && (data.include?("ppt/presentation.xml".b) || data.include?("ppt/".b))
+    end
+
+    def odt_check(data)
+      return false if data.size < 100
+      data.include?("manifest.rdf".b) && data.include?("content.xml".b)
+    end
+
+    def jar_check(data)
+      return false if data.size < 100
+      data.include?("META-INF/MANIFEST.MF".b)
+    end
+
+    def apk_check(data)
+      return false if data.size < 100
+      data.include?("AndroidManifest.xml".b) || data.include?("classes.dex".b)
+    end
+
+    def webm_check(data)
+      return false if data.size < 20
+      # Look for WebM signature in the EBML header
+      # WebM files have EBML header followed by doctype "webm"
+      # The "webm" string can appear anywhere in the first 100 bytes
+      search_area = data[0..[100, data.size].min]
+      return true if search_area.include?("webm".b)
+      return true if search_area.include?("matroska".b)  # Matroska is also valid for MKV
+      false
+    end
+
+    def svg_check(data)
+      return false if data.size < 20
+      content = data[0..[500, data.size].min]
+      # Convert to string for case-insensitive check
+      content_str = content.force_encoding('UTF-8').downcase rescue content.downcase
+      content_str.include?("<svg") || content_str.include?("xmlns=\"http://www.w3.org/2000/svg\"")
+    end
+
+    def html_check(data)
+      return false if data.size < 10
+      content = data[0..[500, data.size].min]
+      # Convert to string for case-insensitive check
+      content_str = content.force_encoding('UTF-8').downcase rescue content.downcase
+      content_str.include?("<html") || content_str.include?("<!doctype html")
+    end
+
+    def json_check(data)
+      return false if data.empty?
+      content = data.strip
+      return false unless (content[0] == '{' && content[-1] == '}') || (content[0] == '[' && content[-1] == ']')
+
+      # Simple JSON validation - check for basic structure
+      depth = 0
+      in_string = false
+      escaped = false
+
+      content.each_char do |char|
+        if in_string
+          if escaped
+            escaped = false
+          elsif char == '\\'
+            escaped = true
+          elsif char == '"'
+            in_string = false
+          end
+        else
+          case char
+          when '"'
+            in_string = true
+          when '{', '['
+            depth += 1
+          when '}', ']'
+            depth -= 1
+            return false if depth < 0
+          end
+        end
+      end
+
+      depth == 0
+    rescue
+      false
+    end
+  end
+end

data/lib/mimetyper.rb

@@ -0,0 +1,143 @@
+require_relative "mimetyper/mime_database"
+
+module MimeTyper
+  class << self
+    def from_file(path)
+      raise ArgumentError, "File path cannot be nil" if path.nil?
+      raise ArgumentError, "File does not exist: #{path}" unless File.exist?(path)
+
+      # Read file data for magic byte detection
+      data = File.open(path, "rb") { |f| f.read(4096) } || ""
+
+      # Try magic byte detection first
+      mime_type = detect_by_magic(data)
+
+      # If we only detected generic text/plain, try extension for more specific type
+      if mime_type == "text/plain" && path.include?('.')
+        extension = File.extname(path).downcase[1..-1]
+        extension_mime = detect_by_extension(extension) if extension
+        # Use extension-based type if it's more specific
+        mime_type = extension_mime if extension_mime && extension_mime != "text/plain"
+      elsif mime_type.nil? && path.include?('.')
+        # Fall back to extension if magic detection fails completely
+        extension = File.extname(path).downcase[1..-1]
+        mime_type = detect_by_extension(extension) if extension
+      end
+
+      mime_type || "application/octet-stream"
+    end
+
+    def from_data(data, filename: nil)
+      raise ArgumentError, "Data cannot be nil" if data.nil?
+
+      data = data.b if data.is_a?(String) # Ensure binary encoding
+
+      # Try magic byte detection first
+      mime_type = detect_by_magic(data)
+
+      # Fall back to filename extension if provided
+      if mime_type.nil? && filename && filename.include?('.')
+        extension = File.extname(filename).downcase[1..-1]
+        mime_type = detect_by_extension(extension) if extension
+      end
+
+      mime_type || "application/octet-stream"
+    end
+
+    def from_extension(extension)
+      raise ArgumentError, "Extension cannot be nil" if extension.nil?
+
+      extension = extension.downcase
+      extension = extension[1..-1] if extension.start_with?('.')
+
+      detect_by_extension(extension) || "application/octet-stream"
+    end
+
+    private
+
+    def detect_by_magic(data)
+      return nil if data.nil? || data.empty?
+
+      MimeDatabase::MAGIC_BYTES.each do |entry|
+        next if entry[:offset] >= data.size
+
+        magic = entry[:magic]
+        offset = entry[:offset]
+
+        # Check if the magic bytes match at the specified offset
+        if data[offset, magic.size] == magic
+          # If there's an additional check function, use it
+          if entry[:check]
+            next unless entry[:check].call(data)
+          end
+
+          return entry[:mime]
+        end
+      end
+
+      # Special case for text files - check if it's valid UTF-8
+      if data.size > 0 && is_text?(data)
+        return "text/plain"
+      end
+
+      nil
+    end
+
+    def detect_by_extension(extension)
+      return nil if extension.nil? || extension.empty?
+
+      # First check in magic bytes extensions
+      MimeDatabase::MAGIC_BYTES.each do |entry|
+        if entry[:extensions] && entry[:extensions].include?(extension)
+          return entry[:mime]
+        end
+      end
+
+      # Then check in extension map
+      MimeDatabase::EXTENSION_MAP[extension]
+    end
+
+    def is_text?(data)
+      # Check if data appears to be text
+      # Look for common text patterns and absence of binary markers
+      return false if data.nil? || data.empty?
+
+      # Don't detect single character as text
+      return false if data.size == 1
+
+      # Sample the first 512 bytes
+      sample = data[0, [512, data.size].min]
+
+      # Count control characters (excluding tab, newline, carriage return)
+      control_chars = 0
+      printable_chars = 0
+      null_bytes = 0
+
+      sample.each_byte do |byte|
+        if byte == 0
+          null_bytes += 1
+        elsif byte == 9 || byte == 10 || byte == 13 || (byte >= 32 && byte < 127)
+          printable_chars += 1
+        elsif byte < 32 || byte == 127
+          control_chars += 1
+        end
+      end
+
+      # If there are null bytes, it's likely binary
+      return false if null_bytes > 0
+
+      # If more than 30% are control characters, it's likely binary
+      return false if control_chars > sample.size * 0.3
+
+      # If more than 80% are printable ASCII, it's likely text
+      return true if printable_chars > sample.size * 0.8
+
+      # Try to validate as UTF-8
+      begin
+        sample.force_encoding('UTF-8').valid_encoding?
+      rescue
+        false
+      end
+    end
+  end
+end

data/mimetyper.gemspec

@@ -0,0 +1,25 @@
+Gem::Specification.new do |spec|
+  spec.name          = "mimetyper"
+  spec.version       = "1.0.0"
+  spec.authors       = ["Russell Van Curen"]
+  spec.email         = ["russell@vancuren.net"]
+
+  spec.summary       = %q{A pure Ruby MIME type detection library focused on accuracy and reliability}
+  spec.description   = %q{MimeTyper is a comprehensive, pure Ruby MIME type detection library that uses magic bytes and file extensions to accurately identify file types. Built for reliability and simplicity.}
+  spec.homepage      = "https://github.com/vancuren/mimetyper"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: mimetyper
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Russell Van Curen
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-09-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: MimeTyper is a comprehensive, pure Ruby MIME type detection library that
+  uses magic bytes and file extensions to accurately identify file types. Built for
+  reliability and simplicity.
+email:
+- russell@vancuren.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/mimetyper.rb
+- lib/mimetyper/mime_database.rb
+- mimetyper.gemspec
+homepage: https://github.com/vancuren/mimetyper
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/vancuren/mimetyper
+  source_code_uri: https://github.com/vancuren/mimetyper
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: A pure Ruby MIME type detection library focused on accuracy and reliability
+test_files: []