format_parser 0.20.0 → 0.22.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e97554eb9bf6ca4a4ea76daa0f226c370f707e270931759375e9f6b72c1e7f40
-  data.tar.gz: 946767ce39eb4a96420fd52852f514333baa33ec20d256241acc7208863aaf87
+  metadata.gz: 05470fef0edec68c427b9680cf94a88a8f3286e2279b2daf13e87679324eb061
+  data.tar.gz: f65ed1d390e4e70bd34a3b01b5d54d39e4076d18ebf15fc20196c2746c86122f
 SHA512:
-  metadata.gz: 612b8b1af86329fce62e3eb035b30178485679a76516fcfe8a72c3785ef782855098609e7189559df2fd5929663d5b7ec3b7319e5e44a7048229aa13b5fc5dc9
-  data.tar.gz: 8ffa31f8c498d72eb734b15d9b5de99c44742e1651a200b5484da8e7d5bc5bba5d52092a9b8b52d7374646265be2ecd0f0b4f06bc4798b4da9a16f83d3749512
+  metadata.gz: e6e9e2d1fbfe6e813d1e0d9d2c102ce3f031fd37395cc75807ca7b527b1a2fc4a9a3c41baaf9e2cdaa601063cded92ef446ce913f2210f3d82e063126873d54d
+  data.tar.gz: 86e166b2ac754fe5d7e42e471bcaa70cd54ae0aa22da3e0f85a6223213c2bd5a284f2b53416d03656dc291898837636678dbfba2e32b179a562ea7c8b05ef0bf

data/.gitignore

@@ -54,3 +54,10 @@ Gemfile.lock
 
 # Used by RuboCop. Remote config files pulled in from inherit_from directive.
 # .rubocop-https?--*
+
+
+# OSX Files
+.DS_Store
+
+# rspec examples
+spec/examples.txt

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+## 0.22.1
+* Fix Zip parser to not raise error for invalid zip files, with an invalid central directory
+
+## 0.22.0
+* Adds option `stringify_keys: true` to #as_json methods (fix #151)
+
+## 0.21.1
+* MPEG: Ensure parsing does not inadvertently return an Integer instead of Result|nil
+* MPEG: Scan further into the MPEG file than previously (scan 32 1KB chunks)
+* MPEG: Ensure the parser does not raise an exception when there is no data to read for scanning beyound the initial header
+
+## 0.21.0
+* Adds support for MPEG video files
+
+## 0.20.1
+* Make sure EXIF results work correctly with ActiveSupport JSON encoders
+
 ## 0.20.0
 * Correctly tag the license on Rubygems as MIT (Hippocratic) for easier audit
 

data/CONTRIBUTING.md

@@ -234,4 +234,9 @@ This provision also applies to the test files you include with the changed code
 
 ## Changelog
 
-When creating a new release you must add an entry in the `CHANGELOG.md`.
+When creating a new release you must add an entry in the `CHANGELOG.md`.
+
+## Testing locally
+
+It's possible to run `exe/format_parser_inspect FILE_NAME` or `exe/format_parser_inspect FILE_URI`
+to test the new code without the necessity of installing the gem.

data/README.md

@@ -31,6 +31,7 @@ and [dimensions,](https://github.com/sstephenson/dimensions) borrowing from them
 * ZIP
 * DOCX, PPTX, XLSX
 * OGG
+* MPEG, MPG
 
 ...with [more](https://github.com/WeTransfer/format_parser/issues?q=is%3Aissue+is%3Aopen+label%3Aformats) on the way!
 
@@ -74,6 +75,17 @@ img_info = FormatParser.parse(File.open("myimage.jpg", "rb"))
 JSON.pretty_generate(img_info) #=> ...
 ```
 
+To convert the result to a Hash or a structure suitable for JSON serialization
+
+```ruby
+img_info = FormatParser.parse(File.open("myimage.jpg", "rb"))
+img_info.as_json
+
+# it's also possible to convert all keys to string
+img_info.as_json(stringify_keys: true)
+```
+
+
 ## Creating your own parsers
 
 See the [section on writing parsers in CONTRIBUTING.md](CONTRIBUTING.md#so-you-want-to-contribute-a-new-parser)
@@ -173,6 +185,10 @@ Unless specified otherwise in this section the fixture files are MIT licensed an
 ### .docx
 - The .docx files were generated by the project maintainers
 
+### .mpg and .mpeg
+- The files (video 1 to 4) were downloaded from https://standaloneinstaller.com/blog/big-list-of-sample-videos-for-testers-124.html.
+- Video 5 was downloaded from https://archive.org/details/ligouHDR-HC1_sample1.
+
 ### JPEG examples of EXIF  orientation
 - Downloaded from Unspash (and thus freely avaliable) - https://unsplash.com/license and have then been
   manipulated using the [https://github.com/recurser/exif-orientation-examples](exif-orientation-examples)
@@ -183,7 +199,7 @@ Unless specified otherwise in this section the fixture files are MIT licensed an
 
 ## Copyright
 
-Copyright (c) 2019 WeTransfer. 
+Copyright (c) 2020 WeTransfer.
 
 `format_parser` is distributed under the conditions of the [Hippocratic License](https://firstdonoharm.dev/version/1/2/license.html)
   - See LICENSE.txt for further details.

data/format_parser.gemspec

@@ -39,7 +39,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rake', '~> 12'
   spec.add_development_dependency 'simplecov', '~> 0.15'
-  spec.add_development_dependency 'pry', '~> 0.11'
   spec.add_development_dependency 'yard', '~> 0.9'
   spec.add_development_dependency 'wetransfer_style', '0.5.0'
   spec.add_development_dependency 'parallel_tests'

data/lib/attributes_json.rb

@@ -15,7 +15,12 @@ module FormatParser::AttributesJSON
 
   # Implements a sane default `as_json` for an object
   # that accessors defined
-  def as_json(root: false)
+  #
+  # @param root[Bool] if true, it surrounds the result in a hash with a key
+  #  `format_parser_file_info`
+  # @param stringify_keys[Bool] if true, it transforms all the hash keys to a string.
+  #   The default value is false for backward compatibility
+  def as_json(root: false, stringify_keys: false, **)
     h = {}
     h['nature'] = nature if respond_to?(:nature) # Needed for file info structs
     methods.grep(/\w\=$/).each_with_object(h) do |attr_writer_method_name, h|
@@ -27,6 +32,9 @@ module FormatParser::AttributesJSON
       sanitized_value = _sanitize_json_value(unwrapped_attribute_value)
       h[reader_method_name] = sanitized_value
     end
+
+    h = FormatParser::HashUtils.deep_transform_keys(h, &:to_s) if stringify_keys
+
     if root
       {'format_parser_file_info' => h}
     else

data/lib/format_parser.rb

@@ -5,6 +5,7 @@ require 'measurometer'
 # top-level methods of the library.
 module FormatParser
   require_relative 'format_parser/version'
+  require_relative 'hash_utils'
   require_relative 'attributes_json'
   require_relative 'image'
   require_relative 'audio'

data/lib/format_parser/version.rb

@@ -1,3 +1,3 @@
 module FormatParser
-  VERSION = '0.20.0'
+  VERSION = '0.22.1'
 end

data/lib/hash_utils.rb

@@ -0,0 +1,19 @@
+# based on https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/hash/keys.rb#L116
+# I chose to copy this method instead of adding activesupport as a dependency
+# because we want to have the least number of dependencies
+module FormatParser
+  class HashUtils
+    def self.deep_transform_keys(object, &block)
+      case object
+      when Hash
+        object.each_with_object({}) do |(key, value), result|
+          result[yield(key)] = deep_transform_keys(value, &block)
+        end
+      when Array
+        object.map { |e| deep_transform_keys(e, &block) }
+      else
+        object
+      end
+    end
+  end
+end

data/lib/parsers/exif_parser.rb

@@ -100,17 +100,7 @@ module FormatParser::EXIFParser
     end
 
     def to_json(*maybe_coder)
-      # Let EXIF tags that come later overwrite the properties from the tags
-      # that come earlier
-      overlay = @multiple_exif_results.each_with_object({}) do |one_exif_frame, h|
-        h.merge!(one_exif_frame.to_hash)
-      end
-      # Overwrite the orientation with our custom method implementation, because
-      # it does reject 0-values.
-      overlay[:orientation] = orientation
-
-      sanitized = FormatParser::AttributesJSON._sanitize_json_value(overlay)
-      sanitized.to_json(*maybe_coder)
+      to_hash.to_json(*maybe_coder)
     end
 
     def orientation_sym
@@ -135,10 +125,27 @@ module FormatParser::EXIFParser
       0 # If none were found - the orientation is unknown
     end
 
+    # ActiveSupport will attempt to call #to_hash first, and
+    # #to_hash is a decent default implementation to have
+    def to_hash
+      # Let EXIF tags that come later overwrite the properties from the tags
+      # that come earlier
+      overlay = @multiple_exif_results.each_with_object({}) do |one_exif_frame, h|
+        h.merge!(one_exif_frame.to_hash)
+      end
+      # Overwrite the orientation with our custom method implementation, because
+      # it does reject 0-values.
+      overlay[:orientation] = orientation
+
+      FormatParser::AttributesJSON._sanitize_json_value(overlay)
+    end
+
     private
 
-    def respond_to_missing?(method_name)
-      @multiple_exif_results.last.respond_to?(method_name)
+    # respond_to_missing? accepts 2 arguments: the method name symbol
+    # and whether the method being looked up can be private or not
+    def respond_to_missing?(method_name, include_private_methods)
+      @multiple_exif_results.last.respond_to?(method_name, include_private_methods)
     end
 
     def method_missing(*a)

data/lib/parsers/mp3_parser.rb

@@ -47,10 +47,6 @@ class FormatParser::MP3Parser
         h[k] = value if value
       end
     end
-
-    def as_json(*)
-      to_h
-    end
   end
 
   def likely_match?(filename)

data/lib/parsers/mpeg_parser.rb

@@ -0,0 +1,127 @@
+
+# MPEG Headers documentation:
+# http://dvd.sourceforge.net/dvdinfo/mpeghdrs.html#seq
+# http://www.cs.columbia.edu/~delbert/docs/Dueck%20--%20MPEG-2%20Video%20Transcoding.pdf
+# Useful tool to check the file information: https://www.metadata2go.com/
+class FormatParser::MPEGParser
+  extend FormatParser::IOUtils
+
+  ASPECT_RATIOS = {
+    1 => '1:1',
+    2 => '4:3',
+    3 => '16:9',
+    4 => '2.21:1'
+  }
+
+  FRAME_RATES = {
+    1 => '23.976',
+    2 => '24',
+    3 => '25',
+    4 => '29.97',
+    5 => '30',
+    6 => '50',
+    7 => '59.94',
+    8 => '60'
+  }
+
+  PACK_HEADER_START_CODE = [0x00, 0x00, 0x01, 0xBA].pack('C*')
+  SEQUENCE_HEADER_START_CODE = [0xB3].pack('C*')
+  MAX_BLOCK_READS = 32
+  BYTES_TO_READ_PER_READ = 1024
+
+  def self.likely_match?(filename)
+    filename =~ /\.(mpg|mpeg)$/i
+  end
+
+  def self.call(io)
+    return unless matches_mpeg_header?(io)
+
+    # We are looping though the stream because there can be several sequence headers and some of them are not useful.
+    # If we detect that the header is not useful, then we look for the next one for SEEK_FOR_SEQUENCE_HEADER_TIMES_LIMIT
+    # If we reach the EOF, then the mpg is likely to be corrupted and we return nil
+    MAX_BLOCK_READS.times do
+      next unless pos = find_next_header_code_pos(io)
+      io.seek(pos + 1)
+      horizontal_size, vertical_size = parse_image_size(io)
+      ratio_code, rate_code = parse_rate_information(io)
+      if valid_aspect_ratio_code?(ratio_code) && valid_frame_rate_code?(rate_code)
+        return file_info(horizontal_size, vertical_size, ratio_code, rate_code)
+      end
+    end
+    nil # otherwise the return value of Integer#times will be returned
+  rescue FormatParser::IOUtils::InvalidRead
+    nil
+  end
+
+  def self.file_info(width_px, height_px, ratio_code, rate_code)
+    FormatParser::Video.new(
+      format: :mpg,
+      width_px: width_px,
+      height_px: height_px,
+      intrinsics: {
+        aspect_ratio: ASPECT_RATIOS.fetch(ratio_code),
+        frame_rate: FRAME_RATES.fetch(rate_code)
+      },
+    )
+  end
+
+  # The following 3 bytes after the sequence header code, gives us information about the px size
+  # 1.5 bytes (12 bits) for horizontal size and 1.5 bytes for vertical size
+  def self.parse_image_size(io)
+    image_size = convert_3_bytes_to_bits(safe_read(io, 3))
+    [read_first_12_bits(image_size), read_last_12_bits(image_size)]
+  end
+
+  # The following byte gives us information about the aspect ratio and frame rate
+  # 4 bits corresponds to the aspect ratio and 4 bits to the frame rate code
+  def self.parse_rate_information(io)
+    rate_information = safe_read(io, 1).unpack('C').first
+    [read_first_4_bits(rate_information), read_last_4_bits(rate_information)]
+  end
+
+  def self.valid_aspect_ratio_code?(ratio_code)
+    ASPECT_RATIOS.include?(ratio_code)
+  end
+
+  def self.valid_frame_rate_code?(rate_code)
+    FRAME_RATES.include?(rate_code)
+  end
+
+  # Returns the position of the next sequence package content in the stream
+  # This method will read BYTES_TO_READ_PER_TIME in each loop for a maximum amount of SEEK_FOR_SEQUENCE_HEADER_START_CODE_TIMES_LIMIT times
+  # If the package is not found, then it returns nil.
+  def self.find_next_header_code_pos(io)
+    pos_before_read = io.pos
+    bin_str = io.read(BYTES_TO_READ_PER_READ) # bin_str might be nil if we are at EOF
+    header_relative_index = bin_str && bin_str.index(SEQUENCE_HEADER_START_CODE)
+    return pos_before_read + header_relative_index if header_relative_index
+  end
+
+  # If the first 4 bytes of the stream are equal to 00 00 01 BA, the pack start code for the Pack Header, then it's an MPEG file.
+  def self.matches_mpeg_header?(io)
+    safe_read(io, 4) == PACK_HEADER_START_CODE
+  end
+
+  def self.convert_3_bytes_to_bits(bytes)
+    bytes = bytes.unpack('CCC')
+    (bytes[0] << 16) | (bytes[1] << 8) | (bytes[2])
+  end
+
+  def self.read_first_12_bits(bits)
+    bits >> 12 & 0x0fff
+  end
+
+  def self.read_last_12_bits(bits)
+    bits & 0x0fff
+  end
+
+  def self.read_first_4_bits(byte)
+    byte >> 4
+  end
+
+  def self.read_last_4_bits(byte)
+    byte & 0x0F
+  end
+
+  FormatParser.register_parser self, natures: [:video], formats: [:mpg, :mpeg]
+end

data/lib/parsers/zip_parser/file_reader.rb

@@ -18,6 +18,7 @@ class FormatParser::ZIPParser::FileReader
       'Could not find the EOCD signature in the buffer - maybe a malformed ZIP file'
     end
   end
+  InvalidCentralDirectory = Class.new(Error)
 
   C_UINT32LE = 'V'
   C_UINT16LE = 'v'
@@ -175,6 +176,8 @@ class FormatParser::ZIPParser::FileReader
     # BUT! in format_parser we avoid unbounded reads, as a matter of fact they are forbidden.
     # So we will again limit ouselves to cdir_size, and we will take cushion of 1 KB.
     central_directory_str = io.read(cdir_size + 1024)
+    raise InvalidCentralDirectory if central_directory_str.nil?
+
     central_directory_io = StringIO.new(central_directory_str)
     log do
       format(

data/spec/attributes_json_spec.rb

@@ -140,4 +140,30 @@ describe FormatParser::AttributesJSON do
       JSON.pretty_generate(object_with_attributes_module)
     }.to raise_error(/structure too deep/)
   end
+
+  it 'converts all hash keys to string when stringify_keys: true' do
+    fixture_path = fixtures_dir + '/ZIP/arch_few_entries.zip'
+    fi_io = File.open(fixture_path, 'rb')
+
+    result = FormatParser::ZIPParser.new.call(fi_io).as_json(stringify_keys: true)
+
+    result['entries'].each do |entry|
+      entry.each do |key, _value|
+        expect(key).to be_a(String)
+      end
+    end
+  end
+
+  it 'does not convert hash keys to string when stringify_keys: false' do
+    fixture_path = fixtures_dir + '/ZIP/arch_few_entries.zip'
+    fi_io = File.open(fixture_path, 'rb')
+
+    result = FormatParser::ZIPParser.new.call(fi_io).as_json
+
+    result['entries'].each do |entry|
+      entry.each do |key, _value|
+        expect(key).to be_a(Symbol)
+      end
+    end
+  end
 end

data/spec/hash_utils_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe FormatParser::HashUtils do
+  describe '.deep_transform_keys' do
+    it 'transforms all the keys in a hash' do
+      hash = { aa: 1, 'bb' => 2 }
+      result = described_class.deep_transform_keys(hash, &:to_s)
+
+      expect(result).to eq('aa' => 1, 'bb' => 2)
+    end
+
+    it 'transforms all the keys in a array of hashes' do
+      array = [{ aa: 1, bb: 2 }, { cc: 3, dd: [{c: 2, d: 3}] }]
+      result = described_class.deep_transform_keys(array, &:to_s)
+
+      expect(result).to eq(
+        [{'aa' => 1, 'bb' => 2}, {'cc' => 3, 'dd' => [{'c' => 2, 'd' => 3}]}]
+      )
+    end
+
+    it 'transforms all the keys in a hash recursively' do
+      hash = { aa: 1, bb: { cc: 22, dd: 3 } }
+      result = described_class.deep_transform_keys(hash, &:to_s)
+
+      expect(result).to eq('aa' => 1, 'bb' => { 'cc' => 22, 'dd' => 3})
+    end
+
+    it 'does nothing for an non array/hash object' do
+      object = Object.new
+      result = described_class.deep_transform_keys(object, &:to_s)
+
+      expect(result).to eq(object)
+    end
+
+    it 'returns the last value if different keys are transformed into the same one' do
+      hash = { aa: 0, 'bb' => 2, bb: 1 }
+      result = described_class.deep_transform_keys(hash, &:to_s)
+
+      expect(result).to eq('aa' => 0, 'bb' => 1)
+    end
+  end
+end

data/spec/parsers/exif_parser_spec.rb

@@ -14,6 +14,34 @@ describe FormatParser::EXIFParser do
     end
   end
 
+  describe 'EXIFStack' do
+    it 'supports respond_to? for methods it does not have' do
+      # Peculiar thing: we need to support respond_to?(:to_hash)
+      # for compatibility with ActiveSupport JSON output. When you call as_json
+      # on an object ActiveSupport implements that as_json method and will then
+      # call #as_json on the contained objects as necessary, _or_ call
+      # other methods if it thinks it is necessary.
+      #
+      # Although we _will_ be implementing to_hash specifically
+      # the respond_to_missing must be implemented correctly
+      stack = FormatParser::EXIFParser::EXIFStack.new([{}, {}])
+      expect(stack).not_to respond_to(:no_such_method__at_all)
+    end
+
+    it 'returns a Hash from #to_hash' do
+      first_fake_exif = double(orientation: 1, to_hash: {foo: 123, bar: 675})
+      second_fake_exif = double(orientation: 4, to_hash: {foo: 245})
+
+      stack = FormatParser::EXIFParser::EXIFStack.new([first_fake_exif, second_fake_exif])
+      stack_as_hash = stack.to_hash
+
+      # In this instance we DO need an actual type_check, because #to_hash
+      # is used by default type coercions in Ruby
+      expect(stack_as_hash).to be_kind_of(Hash)
+      expect(stack_as_hash).to eq(foo: 245, bar: 675, orientation: 4)
+    end
+  end
+
   it 'is able to deal with an orientation tag which a tuple value for orientation' do
     path = fixtures_dir + '/EXIF/double_orientation.exif.bin'
     exif_data = File.open(path, 'rb') do |f|

data/spec/parsers/mp3_parser_spec.rb

@@ -110,4 +110,32 @@ describe FormatParser::MP3Parser do
       subject.call(StringIO.new(''))
     }.to raise_error(FormatParser::IOUtils::InvalidRead)
   end
+
+  describe '#as_json' do
+    it 'converts all hash keys to string when stringify_keys: true' do
+      fpath = fixtures_dir + '/MP3/Cassy.mp3'
+      result = subject.call(File.open(fpath, 'rb')).as_json(stringify_keys: true)
+
+      expect(
+        result['intrinsics'].keys.map(&:class).uniq
+      ).to eq([String])
+
+      expect(
+        result['intrinsics']['id3tags'].map(&:class).uniq
+      ).to eq([ID3Tag::Tag])
+    end
+
+    it 'does not convert the hash keys to string when stringify_keys: false' do
+      fpath = fixtures_dir + '/MP3/Cassy.mp3'
+      result = subject.call(File.open(fpath, 'rb')).as_json
+
+      expect(
+        result['intrinsics'].keys.map(&:class).uniq
+      ).to eq([Symbol])
+
+      expect(
+        result['intrinsics'][:id3tags].map(&:class).uniq
+      ).to eq([ID3Tag::Tag])
+    end
+  end
 end

data/spec/parsers/mpeg_parser_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe FormatParser::MPEGParser do
+  it 'parses a first example mpg file' do
+    parse_result = described_class.call(File.open(__dir__ + '/../fixtures/MPG/video1.mpg', 'rb'))
+
+    expect(parse_result.nature).to eq(:video)
+    expect(parse_result.format).to eq(:mpg)
+    expect(parse_result.width_px).to eq(560)
+    expect(parse_result.height_px).to eq(320)
+    expect(parse_result.intrinsics[:aspect_ratio]).to eq('1:1')
+    expect(parse_result.intrinsics[:frame_rate]).to eq('30')
+  end
+
+  it 'returns a nil if it is necessary to iterate over a very large number of bytes and the requisite sequences are not detected' do
+    bytes_buffer = StringIO.new
+    bytes_buffer.write([0x00, 0x00, 0x01, 0xBA].pack('C*')) # MPEG header
+    zero_bytes = [0x00].pack('C') * (1024 * 1024 * 5)
+    bytes_buffer.write(zero_bytes)
+
+    bytes_buffer.rewind
+
+    parse_result = described_class.call(bytes_buffer)
+    expect(parse_result).to be_nil
+  end
+
+  it 'returns a nil if the IO only contains the MPEG header bytes at the start and nothing else' do
+    bytes_buffer = StringIO.new
+    bytes_buffer.write([0x00, 0x00, 0x01, 0xBA].pack('C*')) # MPEG header
+    bytes_buffer.rewind
+
+    parse_result = described_class.call(bytes_buffer)
+    expect(parse_result).to be_nil
+  end
+
+  it 'parses a file with mpeg extension' do
+    parse_result = described_class.call(File.open(__dir__ + '/../fixtures/MPG/video2.mpeg', 'rb'))
+
+    expect(parse_result.nature).to eq(:video)
+    expect(parse_result.format).to eq(:mpg)
+    expect(parse_result.width_px).to eq(720)
+    expect(parse_result.height_px).to eq(480)
+    expect(parse_result.intrinsics[:aspect_ratio]).to eq('4:3')
+    expect(parse_result.intrinsics[:frame_rate]).to eq('29.97')
+  end
+
+  it 'parses a second example mpg file' do
+    parse_result = described_class.call(File.open(__dir__ + '/../fixtures/MPG/video3.mpg', 'rb'))
+
+    expect(parse_result.nature).to eq(:video)
+    expect(parse_result.format).to eq(:mpg)
+    expect(parse_result.width_px).to eq(720)
+    expect(parse_result.height_px).to eq(496)
+    expect(parse_result.intrinsics[:aspect_ratio]).to eq('4:3')
+    expect(parse_result.intrinsics[:frame_rate]).to eq('29.97')
+  end
+
+  it 'parses a bigger mpg file' do
+    parse_result = described_class.call(File.open(__dir__ + '/../fixtures/MPG/video4.mpg', 'rb'))
+
+    expect(parse_result.nature).to eq(:video)
+    expect(parse_result.format).to eq(:mpg)
+    expect(parse_result.width_px).to eq(1920)
+    expect(parse_result.height_px).to eq(1080)
+    expect(parse_result.intrinsics[:aspect_ratio]).to eq('16:9')
+    expect(parse_result.intrinsics[:frame_rate]).to eq('29.97')
+  end
+
+  it 'parses a file with different malformed first sequence header' do
+    parse_result = described_class.call(File.open(__dir__ + '/../fixtures/MPG/video5.mpg', 'rb'))
+
+    expect(parse_result.nature).to eq(:video)
+    expect(parse_result.format).to eq(:mpg)
+    expect(parse_result.width_px).to eq(1440)
+    expect(parse_result.height_px).to eq(1080)
+    expect(parse_result.intrinsics[:aspect_ratio]).to eq('16:9')
+    expect(parse_result.intrinsics[:frame_rate]).to eq('25')
+  end
+
+  it 'parses a MP4 file' do
+    parse_result = described_class.call(File.open(__dir__ + '/../fixtures/MOOV/MP4/bmff.mp4', 'rb'))
+
+    expect(parse_result).to be_nil
+  end
+end

data/spec/parsers/zip_parser_spec.rb

@@ -103,4 +103,11 @@ describe FormatParser::ZIPParser do
     expect(first_entry.filename).to eq('Li��nia Extreme//')
     expect(first_entry.type).to eq(:directory)
   end
+
+  it 'is able to handle files with invalid central directory position' do
+    invalid_zip_path = fixtures_dir + '/ZIP/invalid_central_directory.zip'
+
+    expect { subject.call(File.open(invalid_zip_path, 'rb')) }
+      .to_not raise_error
+  end
 end

data/spec/spec_helper.rb

@@ -8,7 +8,6 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 require 'rspec'
 require 'format_parser'
-require 'pry'
 
 module SpecHelpers
   def fixtures_dir
@@ -19,6 +18,8 @@ end
 RSpec.configure do |c|
   c.include SpecHelpers
   c.extend SpecHelpers # makes fixtures_dir available for example groups too
+  # https://relishapp.com/rspec/rspec-core/docs/command-line/only-failures
+  c.example_status_persistence_file_path = 'spec/examples.txt'
 end
 
 RSpec.shared_examples 'an IO object compatible with IOConstraint' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: format_parser
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 0.22.1
 platform: ruby
 authors:
 - Noah Berman
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-13 00:00:00.000000000 Z
+date: 2020-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ks
@@ -135,20 +135,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.15'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.11'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.11'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -223,6 +209,7 @@ files:
 - lib/document.rb
 - lib/format_parser.rb
 - lib/format_parser/version.rb
+- lib/hash_utils.rb
 - lib/image.rb
 - lib/io_constraint.rb
 - lib/io_utils.rb
@@ -240,6 +227,7 @@ files:
 - lib/parsers/moov_parser/decoder.rb
 - lib/parsers/mp3_parser.rb
 - lib/parsers/mp3_parser/id3_extraction.rb
+- lib/parsers/mpeg_parser.rb
 - lib/parsers/ogg_parser.rb
 - lib/parsers/pdf_parser.rb
 - lib/parsers/png_parser.rb
@@ -259,6 +247,7 @@ files:
 - spec/file_information_spec.rb
 - spec/format_parser_inspect_spec.rb
 - spec/format_parser_spec.rb
+- spec/hash_utils_spec.rb
 - spec/io_utils_spec.rb
 - spec/parsers/aiff_parser_spec.rb
 - spec/parsers/bmp_parser_spec.rb
@@ -271,6 +260,7 @@ files:
 - spec/parsers/jpeg_parser_spec.rb
 - spec/parsers/moov_parser_spec.rb
 - spec/parsers/mp3_parser_spec.rb
+- spec/parsers/mpeg_parser_spec.rb
 - spec/parsers/ogg_parser_spec.rb
 - spec/parsers/pdf_parser_spec.rb
 - spec/parsers/png_parser_spec.rb
@@ -303,7 +293,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A library for efficient parsing of file metadata