format_parser 2.2.1 → 2.4.3

data/spec/parsers/mov_parser_spec.rb

@@ -0,0 +1,90 @@
+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') { expect(result).not_to be_nil }
+        it('should have video nature') { expect(result.nature).to eq(:video) }
+        it('should have MOV video content type') { expect(result.content_type).to eq('video/quicktime') }
+        it('should have MOV video format') { expect(result.format).to eq(:mov) }
+        it('should have a non-zero height ') { expect(result.height_px).to be > 0 }
+        it('should have a non-zero width') { expect(result.width_px).to be > 0 }
+        it('should have a non-zero duration') { expect(result.media_duration_seconds).to be > 0 }
+        it('should have a non-nil frame rate') { expect(result.frame_rate).not_to be_nil }
+        it('should have intrinsics') { expect(result.intrinsics).not_to be_nil }
+      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') { expect(result).to be_nil }
+      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') { expect(result.height_px).to eq(360) }
+      it('should have the correct width') { expect(result.width_px).to eq(640) }
+      it('should have the correct duration') { expect(result.media_duration_seconds.truncate(2)).to eq(9.36) }
+      it('should have the correct frame rate') { expect(result.frame_rate).to eq(30) }
+    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') { expect(result.height_px).to eq(720) }
+      it('should have the correct width') { expect(result.width_px).to eq(1280) }
+    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') { expect(result.height_px).to eq(640) }
+      it('should have the correct width') { expect(result.width_px).to eq(360) }
+    end
+  end
+end

data/spec/parsers/mp4_parser_spec.rb

@@ -0,0 +1,114 @@
+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') { expect(result).not_to be_nil }
+        it('should have video nature') { expect(result.nature).to eq(:video) }
+        it('should have MP4 video content type') { expect(result.content_type).to eq('video/mp4') }
+        it('should have MP4 video format') { expect([:mp4, :mv4]).to include(result.format) }
+        it('should have a non-zero height ') { expect(result.height_px).to be > 0 }
+        it('should have a non-zero width') { expect(result.width_px).to be > 0 }
+        it('should have a non-zero duration') { expect(result.media_duration_seconds).to be > 0 }
+        it('should have a non-nil frame rate') { expect(result.frame_rate).not_to be_nil }
+        it('should have intrinsics') { expect(result.intrinsics).not_to be_nil }
+      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') { expect(result).not_to be_nil }
+        it('should have audio nature') { expect(result.nature).to eq(:audio) }
+        it('should have MP4 audio content type') { expect(result.content_type).to eq('audio/mp4') }
+        it('should have MP4 audio format') { expect([:m4a, :m4b, :m4p, :m4r]).to include(result.format) }
+        it('should have a non-zero duration') { expect(result.media_duration_seconds).to be > 0 }
+        it('should have intrinsics') { expect(result.intrinsics).not_to be_nil }
+      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') { expect(result).to be_nil }
+      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') { expect(result.height_px).to eq(360) }
+      it('should have the correct width') { expect(result.width_px).to eq(640) }
+      it('should have the correct duration') { expect(result.media_duration_seconds.truncate(2)).to eq(9.36) }
+      it('should have the correct frame rate') { expect(result.frame_rate).to eq(30) }
+    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') { expect(result.height_px).to eq(720) }
+      it('should have the correct width') { expect(result.width_px).to eq(1280) }
+    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') { expect(result.height_px).to eq(640) }
+      it('should have the correct width') { expect(result.width_px).to eq(360) }
+    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') { expect(result.height_px).to eq(1280) }
+      it('should have the correct width') { expect(result.width_px).to eq(1024) }
+      it('should have the correct frame rate') { expect(result.frame_rate).to eq(24) }
+    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

data/spec/parsers/rw2_parser_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe FormatParser::RW2Parser do
+  describe '#likely_match?' do
+    %w[rw2 RW2 raw RAW rwl RWL].each do |extension|
+      context "with a file with a .#{extension} extension" do
+        it "returns true" do
+          expect(subject.likely_match?("foo.#{extension}")).to be(true)
+        end
+      end
+    end
+
+    ['', 'foo', 'rw2', 'foorw2', 'foo.rw', 'foo.rw2.bar'].each do |filename|
+      context "with a file named #{filename}" do
+        it 'returns false' do
+          expect(subject.likely_match?(filename)).to be(false)
+        end
+      end
+    end
+  end
+
+  describe '#call' do
+    Dir.glob(fixtures_dir + '/RW2/*.*').sort.each do |path|
+      it "successfully parses #{path}" do
+        result = subject.call(File.open(path, 'rb'))
+
+        expect(result).not_to be_nil
+        expect(result.nature).to eq(:image)
+        expect(result.width_px).to be > 0
+        expect(result.height_px).to be > 0
+        expect(result.content_type).to eq('image/x-panasonic-raw')
+        expect(result.intrinsics).not_to be_nil
+      end
+    end
+
+    %w[ARW/RAW_SONY_A100.ARW NEF/RAW_NIKON_D1X.NEF TIFF/test.tif].each do |path|
+      it "does not parse #{path}" do
+        result = subject.call(File.open(fixtures_dir + path, 'rb'))
+        expect(result).to be_nil
+      end
+    end
+
+    it 'parses metadata correctly' do
+      file_path = fixtures_dir + '/RW2/Panasonic - DMC-G2 - 16_9.RW2'
+
+      result = subject.call(File.open(file_path, 'rb'))
+      expect(result.nature).to eq(:image)
+      expect(result.width_px).to eq(4000)
+      expect(result.height_px).to eq(2248)
+      expect(result.orientation).to eq(:top_left)
+      expect(result.display_width_px).to eq(4000)
+      expect(result.display_height_px).to eq(2248)
+      expect(result.content_type).to eq('image/x-panasonic-raw')
+      expect(result.intrinsics).not_to be_nil
+      expect(result.intrinsics[:exif]).not_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.2.1
+  version: 2.4.3
 platform: ruby
 authors:
 - Noah Berman
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-11-28 00:00:00.000000000 Z
+date: 2023-03-27 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,19 +218,23 @@ 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
 - lib/parsers/pdf_parser.rb
 - lib/parsers/png_parser.rb
 - lib/parsers/psd_parser.rb
+- lib/parsers/rw2_parser.rb
 - lib/parsers/tiff_parser.rb
 - lib/parsers/wav_parser.rb
 - lib/parsers/webp_parser.rb
@@ -253,17 +271,21 @@ 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
 - spec/parsers/pdf_parser_spec.rb
 - spec/parsers/png_parser_spec.rb
 - spec/parsers/psd_parser_spec.rb
+- spec/parsers/rw2_parser_spec.rb
 - spec/parsers/tiff_parser_spec.rb
 - spec/parsers/wav_parser_spec.rb
 - spec/parsers/webp_parser_spec.rb