format_parser 0.24.2 → 0.25.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b680c35747790df90503edc5cb7ddda0d8929ab47c945fe6c13f5fa4319ba747
-  data.tar.gz: e8cf15c34f0422a99f3e09b30ab7ca50d54c17f2933762414323f34f06100260
+  metadata.gz: 379af5330f9b9521b278e5fe54821398ea2a5a58d4ac9881bcc5f30021446c2a
+  data.tar.gz: 71da3110186c0c8fce731fc2adb05fbcbcc829ab9c6fe67b4934dc8d69fa093c
 SHA512:
-  metadata.gz: 658e3d789e95c20b7a30e4a4c0cdb37fc186b0b696d8bfa1fd7b7b500bb375dfc0dc6873f908e20c45e871ac3831231adad3589457073bdf13697c79677b450f
-  data.tar.gz: 669af5c03327b8e048cee8401ac340b77b5bb990d08b4786c402451a092fdbea1d4a106a6404a6ac711baed2171eced775b37e5e5979e130fea2e833380e7598
+  metadata.gz: 5a9a99547baa58e3e693c8e24cc84af0d1e6598403dbed9473b885531e7c067b51c5aac4cc411ddc3f7d114b7987b470eb81554422553e6b346fc42b98a50789
+  data.tar.gz: 851b0c4fad434140e641077c01e6d46f463c8aab7b85d35a85ba0729c2913bd978a35e7ab0608d4cb8d5e2e2f13761a00078b98948290c3b3203953a9cba7c03

data/.travis.yml

@@ -2,8 +2,9 @@ rvm:
 - 2.2.10
 - 2.3.8
 - 2.4.9
-- 2.5.7
-- 2.6.5
+- 2.5.8
+- 2.6.6
+- 2.7.2
 - jruby
 sudo: false
 cache: bundler

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 0.25.4
+* MP3: Fix MP3Parser to return nil for TIFF files
+* Add support to ruby 2.7
+
+## 0.25.3
+* MP3: Fix parser to not skip the first bytes if it's not an ID3 header
+
+## 0.25.2
+* Hotfix Moov parser
+
+## 0.25.1
+* MOV: Fix error "negative length"
+* MOV: Fix reading dimensions in multi-track files
+* MP3: Fix parse of the Xing header to not raise errors
+
+## 0.25.0
+* MP3: add suport to id3 v2.4.x
+* JPEG: Update gem exifr to 1.3.8 to fix a bug
+
 ## 0.24.2
 * Update gem id3tag to 0.14.0 to fix MP3 issues
 

data/CONTRIBUTING.md

@@ -83,32 +83,59 @@ of software. Ideally, this file is going to be something you have produced yours
 and you are permitted to share under the MIT license provisions.
 
 When writing a parser, please try to ensure it returns a usable result as soon as possible,
-or no result as soon as possible (once you know the file is not fit for your specific parser).
+or `nil` as soon as possible (once you know the file is not fit for your specific parser).
 Bear in mind that we enforce read budgets per-parser, so you will not be allowed to perform
 too many reads, or perform reads which are too large.
 
-In order to create new parsers, it is recommended to make a well-named class with an instance method `call`.
+In order to create new parsers, make a well-named class with an instance method `call`,
+and to register a single instance of that class as the parser - so that only one object needs to be stored
+in memory when parsing multiple inputs. In that case your object must be **thread-safe and stateless** - this
+is really important since FormatParser is thread-safe and multiple parsing procedures may be in progress
+concurrently against the same parser object. You can also create a Proc if your parser is fairly trivial.
 
-`call` accepts the IO-ish object as an argument, parses data that it reads from it,
-and then returns the metadata for the file (if it could recover any) or `nil` if it couldn't. All files pass
-through all parsers by default, so if you are dealing with a file that is not "your" format - return `nil` from
-your method or `break` your Proc as early as possible. A blank `return` works fine too.
+If it will be difficult to have your parser thread-safe you can register your class itself as
+the parser and define the `self.call` method to parse using a fresh instance every time, allowing
+object-level state:
+
+```ruby
+class MyParser
+  def self.call(io)
+    new.call(io)
+  end
+
+  def call(io)
+    @state = ...
+  end
+```
+
+`call` accepts a single argument - an IO-ish object which is guaranteed to respond to the same methods as the
+ones defined in `IOConstraint` - that is, it is a strict subset of a standard Ruby IO object. *All reads from
+this IO object are guaranteed to be returned in binary encoding.* The IO will be at offset of 0 when your parsing
+proc receives it and there will be no concurrent calls to that object until your proc returns.
 
-The IO will at the minimum support the subset of the IO API defined in `IOConstraint`
+Your parsing procedure may read from this IO object, and should return either a `Result`-like object with
+the file metadata (if it could recover any) or `nil` if it couldn't. All files pass
+through all parsers by default, so if you are dealing with a file that is not "your" format - return `nil` from
+your method or `break` your Proc as early as possible. A blank `return` works fine too as it actually returns `nil`.
 
-Your parser has to be registered using `FormatParser.register_parser` with the information on the formats
-and file natures it provides.
+Your parser then needs to be registered using `FormatParser.register_parser` with the information on the formats
+and file natures it provides. This allows FormatParser to skip your parser if, say, the user only want to parse for
+`:image` nature files but your parser parses `:audio`.
 
-Down below you can find the most basic parser implementation:
+Down below you can find the most basic parser implementation which parses an imaginary `IMGA` file format:
 
 ```ruby
 MyParser = ->(io) {
-  # ... do some parsing with `io`
+  # ... Read the magic bytes from the start of IO - the IO is
+  # guaranteed to be fed to you at offset 0, start-of-file.
   magic_bytes = io.read(4)
+
   # breaking the block returns `nil` to the caller signaling "no match"
   break if magic_bytes != 'IMGA'
 
+  # Our file format stores the width and height as 2 32-bit unsigned integers
   parsed_witdh, parsed_height = io.read(8).unpack('VV')
+
   # ...and return the FileInformation::Image object with the metadata.
   FormatParser::Image.new(
     format: :imga,
@@ -135,8 +162,8 @@ class MyParser
     # ... do some parsing with `io`
     # The instance will be discarded after parsing, so using instance variables
     # is permitted - they are not shared between calls to `call`
-    @magic_bytes = io.read(4)
-    break if @magic_bytes != 'IMGA'
+    magic_bytes = io.read(4)
+    break if magic_bytes != 'IMGA'
     parsed_witdh, parsed_height = io.read(8).unpack('VV')
     FormatParser::Image.new(
       format: :imga,
@@ -145,23 +172,33 @@ class MyParser
     )
   end
 
-  FormatParser.register_parser self, natures: :image, formats: :bmp
+  # Note that we register an instance of the class, not the class. It is the
+  # instance that responds to `call()` and we can do this because our object
+  # is stateless.
+  FormatParser.register_parser new, natures: :image, formats: :bmp
 end
 ```
 
-### Calling convention for preparing parsers
+If your parser supports file types which have a known filename extension, you can add a method to it called `likely_match?`,
+add this method on the object you register itself. For example, for the ZIP parser we use:
+
+```ruby
+  def likely_match?(filename)
+    filename =~ /\.(zip|docx|keynote|numbers|pptx|xlsx)$/i
+  end
+```
 
-A parser that gets registered using `register_parser` must be either:
+If your parser matches the filename it is going to be applied *earlier*, saving time. Since most FormatParser users are
+likely to only want the first result of the parsing, the sooner your parser gets applied - the sooner you can return the result,
+avoiding unnecessary reads.
 
-1) An object that can be `call()`-ed itself, with an argument that conforms to `IOConstraint`
-2) An object that responds to `new` and returns something that can be `call()`-ed with with an argument that conforms to `IOConstraint`.
+### Calling convention for preparing parsers
 
-The second opton is recommended  for most cases.
+A parser that gets registered using `register_parser` must be an object that can be `call()`-ed, with an argument that conforms to `IOConstraint`
 
 FormatParser is made to be used in threaded environments, and if you use instance variables
-you need your parser to be isolated from it's siblings in other threads - therefore you can pass
-a Class on registration to have your parser instantiated for each `call()`, anew.
-
+you need your parser to be isolated from it's siblings in other threads - create a copy for one-off use inside
+your `call` method.
 
 ## Pull requests
 

data/format_parser.gemspec

@@ -31,7 +31,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'ks', '~> 0.0'
-  spec.add_dependency 'exifr', '~> 1', '>= 1.3.7'
+  spec.add_dependency 'exifr', '~> 1', '>= 1.3.8'
   spec.add_dependency 'id3tag', '~> 0.14'
   spec.add_dependency 'faraday', '~> 0.13'
   spec.add_dependency 'measurometer', '~> 1'

data/lib/format_parser.rb

@@ -36,7 +36,7 @@ module FormatParser
   # Register a parser object to be used to perform file format detection. Each parser FormatParser
   # provides out of the box registers itself using this method.
   #
-  # @param callable_or_responding_to_new[#call, #new] an object that either responds to #new or to #call
+  # @param callable_parser[#call] an object that responds to #call for parsing an IO
   # @param formats[Array<Symbol>] file formats that the parser provides
   # @param natures[Array<Symbol>] file natures that the parser provides
   # @param priority[Integer] whether the parser has to be applied first or later. Parsers that offer the safest
@@ -45,39 +45,39 @@ module FormatParser
   #   with a lower priority value will be applied first, and if a single result is requested, will also return
   #   first.
   # @return void
-  def self.register_parser(callable_or_responding_to_new, formats:, natures:, priority: LEAST_PRIORITY)
+  def self.register_parser(callable_parser, formats:, natures:, priority: LEAST_PRIORITY)
     parser_provided_formats = Array(formats)
     parser_provided_natures = Array(natures)
     PARSER_MUX.synchronize do
       @parsers ||= Set.new
-      @parsers << callable_or_responding_to_new
+      @parsers << callable_parser
       @parsers_per_nature ||= {}
       parser_provided_natures.each do |provided_nature|
         @parsers_per_nature[provided_nature] ||= Set.new
-        @parsers_per_nature[provided_nature] << callable_or_responding_to_new
+        @parsers_per_nature[provided_nature] << callable_parser
       end
       @parsers_per_format ||= {}
       parser_provided_formats.each do |provided_format|
         @parsers_per_format[provided_format] ||= Set.new
-        @parsers_per_format[provided_format] << callable_or_responding_to_new
+        @parsers_per_format[provided_format] << callable_parser
       end
       @parser_priorities ||= {}
-      @parser_priorities[callable_or_responding_to_new] = priority
+      @parser_priorities[callable_parser] = priority
     end
   end
 
   # Deregister a parser object (makes FormatParser forget this parser existed). Is mostly used in
   # tests, but can also be used to forcibly disable some formats completely.
   #
-  # @param callable_or_responding_to_new[#call, #new] an object that either responds to #new or to #call
+  # @param callable_parser[#==] an object that is identity-equal to any other registered parser
   # @return void
-  def self.deregister_parser(callable_or_responding_to_new)
+  def self.deregister_parser(callable_parser)
     # Used only in tests
     PARSER_MUX.synchronize do
-      (@parsers || []).delete(callable_or_responding_to_new)
-      (@parsers_per_nature || {}).values.map { |e| e.delete(callable_or_responding_to_new) }
-      (@parsers_per_format || {}).values.map { |e| e.delete(callable_or_responding_to_new) }
-      (@parser_priorities || {}).delete(callable_or_responding_to_new)
+      (@parsers || []).delete(callable_parser)
+      (@parsers_per_nature || {}).values.map { |e| e.delete(callable_parser) }
+      (@parsers_per_format || {}).values.map { |e| e.delete(callable_parser) }
+      (@parser_priorities || {}).delete(callable_parser)
     end
   end
 

data/lib/format_parser/version.rb

@@ -1,3 +1,3 @@
 module FormatParser
-  VERSION = '0.24.2'
+  VERSION = '0.25.4'
 end

data/lib/parsers/moov_parser.rb

@@ -38,14 +38,8 @@ class FormatParser::MOOVParser
     ftyp_atom = decoder.find_first_atom_by_path(atom_tree, 'ftyp')
     file_type = ftyp_atom.field_value(:major_brand)
 
-    width = nil
-    height = nil
-
     # Try to find the width and height in the tkhd
-    if tkhd = decoder.find_first_atom_by_path(atom_tree, 'moov', 'trak', 'tkhd')
-      width = tkhd.field_value(:track_width).first
-      height = tkhd.field_value(:track_height).first
-    end
+    width, height = parse_dimensions(decoder, atom_tree)
 
     # Try to find the "topmost" duration (respecting edits)
     if mdhd = decoder.find_first_atom_by_path(atom_tree, 'moov', 'mvhd')
@@ -78,6 +72,31 @@ class FormatParser::MOOVParser
     FTYP_MAP.fetch(file_type.downcase, :mov)
   end
 
+  # The dimensions are located in tkhd atom, but in some files it is necessary
+  # to get it below the video track, because it can have other tracks such as
+  # audio which does not have the dimensions.
+  # More details in https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-DontLinkElementID_147
+  #
+  # Returns [width, height] if the dimension is found
+  # Returns [nil, nil] if the dimension is not found
+  def parse_dimensions(decoder, atom_tree)
+    video_trak_atom = decoder.find_video_trak_atom(atom_tree)
+
+    tkhd = begin
+      if video_trak_atom
+        decoder.find_first_atom_by_path([video_trak_atom], 'trak', 'tkhd')
+      else
+        decoder.find_first_atom_by_path(atom_tree, 'moov', 'trak', 'tkhd')
+      end
+    end
+
+    if tkhd
+      [tkhd.field_value(:track_width).first, tkhd.field_value(:track_height).first]
+    else
+      [nil, nil]
+    end
+  end
+
   # An MPEG4/MOV/M4A will start with the "ftyp" atom. The atom must have a length
   # of at least 8 (to accomodate the atom size and the atom type itself) plus the major
   # and minor version fields. If we cannot find it we can be certain this is not our file.

data/lib/parsers/moov_parser/decoder.rb

@@ -1,6 +1,7 @@
 # Handles decoding of MOV/MPEG4 atoms/boxes in a stream. Will recursively
 # read atoms and parse their data fields if applicable. Also contains
 # a few utility functions for finding atoms in a list etc.
+# To know more about Atoms: https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html
 class FormatParser::MOOVParser::Decoder
   include FormatParser::IOUtils
 
@@ -47,6 +48,34 @@ class FormatParser::MOOVParser::Decoder
     find_first_atom_by_path(requisite.children || [], *atom_types)
   end
 
+  def find_atoms_by_path(atoms, atom_types)
+    type_to_find = atom_types.shift
+    requisites = atoms.select { |e| e.atom_type == type_to_find }
+
+    # Return if we found our match
+    return requisites if atom_types.empty?
+
+    # Return nil if we didn't find the match at this nesting level
+    return unless requisites
+
+    # ...otherwise drill further down
+    find_atoms_by_path(requisites.flat_map(&:children).compact || [], atom_types)
+  end
+
+  # A file can have multiple tracks. To identify the type it is necessary to check
+  # the fields `omponent_subtype` in hdlr atom under the trak atom
+  # More details in https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-DontLinkElementID_147
+  def find_video_trak_atom(atoms)
+    trak_atoms = find_atoms_by_path(atoms, ['moov', 'trak'])
+
+    return if trak_atoms.empty?
+
+    trak_atoms.find do |trak_atom|
+      hdlr_atom = find_first_atom_by_path([trak_atom], 'trak', 'mdia', 'hdlr')
+      hdlr_atom.atom_fields[:component_type] == 'mhlr' && hdlr_atom.atom_fields[:component_subtype] == 'vide'
+    end
+  end
+
   def parse_ftyp_atom(io, atom_size)
     # Subtract 8 for the atom_size+atom_type,
     # and 8 once more for the major_brand and minor_version. The remaining
@@ -194,6 +223,8 @@ class FormatParser::MOOVParser::Decoder
   end
 
   def parse_meta_atom(io, atom_size)
+    return if atom_size == 0 # this atom can be empty
+
     parse_hdlr_atom(io, atom_size)
   end
 

data/lib/parsers/mp3_parser.rb

@@ -29,6 +29,10 @@ class FormatParser::MP3Parser
   ZIP_LOCAL_ENTRY_SIGNATURE = "PK\x03\x04\x14\x00".b
   PNG_HEADER_BYTES = [137, 80, 78, 71, 13, 10, 26, 10].pack('C*')
 
+  MAGIC_LE = [0x49, 0x49, 0x2A, 0x0].pack('C4')
+  MAGIC_BE = [0x4D, 0x4D, 0x0, 0x2A].pack('C4')
+  TIFF_HEADER_BYTES = [MAGIC_LE, MAGIC_BE]
+
   # Wraps the Tag object returned by ID3Tag in such
   # a way that a usable JSON representation gets
   # returned
@@ -68,11 +72,16 @@ class FormatParser::MP3Parser
     return if header.start_with?(ZIP_LOCAL_ENTRY_SIGNATURE)
     return if header.start_with?(PNG_HEADER_BYTES)
 
+    io.seek(0)
+    return if TIFF_HEADER_BYTES.include?(safe_read(io, 4))
+
     # Read all the ID3 tags (or at least attempt to)
     io.seek(0)
     id3v1 = ID3Extraction.attempt_id3_v1_extraction(io)
     tags = [id3v1, ID3Extraction.attempt_id3_v2_extraction(io)].compact
 
+    io.seek(0) if tags.empty?
+
     # Compute how many bytes are occupied by the actual MPEG frames
     ignore_bytes_at_tail = id3v1 ? 128 : 0
     ignore_bytes_at_head = io.pos
@@ -249,16 +258,16 @@ class FormatParser::MP3Parser
     io.seek(xing_offset + 4) # Include the length of "Xing" itself
 
     # https://www.codeproject.com/Articles/8295/MPEG-Audio-Frame-Header#XINGHeader
-    header_flags, _ = io.read(4).unpack('s>s>')
+    header_flags, _ = io.read(4).unpack('i>')
     frames = byte_count = toc = vbr_scale = nil
 
-    frames = io.read(4).unpack('N1').first if header_flags & 1 # FRAMES FLAG
+    frames = io.read(4).unpack('N1').first if header_flags & 1 != 0   # FRAMES FLAG
 
-    byte_count = io.read(4).unpack('N1').first if header_flags & 2 # BYTES FLAG
+    byte_count = io.read(4).unpack('N1').first if header_flags & 2 != 0   # BYTES FLAG
 
-    toc = io.read(100).unpack('C100') if header_flags & 4 # TOC FLAG
+    toc = io.read(100).unpack('C100') if header_flags & 4 != 0   # TOC FLAG
 
-    vbr_scale = io.read(4).unpack('N1').first if header_flags & 8 # VBR SCALE FLAG
+    vbr_scale = io.read(4).unpack('N1').first if header_flags & 8 != 0   # VBR SCALE FLAG
 
     VBRHeader.new(frames: frames, byte_count: byte_count, toc_entries: toc, vbr_scale: vbr_scale)
   end

data/lib/parsers/mp3_parser/id3_extraction.rb

@@ -1,6 +1,8 @@
 module FormatParser::MP3Parser::ID3Extraction
   ID3V1_TAG_SIZE_BYTES = 128
-  ID3V2_TAG_VERSIONS = ["\x43\x00".b, "\x03\x00".b, "\x02\x00".b]
+  # it supports 2.4.x, 2.3.x, 2.2.x which are supported by the gem id3tag
+  # see https://id3.org/Developer%20Information for more details of each version
+  ID3V2_MINOR_TAG_VERSIONS = [2, 3, 4]
   MAX_SIZE_FOR_ID3V2 = 1 * 1024 * 1024
 
   extend FormatParser::IOUtils
@@ -22,7 +24,7 @@ module FormatParser::MP3Parser::ID3Extraction
     io.seek(0) # Only support header ID3v2
     header = parse_id3_v2_header(io)
     return unless header[:tag] == 'ID3' && header[:size] > 0
-    return unless ID3V2_TAG_VERSIONS.include?(header[:version])
+    return unless ID3V2_MINOR_TAG_VERSIONS.include?(header[:version].unpack('C').first)
 
     id3_tag_size = io.pos + header[:size]
 

data/lib/parsers/tiff_parser.rb

@@ -4,6 +4,7 @@ class FormatParser::TIFFParser
 
   MAGIC_LE = [0x49, 0x49, 0x2A, 0x0].pack('C4')
   MAGIC_BE = [0x4D, 0x4D, 0x0, 0x2A].pack('C4')
+  HEADER_BYTES = [MAGIC_LE, MAGIC_BE]
 
   def likely_match?(filename)
     filename =~ /\.tiff?$/i
@@ -12,7 +13,7 @@ class FormatParser::TIFFParser
   def call(io)
     io = FormatParser::IOConstraint.new(io)
 
-    return unless [MAGIC_LE, MAGIC_BE].include?(safe_read(io, 4))
+    return unless HEADER_BYTES.include?(safe_read(io, 4))
     io.seek(io.pos + 2) # Skip over the offset of the IFD, EXIFR will re-read it anyway
     return if cr2?(io)
 

data/spec/parsers/moov_parser_spec.rb

@@ -108,4 +108,24 @@ describe FormatParser::MOOVParser do
   it 'provides filename hints' do
     expect(subject).to be_likely_match('file.m4v')
   end
+
+  it 'reads correctly the video dimensions' do
+    mov_path = fixtures_dir + '/MOOV/MOV/Test_Dimensions.mov'
+
+    result = subject.call(File.open(mov_path, 'rb'))
+
+    expect(result).not_to be_nil
+    expect(result.nature).to eq(:video)
+    expect(result.format).to eq(:mov)
+    expect(result.width_px).to eq(640)
+    expect(result.height_px).to eq(360)
+  end
+
+  it 'does not raise error when a meta atom has size 0' do
+    mov_path = fixtures_dir + '/MOOV/MOV/Test_Meta_Atom_With_Size_Zero.mov'
+
+    result = subject.call(File.open(mov_path, 'rb'))
+    expect(result).not_to be_nil
+    expect(result.format).to eq(:mov)
+  end
 end

data/spec/parsers/mp3_parser_spec.rb

@@ -15,6 +15,20 @@ describe FormatParser::MP3Parser do
     expect(parsed.media_duration_seconds).to be_within(0.1).of(0.836)
   end
 
+  it 'reads the Xing header without raising errors' do
+    fpath = fixtures_dir + '/MP3/test_xing_header.mp3'
+    parsed = subject.call(File.open(fpath, 'rb'))
+
+    expect(parsed).not_to be_nil
+
+    expect(parsed.nature).to eq(:audio)
+    expect(parsed.format).to eq(:mp3)
+    expect(parsed.num_audio_channels).to eq(2)
+    expect(parsed.audio_sample_rate_hz).to eq(48000)
+    expect(parsed.intrinsics).not_to be_nil
+    expect(parsed.media_duration_seconds).to be_within(0.1).of(0.0342)
+  end
+
   it 'does not misdetect a PNG' do
     fpath = fixtures_dir + '/PNG/anim.png'
     parsed = subject.call(File.open(fpath, 'rb'))
@@ -73,7 +87,7 @@ describe FormatParser::MP3Parser do
 
     large_syncsfe_size = [ID3Tag::SynchsafeInteger.encode(more_bytes_than_permitted)].pack('N')
     prepped = StringIO.new(
-      'ID3' + "\x43\x00".b + "\x00".b + large_syncsfe_size + gunk
+      'ID3' + "\x03\x00".b + "\x00".b + large_syncsfe_size + gunk
     )
 
     expect(ID3Tag).not_to receive(:read)
@@ -144,6 +158,26 @@ describe FormatParser::MP3Parser do
     }.to raise_error(FormatParser::IOUtils::InvalidRead)
   end
 
+  it 'supports id3 v2.4.x' do
+    fpath = fixtures_dir + '/MP3/id3v24.mp3'
+
+    parsed = subject.call(File.open(fpath, 'rb'))
+
+    expect(parsed.artist). to eq('wetransfer')
+  end
+
+  it 'does not skip the first bytes if it is not a id3 tag header' do
+    fpath = fixtures_dir + '/MP3/no_id3_tags.mp3'
+
+    parsed = subject.call(File.open(fpath, 'rb'))
+
+    expect(parsed).not_to be_nil
+
+    expect(parsed.nature).to eq(:audio)
+    expect(parsed.format).to eq(:mp3)
+    expect(parsed.audio_sample_rate_hz).to eq(44100)
+  end
+
   describe '#as_json' do
     it 'converts all hash keys to string when stringify_keys: true' do
       fpath = fixtures_dir + '/MP3/Cassy.mp3'
@@ -171,4 +205,12 @@ describe FormatParser::MP3Parser do
       ).to eq([ID3Tag::Tag])
     end
   end
+
+  it 'does not recognize TIFF files as MP3' do
+    fpath = fixtures_dir + '/TIFF/test2.tif'
+
+    parsed = subject.call(File.open(fpath, 'rb'))
+
+    expect(parsed).to be_nil
+  end
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: format_parser
 version: !ruby/object:Gem::Version
-  version: 0.24.2
+  version: 0.25.4
 platform: ruby
 authors:
 - Noah Berman
 - Julik Tarkhanov
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-09-18 00:00:00.000000000 Z
+date: 2020-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ks
@@ -34,7 +34,7 @@ dependencies:
         version: '1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.7
+        version: 1.3.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -44,7 +44,7 @@ dependencies:
         version: '1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.7
+        version: 1.3.8
 - !ruby/object:Gem::Dependency
   name: id3tag
   requirement: !ruby/object:Gem::Requirement
@@ -277,7 +277,7 @@ licenses:
 - MIT (Hippocratic)
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -292,8 +292,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: A library for efficient parsing of file metadata
 test_files: []