marcel 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35fe8aac124b049b86f375622d6255bb549fa4c972db38f27328472c96a74497
-  data.tar.gz: 9b4800e39fa6c1506acb964730567f4457a2b5e89be6c0fc271144f2dc5b34f8
+  metadata.gz: d72cd32835e2c94cb305350ca65c70471ba0003730705c42f880571344b9a79c
+  data.tar.gz: bf87bf4e6739db822a9e474677d4785aad74a37add0ad88fba3c2daac24bb142
 SHA512:
-  metadata.gz: cbf93f7d5b30bcb3927c49fe3cbcc238f040689178a810892be64095908112dbe27381a438bb7d6cf89980af14e82b52d46263f9df8577d2836c5dbd9858771b
-  data.tar.gz: 787c8be7892b97d02b96edf1340656d43c98829a187f7d90d7b720b188d793e26c8c34f55f1e7529ed646f0e7cb6d8ed8fd87c7b4299510ffed89f7d03cc23b5
+  metadata.gz: 002d7bf37923e0ce1da283ee7d41f36f604c454aa0924066013590805bb5bcaa878fab1cda9a884544afbcaf589384e0960a80774723f202a7c6dfa637bea05a
+  data.tar.gz: c3c361fc72ceec92d38e938613f8e1bbb7821cbe7221a59255d5d6eb8012aafd775b38f431c34df3fb5e9b443fedfdcda500fb76a2cb52e03cbe6028a042c26e

data/README.md

@@ -1,8 +1,6 @@
 # Marcel
 
-Marcel attempts to choose the most appropriate content type for a given file by looking at the binary data, the filename, and any declared type (perhaps passed as a request header):
-
-It's used like this:
+Marcel attempts to choose the most appropriate content type for a given file by looking at the binary data, the filename, and any declared type (perhaps passed as a request header). This is done via the `Marcel::MimeType.for` method, and is used like this:
 
 ```ruby
 Marcel::MimeType.for Pathname.new("example.gif")
@@ -43,6 +41,14 @@ Marcel::MimeType.for Pathname.new("example.png"), name: "example.ai"
 # As "application/illustrator" is not a more specific type of "image/png", the filename is ignored
 ```
 
+Custom file types not supported by Marcel can be added using `Marcel::MimeType.extend`. 
+
+```ruby
+Marcel::MimeType.extend "text/custom", extensions: %w( customtxt )
+Marcel::MimeType.for name: "file.customtxt"
+#  => "text/custom"
+```
+
 ## Motivation
 
 Marcel was extracted from Basecamp 3, in order to make our file detection logic both easily reusable but more importantly, easily testable. Test fixtures have been added for all of the most common file types uploaded to Basecamp, and other common file types too. We hope to expand this test coverage with other file types as and when problems are identified.

data/lib/marcel/magic.rb

@@ -29,9 +29,9 @@ module Marcel
     # * <i>:comment</i>: Comment string
     def self.add(type, options)
       extensions = [options[:extensions]].flatten.compact
-      TYPES[type] = [extensions,
-                    [options[:parents]].flatten.compact,
-                    options[:comment]]
+      TYPE_EXTS[type] = extensions
+      parents = [options[:parents]].flatten.compact
+      TYPE_PARENTS[type] = parents unless parents.empty?
       extensions.each {|ext| EXTENSIONS[ext] = type }
       MAGIC.unshift [type, options[:magic]] if options[:magic]
     end
@@ -42,7 +42,8 @@ module Marcel
     def self.remove(type)
       EXTENSIONS.delete_if {|ext, t| t == type }
       MAGIC.delete_if {|t, m| t == type }
-      TYPES.delete(type)
+      TYPE_EXTS.delete(type)
+      TYPE_PARENTS.delete(type)
     end
 
     # Returns true if type is a text format
@@ -60,12 +61,12 @@ module Marcel
 
     # Get string list of file extensions
     def extensions
-      TYPES.key?(type) ? TYPES[type][0] : []
+      TYPE_EXTS[type] || []
     end
 
     # Get mime comment
     def comment
-      (TYPES.key?(type) ? TYPES[type][2] : nil).to_s
+      nil # deprecated
     end
 
     # Lookup mime type by file extension
@@ -110,7 +111,7 @@ module Marcel
     alias == eql?
 
     def self.child?(child, parent)
-      child == parent || TYPES.key?(child) && TYPES[child][1].any? {|p| child?(p, parent) }
+      child == parent || TYPE_PARENTS[child]&.any? {|p| child?(p, parent) }
     end
 
     def self.magic_match(io, method)

data/lib/marcel/mime_type/definitions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Marcel::MimeType.extend "text/plain", extensions: %w( txt asc )
 
 Marcel::MimeType.extend "application/illustrator", parents: "application/pdf"
@@ -31,7 +33,7 @@ Marcel::MimeType.extend "application/vnd.apple.numbers", extensions: %w( numbers
 Marcel::MimeType.extend "application/vnd.apple.keynote", extensions: %w( key ), parents: "application/zip"
 
 Marcel::MimeType.extend "audio/aac", extensions: %w( aac ), parents: "audio/x-aac"
-
+Marcel::MimeType.extend("audio/ogg", extensions: %w( ogg oga ), magic: [[0, 'OggS', [[29, 'vorbis']]]])
 
 Marcel::MimeType.extend "image/vnd.dwg", magic: [[0, "AC10"]]
 
@@ -57,8 +59,8 @@ Marcel::MimeType.extend(
   "application/vnd.ms-access",
   extensions: %w( mdb mde accdb accde ),
   magic: [
-    [0, "\x00\x01\x00\x00\x53\x74\x61\x6e\x64\x61\x72\x64\x20\x4a\x65\x74\x20\x44\x42"], # \x00\x01\x00\xStandard Jet DB
-    [0, "\x00\x01\x00\x00\x53\x74\x61\x6e\x64\x61\x72\x64\x20\x41\x43\x45\x20\x44\x42"], # \x00\x01\x00\xStandard ACE DB
+    [0, "\x00\x01\x00\x00\x53\x74\x61\x6e\x64\x61\x72\x64\x20\x4a\x65\x74\x20\x44\x42"], # "\x00\x01\x00Standard Jet DB"
+    [0, "\x00\x01\x00\x00\x53\x74\x61\x6e\x64\x61\x72\x64\x20\x41\x43\x45\x20\x44\x42"], # "\x00\x01\x00Standard ACE DB"
   ],
   parents: "application/x-msaccess"
 )

data/lib/marcel/mime_type.rb

@@ -1,30 +1,38 @@
+# frozen_string_literal: true
+
 module Marcel
   class MimeType
     BINARY = "application/octet-stream"
 
     class << self
       def extend(type, extensions: [], parents: [], magic: nil)
-        existing = Marcel::TYPES[type] || [[], [], ""]
-
-        extensions = (Array(extensions) + existing[0]).uniq
-        parents = (Array(parents) + existing[1]).uniq
-        comment = existing[2]
-
-        Magic.add(type, extensions: extensions, magic: magic, parents: parents, comment: comment)
+        extensions = (Array(extensions) + Array(Marcel::TYPE_EXTS[type])).uniq
+        parents = (Array(parents) + Array(Marcel::TYPE_PARENTS[type])).uniq
+        Magic.add(type, extensions: extensions, magic: magic, parents: parents)
       end
 
+      # Returns the most appropriate content type for the given file.
+      #
+      # The first argument should be a +Pathname+ or an +IO+. If it is a +Pathname+, the specified
+      # file will be opened first.
+      #
+      # Optional parameters:
+      # * +name+: file name, if known
+      # * +extension+: file extension, if known
+      # * +declared_type+: MIME type, if known
+      #
+      # The most appropriate type is determined by the following:
+      # * type declared by binary magic number data
+      # * type declared by the first of file name, file extension, or declared MIME type
+      #
+      # If no type can be determined, then +application/octet-stream+ is returned.
       def for(pathname_or_io = nil, name: nil, extension: nil, declared_type: nil)
-        type_from_data = for_data(pathname_or_io)
-        fallback_type = for_declared_type(declared_type) || for_name(name) || for_extension(extension) || BINARY
-
-        if type_from_data
-          most_specific_type type_from_data, fallback_type
-        else
-          fallback_type
-        end
+        filename_type = for_name(name) || for_extension(extension)
+        most_specific_type for_data(pathname_or_io), for_declared_type(declared_type), filename_type, BINARY
       end
 
       private
+
         def for_data(pathname_or_io)
           if pathname_or_io
             with_io(pathname_or_io) do |io|
@@ -52,11 +60,7 @@ module Marcel
         end
 
         def for_declared_type(declared_type)
-          type = parse_media_type(declared_type)
-
-          if type != BINARY && !type.nil?
-            type.downcase
-          end
+          parse_media_type(declared_type)
         end
 
         def with_io(pathname_or_io, &block)
@@ -77,19 +81,9 @@ module Marcel
         # For some document types (notably Microsoft Office) we recognise the main content
         # type with magic, but not the specific subclass. In this situation, if we can get a more
         # specific class using either the name or declared_type, we should use that in preference
-        def most_specific_type(from_magic_type, fallback_type)
-          if (root_types(from_magic_type) & root_types(fallback_type)).any?
-            fallback_type
-          else
-            from_magic_type
-          end
-        end
-
-        def root_types(type)
-          if TYPES[type].nil? || TYPES[type][1].empty?
-            [ type ]
-          else
-            TYPES[type][1].map {|t| root_types t }.flatten
+        def most_specific_type(*candidates)
+          candidates.compact.uniq.reduce do |type, candidate|
+            Marcel::Magic.child?(candidate, type) ? candidate : type
           end
         end
     end