format_parser 2.3.0 → 2.4.4

data/spec/parsers/mov_parser_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe FormatParser::MOVParser do
+  describe '#likely_match?' do
+    %w[mov mOv moV Mov MOv MoV MOV moov qt].each do |e|
+      context "with foo.#{e}" do
+        it 'should return true' do
+          expect(subject.likely_match?("foo.#{e}")).to eq(true)
+        end
+      end
+    end
+
+    ['', 'foo', 'mov', 'foomov', 'foo.mp4', 'foo.mov.bar'].each do |f|
+      context "with #{f}" do
+        it 'should return false' do
+          expect(subject.likely_match?(f)).to eq(false)
+        end
+      end
+    end
+  end
+
+  describe '#call' do
+    context "when magic bytes are absent" do
+      let(:io) do
+        input = [0x10].pack('N') + 'ftyp' + 'foo ' + [0x1].pack('N')
+        StringIO.new(input)
+      end
+
+      it 'should return nil' do
+        expect(subject.call(io)).to be_nil
+      end
+    end
+
+    Dir.glob(fixtures_dir + '/MOV/valid/**/*.*').sort.each do |path|
+      context "for #{path}" do
+        let(:result) { subject.call(File.open(path, 'rb')) }
+
+        it 'should not be nil' do
+          expect(result).not_to be_nil
+        end
+
+        it 'should have video nature' do
+          expect(result.nature).to eq(:video)
+        end
+
+        it 'should have MOV video content type' do
+          expect(result.content_type).to eq('video/quicktime')
+        end
+
+        it 'should have MOV video format' do
+          expect(result.format).to eq(:mov)
+        end
+
+        it 'should have a non-zero height ' do
+          expect(result.height_px).to be > 0
+        end
+
+        it 'should have a non-zero width' do
+          expect(result.width_px).to be > 0
+        end
+
+        it 'should have a non-zero duration' do
+          expect(result.media_duration_seconds).to be > 0
+        end
+
+        it 'should have a non-nil frame rate' do
+          expect(result.frame_rate).not_to be_nil
+        end
+
+        it 'should have intrinsics' do
+          expect(result.intrinsics).not_to be_nil
+        end
+      end
+    end
+
+    Dir.glob(fixtures_dir + '/MOV/invalid/**/*.*').sort.each do |path|
+      context "for #{path}" do
+        let(:result) { subject.call(File.open(path, 'rb')) }
+
+        it 'should be nil' do
+          expect(result).to be_nil
+        end
+      end
+    end
+
+    context "for a standard MOV video" do
+      let(:result) do
+        path = fixtures_dir + '/MOV/valid/standard.mov'
+        subject.call(File.open(path, 'rb'))
+      end
+
+      it 'should have the correct height' do
+        expect(result.height_px).to eq(360)
+      end
+
+      it 'should have the correct width' do
+        expect(result.width_px).to eq(640)
+      end
+
+      it 'should have the correct duration' do
+        expect(result.media_duration_seconds.truncate(2)).to eq(9.36)
+      end
+
+      it 'should have the correct frame rate' do
+        expect(result.frame_rate).to eq(30)
+      end
+    end
+
+    context "for a scaled MOV video" do
+      let(:result) do
+        path = fixtures_dir + '/MOV/valid/scaled.mov'
+        subject.call(File.open(path, 'rb'))
+      end
+
+      it 'should have the correct height' do
+        expect(result.height_px).to eq(720)
+      end
+
+      it 'should have the correct width' do
+        expect(result.width_px).to eq(1280)
+      end
+    end
+
+    context "for a rotated MOV video" do
+      let(:result) do
+        path = fixtures_dir + '/MOV/valid/rotated.mov'
+        subject.call(File.open(path, 'rb'))
+      end
+
+      it 'should have the correct height' do
+        expect(result.height_px).to eq(640)
+      end
+
+      it 'should have the correct width' do
+        expect(result.width_px).to eq(360)
+      end
+    end
+  end
+end

data/spec/parsers/mp4_parser_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+describe FormatParser::MP4Parser do
+  describe '#likely_match?' do
+    %w[mp4 mP4 Mp4 MP4 m4a m4b m4p m4r m4v].each do |e|
+      context "with foo.#{e}" do
+        it 'should return true' do
+          expect(subject.likely_match?("foo.#{e}")).to eq(true)
+        end
+      end
+    end
+
+    ['', 'foo', 'mp4', 'foomp4', 'foo.mp3', 'foo.mov', 'foo.mp4.bar'].each do |f|
+      context "with #{f}" do
+        it 'should return false' do
+          expect(subject.likely_match?(f)).to eq(false)
+        end
+      end
+    end
+  end
+
+  describe '#call' do
+    context "when magic bytes are absent" do
+      let(:io) do
+        input = [0x10].pack('N') + 'ftyp' + 'foo ' + [0x1].pack('N')
+        StringIO.new(input)
+      end
+
+      it 'should return nil' do
+        expect(subject.call(io)).to be_nil
+      end
+    end
+
+    Dir.glob(fixtures_dir + '/MP4/valid/video/*.*').sort.each do |path|
+      context "for #{path}" do
+        let(:result) { subject.call(File.open(path, 'rb')) }
+
+        it 'should not be nil' do
+          expect(result).not_to be_nil
+        end
+
+        it 'should have video nature' do
+          expect(result.nature).to eq(:video)
+        end
+
+        it 'should have MP4 video content type' do
+          expect(result.content_type).to eq('video/mp4')
+        end
+
+        it 'should have MP4 video format' do
+          expect([:mp4, :mv4]).to include(result.format)
+        end
+
+        it 'should have a non-zero height ' do
+          expect(result.height_px).to be > 0
+        end
+
+        it 'should have a non-zero width' do
+          expect(result.width_px).to be > 0
+        end
+
+        it 'should have a non-zero duration' do
+          expect(result.media_duration_seconds).to be > 0
+        end
+
+        it 'should have a non-nil frame rate' do
+          expect(result.frame_rate).not_to be_nil
+        end
+
+        it 'should have intrinsics' do
+          expect(result.intrinsics).not_to be_nil
+        end
+      end
+    end
+
+    Dir.glob(fixtures_dir + '/MP4/valid/audio/*.*').sort.each do |path|
+      context "for #{path}" do
+        let(:result) { subject.call(File.open(path, 'rb')) }
+
+        it 'should not be nil' do
+          expect(result).not_to be_nil
+        end
+
+        it 'should have audio nature' do
+          expect(result.nature).to eq(:audio)
+        end
+
+        it 'should have MP4 audio content type' do
+          expect(result.content_type).to eq('audio/mp4')
+        end
+
+        it 'should have MP4 audio format' do
+          expect([:m4a, :m4b, :m4p, :m4r]).to include(result.format)
+        end
+
+        it 'should have a non-zero duration' do
+          expect(result.media_duration_seconds).to be > 0
+        end
+
+        it 'should have intrinsics' do
+          expect(result.intrinsics).not_to be_nil
+        end
+      end
+    end
+
+    Dir.glob(fixtures_dir + '/MP4/invalid/**/*.*').sort.each do |path|
+      context "for #{path}" do
+        let(:result) { subject.call(File.open(path, 'rb')) }
+
+        it 'should be nil' do
+          expect(result).to be_nil
+        end
+      end
+    end
+
+    context "for a standard MP4 video" do
+      let(:result) do
+        path = fixtures_dir + '/MP4/valid/video/standard.mp4'
+        subject.call(File.open(path, 'rb'))
+      end
+
+      it 'should have the correct height' do
+        expect(result.height_px).to eq(360)
+      end
+
+      it 'should have the correct width' do
+        expect(result.width_px).to eq(640)
+      end
+
+      it 'should have the correct duration' do
+        expect(result.media_duration_seconds.truncate(2)).to eq(9.36)
+      end
+
+      it 'should have the correct frame rate' do
+        expect(result.frame_rate).to eq(30)
+      end
+    end
+
+    context "for a scaled MP4 video" do
+      let(:result) do
+        path = fixtures_dir + '/MP4/valid/video/scaled.mp4'
+        subject.call(File.open(path, 'rb'))
+      end
+
+      it 'should have the correct height' do
+        expect(result.height_px).to eq(720)
+      end
+
+      it 'should have the correct width' do
+        expect(result.width_px).to eq(1280)
+      end
+    end
+
+    context "for a rotated MP4 video" do
+      let(:result) do
+        path = fixtures_dir + '/MP4/valid/video/rotated.mp4'
+        subject.call(File.open(path, 'rb'))
+      end
+
+      it 'should have the correct height' do
+        expect(result.height_px).to eq(640)
+      end
+
+      it 'should have the correct width' do
+        expect(result.width_px).to eq(360)
+      end
+    end
+
+    context "for a multi-track MP4 video" do
+      let(:result) do
+        path = fixtures_dir + '/MP4/valid/video/multi-track.mp4'
+        subject.call(File.open(path, 'rb'))
+      end
+
+      it 'should have the correct height' do
+        expect(result.height_px).to eq(1280)
+      end
+
+      it 'should have the correct width' do
+        expect(result.width_px).to eq(1024)
+      end
+
+      it 'should have the correct frame rate' do
+        expect(result.frame_rate).to eq(24)
+      end
+    end
+  end
+end

data/spec/parsers/pdf_parser_spec.rb

@@ -1,19 +1,18 @@
 require 'spec_helper'
 
 describe FormatParser::PDFParser do
-  let(:parsed_pdf) {
+  def parse_pdf(pdf_filename)
     subject.call(
       File.open(
-        Pathname.new(fixtures_dir).join('PDF').join(pdf_file),
+        Pathname.new(fixtures_dir).join('PDF').join(pdf_filename),
         'rb'
       )
     )
-  }
-
-  shared_examples :behave_like_pdf do |hash|
-    let(:pdf_file) { hash.fetch(:file) }
+  end
 
-    it 'acts as a pdf' do
+  shared_examples :behave_like_pdf do |params|
+    it "#{params[:file]} acts as a pdf" do
+      parsed_pdf = parse_pdf params[:file]
       expect(parsed_pdf).not_to be_nil
       expect(parsed_pdf.nature).to eq(:document)
       expect(parsed_pdf.format).to eq(:pdf)
@@ -21,29 +20,44 @@ describe FormatParser::PDFParser do
     end
   end
 
-  describe 'a PDF file with a missing version header' do
-    let(:pdf_file) { 'not_a.pdf' }
-
-    it 'does not parse succesfully' do
-      expect(parsed_pdf).to be_nil
+  describe 'parses a PDF file' do
+    describe 'a single page file' do
+      include_examples :behave_like_pdf, file: '1_page.pdf'
     end
-  end
 
-  describe 'a PDF file with a correct header but no valid content' do
-    let(:pdf_file) { 'broken.pdf' }
+    describe 'various PDF versions' do
+      include_examples :behave_like_pdf, file: 'Lorem Ipsum PDF 1.6.pdf'
+      include_examples :behave_like_pdf, file: 'Lorem Ipsum PDF-A-1b.pdf'
+      include_examples :behave_like_pdf, file: 'Lorem Ipsum PDF-A-2b.pdf'
+      include_examples :behave_like_pdf, file: 'Lorem Ipsum PDF-A-3b.pdf'
+      include_examples :behave_like_pdf, file: 'Lorem Ipsum PDF-UA.pdf'
+      include_examples :behave_like_pdf, file: 'Lorem Ipsum Hybrid - ODF embedded.pdf'
+      include_examples :behave_like_pdf, file: 'Simple PDF 2.0 file.pdf'
+    end
 
-    pending 'does not parse succesfully'
+    describe 'complex PDF 2.0 files' do
+      include_examples :behave_like_pdf, file: 'PDF 2.0 image with BPC.pdf'
+      include_examples :behave_like_pdf, file: 'PDF 2.0 UTF-8 string and annotation.pdf'
+      include_examples :behave_like_pdf, file: 'PDF 2.0 via incremental save.pdf'
+      include_examples :behave_like_pdf, file: 'PDF 2.0 with page level output intent.pdf'
+      include_examples :behave_like_pdf, file: 'pdf20-utf8-test.pdf'
+    end
   end
 
-  describe 'exceeding the PDF read limit' do
-    let(:pdf_file) { 'read_limit.pdf' }
+  describe 'broken PDF files should not parse' do
+    it 'PDF with missing version header' do
+      parsed_pdf = parse_pdf 'not_a.pdf'
+      expect(parsed_pdf).to be_nil
+    end
 
-    pending 'does not parse succesfully'
-  end
+    it 'PDF 2.0 with offset start' do
+      parsed_pdf = parse_pdf 'PDF 2.0 with offset start.pdf'
+      expect(parsed_pdf).to be_nil
+    end
 
-  describe 'parses a PDF file' do
-    describe 'a single page file' do
-      include_examples :behave_like_pdf, file: '1_page.pdf'
+    it 'exceeds the PDF read limit' do
+      parsed_pdf = parse_pdf 'exceed_PDF_read_limit.pdf'
+      expect(parsed_pdf).to be_nil
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: format_parser
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.4.4
 platform: ruby
 authors:
 - Noah Berman
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-12 00:00:00.000000000 Z
+date: 2023-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: exifr
@@ -39,6 +39,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.14.2
+- !ruby/object:Gem::Dependency
+  name: matrix
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: measurometer
   requirement: !ruby/object:Gem::Requirement
@@ -204,13 +218,16 @@ files:
 - lib/parsers/flac_parser.rb
 - lib/parsers/gif_parser.rb
 - lib/parsers/heif_parser.rb
+- lib/parsers/iso_base_media_file_format/box.rb
 - lib/parsers/iso_base_media_file_format/decoder.rb
+- lib/parsers/iso_base_media_file_format/utils.rb
 - lib/parsers/jpeg_parser.rb
 - lib/parsers/m3u_parser.rb
-- lib/parsers/moov_parser.rb
-- lib/parsers/moov_parser/decoder.rb
+- lib/parsers/mov_parser.rb
+- lib/parsers/mov_parser/decoder.rb
 - lib/parsers/mp3_parser.rb
 - lib/parsers/mp3_parser/id3_extraction.rb
+- lib/parsers/mp4_parser.rb
 - lib/parsers/mpeg_parser.rb
 - lib/parsers/nef_parser.rb
 - lib/parsers/ogg_parser.rb
@@ -254,11 +271,14 @@ files:
 - spec/parsers/flac_parser_spec.rb
 - spec/parsers/gif_parser_spec.rb
 - spec/parsers/heif_parser_spec.rb
+- spec/parsers/iso_base_media_file_format/box_spec.rb
 - spec/parsers/iso_base_media_file_format/decoder_spec.rb
+- spec/parsers/iso_base_media_file_format/utils_spec.rb
 - spec/parsers/jpeg_parser_spec.rb
 - spec/parsers/m3u_parser_spec.rb
-- spec/parsers/moov_parser_spec.rb
+- spec/parsers/mov_parser_spec.rb
 - spec/parsers/mp3_parser_spec.rb
+- spec/parsers/mp4_parser_spec.rb
 - spec/parsers/mpeg_parser_spec.rb
 - spec/parsers/nef_parser_spec.rb
 - spec/parsers/ogg_parser_spec.rb