format_parser 0.1.0

data/spec/aiff_parser_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe FormatParser::AIFFParser do
+  it 'parses an AIFF sample file' do
+    parse_result = subject.information_from_io(File.open(__dir__ + '/fixtures/AIFF/fixture.aiff', 'rb'))
+
+    expect(parse_result.file_nature).to eq(:audio)
+    expect(parse_result.file_type).to eq(:aiff)
+    expect(parse_result.media_duration_frames).to eq(46433)
+    expect(parse_result.num_audio_channels).to eq(2)
+    expect(parse_result.audio_sample_rate_hz).to be_within(0.01).of(44100)
+    expect(parse_result.media_duration_seconds).to be_within(0.01).of(1.05)
+  end
+
+  it 'parses a Logic Pro created AIFF sample file having a COMT chunk before a COMM chunk' do
+    parse_result = subject.information_from_io(File.open(__dir__ + '/fixtures/AIFF/fixture-logic-aiff.aif', 'rb'))
+
+    expect(parse_result.file_nature).to eq(:audio)
+    expect(parse_result.file_type).to eq(:aiff)
+    expect(parse_result.media_duration_frames).to eq(302400)
+    expect(parse_result.num_audio_channels).to eq(2)
+    expect(parse_result.audio_sample_rate_hz).to be_within(0.01).of(44100)
+    expect(parse_result.media_duration_seconds).to be_within(0.01).of(6.85)
+  end
+end

data/spec/care_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Care do
+  describe Care::Cache do
+    let(:source) { StringIO.new("Hello there, this is our little caching reader") }
+
+    it 'performs correct reads at various offsets' do
+      cache = Care::Cache.new(3)
+      expect(cache.byteslice(source, 0, 3)).to eq("Hel")
+      expect(cache.byteslice(source, 0, 7)).to eq("Hello t")
+      expect(cache.byteslice(source, 1, 7)).to eq("ello th")
+      expect(cache.byteslice(source, 11, 8)).to eq(", this i")
+      expect(cache.byteslice(source, 12, 12)).to eq(" this is our")
+      expect(cache.byteslice(source, 120, 12)).to be_nil
+    end
+
+    it 'can be cleared' do
+      cache = Care::Cache.new(3)
+      expect(cache.byteslice(source, 0, 3)).to eq("Hel")
+      expect(cache.instance_variable_get("@pages")).not_to be_empty
+      cache.clear
+      expect(cache.instance_variable_get("@pages")).to be_empty
+    end
+
+    it 'fits all the reads into one if the input fits into one page' do
+      expect(source).to receive(:read).at_most(2).times.and_call_original
+
+      cache = Care::Cache.new(source.size)
+
+      cache.byteslice(source, 0, 3)
+      cache.byteslice(source, 11, 8)
+      cache.byteslice(source, 190, 12)
+      cache.byteslice(source, 290, 1)
+      cache.byteslice(source, 890, 1)
+    end
+
+    it 'permits oversized reads' do
+      cache = Care::Cache.new(4)
+      expect(cache.byteslice(source, 0, 999)).to eq(source.string)
+    end
+
+    it 'returns nil with an empty input' do
+      cache = Care::Cache.new(4)
+      expect(cache.byteslice(StringIO.new(''), 0, 1)).to be_nil
+    end
+  end
+
+  describe Care::IOWrapper do
+    it 'forwards calls to read() to the Care and adjusts internal offsets' do
+      fake_cache_class = Class.new do
+        attr_reader :recorded_calls
+        def byteslice(io, at, n_bytes)
+          @recorded_calls ||= []
+          @recorded_calls << [io, at, n_bytes]
+          # Pretend reads always succeed and return the requisite number of bytes
+          "x" * n_bytes
+        end
+      end
+
+      cache_double = fake_cache_class.new
+      io_double = double('IO')
+
+      subject = Care::IOWrapper.new(io_double, cache_double)
+
+      subject.read(2)
+      subject.read(3)
+      subject.seek(11)
+      subject.read(5)
+
+      expect(cache_double.recorded_calls).to be_kind_of(Array)
+      first, second, third = *cache_double.recorded_calls
+      expect(first).to eq([io_double,  0, 2])
+      expect(second).to eq([io_double, 2, 3])
+      expect(third).to eq([io_double,  11, 5])
+    end
+  end
+end

data/spec/file_information_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe FormatParser::FileInformation do
+
+  context "File data checks" do
+    it 'succeeds with relevant attributes' do
+      result = described_class.new(file_nature: :image, file_type: :jpg, width_px: 42, height_px: 10, image_orientation: 1)
+      expect(result.file_nature).to eq(:image)
+      expect(result.file_type).to eq(:jpg)
+      expect(result.width_px).to eq(42)
+      expect(result.height_px).to eq(10)
+      expect(result.image_orientation).to eq(1)
+    end
+  end
+
+end

data/spec/format_parser_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe FormatParser do
+  it 'returns nil when trying to parse an empty IO' do
+    d = StringIO.new('')
+    expect(FormatParser.parse(d)).to be_nil
+  end
+
+  it 'returns nil when parsing an IO no parser can make sense of' do
+    d = StringIO.new(Random.new.bytes(1))
+    expect(FormatParser.parse(d)).to be_nil
+  end
+
+  describe 'with fuzzing' do
+    it "returns either a valid result or a nil for all fuzzed inputs at seed #{RSpec.configuration.seed}" do
+      r = Random.new(RSpec.configuration.seed)
+      1024.times do
+        random_blob = StringIO.new(r.bytes(512 * 1024))
+        FormatParser.parse(random_blob) # If there is an error in one of the parsers the example will raise too
+      end
+    end
+  end
+end

data/spec/io_utils_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe "IOUtils" do
+  let(:io) {File.open(fixtures_dir + '/test.jpg', 'rb')}
+  include FormatParser::IOUtils 
+
+  describe '#safe_read' do
+    it 'raises if the requested bytes are past the EOF' do
+      io.seek(268118) # Seek to the actual end of the file
+      expect {
+        safe_read(io, 10)
+      }.to raise_error(FormatParser::IOUtils::InvalidRead)
+    end
+
+    it 'raises if we ask for more bytes than are available' do
+      expect {
+        safe_read(io, 1_000_000)
+      }.to raise_error(FormatParser::IOUtils::InvalidRead)
+    end  
+  end
+
+  describe '#safe_skip' do
+    it 'raises on a negative skip byte amount' do
+      fake_io = double()
+      expect {
+        safe_skip(fake_io, -5)
+      }.to raise_error(FormatParser::IOUtils::InvalidRead)
+    end
+
+    it 'uses #pos if available on the object' do
+      fake_io = double(pos: 11)
+      expect(fake_io).to receive(:seek).with(11+5)
+      safe_skip(fake_io, 5)
+    end
+
+    it 'uses #read if no #pos is available on the object' do
+      fake_io = double()
+      expect(fake_io).to receive(:read).with(5).and_return('x' * 5)
+      safe_skip(fake_io, 5)
+    end
+  end
+end

data/spec/parsers/dpx_parser_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe FormatParser::DPXParser do
+  describe 'with Depix example files' do
+    Dir.glob(fixtures_dir + '/dpx/*.*').each do |dpx_path|
+      it "is able to parse #{File.basename(dpx_path)}" do
+        parsed = subject.information_from_io(File.open(dpx_path, 'rb'))
+
+        expect(parsed).not_to be_nil
+        expect(parsed.file_nature).to eq(:image)
+        expect(parsed.file_type).to eq(:dpx)
+
+        # If we have an error in the struct offsets these values are likely to become
+        # the maximum value of a 4-byte uint, which is way higher
+        expect(parsed.width_px).to be_kind_of(Integer)
+        expect(parsed.width_px).to be_between(0, 2048)
+        expect(parsed.height_px).to be_kind_of(Integer)
+        expect(parsed.height_px).to be_between(0, 4000)
+      end
+    end
+
+    it 'correctly reads pixel dimensions' do
+      fi = File.open(fixtures_dir + '/dpx/026_FROM_HERO_TAPE_5-3-1_MOV.0029.dpx', 'rb')
+      parsed = subject.information_from_io(fi)
+      expect(parsed.width_px).to eq(1920)
+      expect(parsed.height_px).to eq(1080)
+    end
+  end
+end

data/spec/parsers/exif_parser_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe FormatParser::EXIFParser do
+  
+  # ORIENTATIONS = [
+  #   :top_left,
+  #   :top_right,
+  #   :bottom_right,
+  #   :bottom_left,
+  #   :left_top,
+  #   :right_top,
+  #   :right_bottom,
+  #   :left_bottom
+  # ]
+
+  describe 'is able to correctly parse orientation for all the JPEG EXIF examples from FastImage' do
+    Dir.glob(fixtures_dir + '/exif-orientation-testimages/jpg/*.jpg').each do |jpeg_path|
+      filename = File.basename(jpeg_path)
+      it "is able to parse #{filename}" do
+        parser = FormatParser::EXIFParser.new(:jpeg, File.open(jpeg_path, 'rb'))
+        parser.scan_image_exif
+        expect(parser).not_to be_nil
+
+        expect(parser.orientation).to be_kind_of(Symbol)
+        # Filenames in this dir correspond with the orientation of the file
+        expect(filename.include?(parser.orientation.to_s)).to be true 
+      end
+    end
+  end
+
+  describe 'is able to correctly parse orientation for all the TIFF EXIF examples from FastImage' do
+    Dir.glob(fixtures_dir + '/exif-orientation-testimages/tiff-*/*.tif').each do |tiff_path|
+      filename = File.basename(tiff_path)
+      it "is able to parse #{filename}" do
+        parser = FormatParser::EXIFParser.new(:tiff, File.open(tiff_path, 'rb'))
+        parser.scan_image_exif
+        expect(parser).not_to be_nil
+
+        expect(parser.orientation).to be_kind_of(Symbol)
+        # Filenames in this dir correspond with the orientation of the file
+        expect(filename.include?(parser.orientation.to_s)).to be true 
+      end
+    end
+  end
+end

data/spec/parsers/gif_parser_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe FormatParser::GIFParser do
+  describe 'is able to parse all the examples from FastImage' do
+    Dir.glob(fixtures_dir + '/*.gif').each do |gif_path|
+      it "is able to parse #{File.basename(gif_path)}" do
+        parsed = subject.information_from_io(File.open(gif_path, 'rb'))
+
+        expect(parsed).not_to be_nil
+
+        expect(parsed.file_nature).to eq(:image)
+        expect(parsed.file_type).to eq(:gif)
+        expect(parsed.color_mode).to eq(:indexed)
+
+        expect(parsed.width_px).to be_kind_of(Integer)
+        expect(parsed.width_px).to be > 0
+
+        expect(parsed.height_px).to be_kind_of(Integer)
+        expect(parsed.height_px).to be > 0
+      end
+    end
+  end
+
+  describe 'is able to correctly parse our own examples' do
+    it 'is able to parse the animated GIF' do
+      gif_path = fixtures_dir + "GIF/anim.gif"
+
+      parsed = subject.information_from_io(File.open(gif_path, 'rb'))
+      expect(parsed).not_to be_nil
+
+      expect(parsed.width_px).to eq(320)
+      expect(parsed.height_px).to eq(180)
+    end
+  end
+end

data/spec/parsers/jpeg_parser_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe FormatParser::JPEGParser do
+  describe 'is able to parse all the examples from FastImage' do
+    Dir.glob(fixtures_dir + '/*.jpg').each do |jpeg_path|
+      it "is able to parse #{File.basename(jpeg_path)}" do
+        parsed = subject.information_from_io(File.open(jpeg_path, 'rb'))
+        expect(parsed).not_to be_nil
+        expect(parsed.file_nature).to eq(:image)
+        expect(parsed.file_type).to eq(:jpg)
+
+        expect(parsed.width_px).to be_kind_of(Integer)
+        expect(parsed.width_px).to be > 0
+
+        expect(parsed.height_px).to be_kind_of(Integer)
+        expect(parsed.height_px).to be > 0
+      end
+    end
+  end
+
+  describe 'is able to parse all the JPEG exif examples from FastImage' do
+    Dir.glob(fixtures_dir + '/exif-orientation-testimages/jpg/*.jpg').each do |jpeg_path|
+      it "is able to parse #{File.basename(jpeg_path)}" do
+        parsed = subject.information_from_io(File.open(jpeg_path, 'rb'))
+        expect(parsed).not_to be_nil
+
+        expect(parsed.orientation).to be_kind_of(Symbol)
+        expect(parsed.width_px).to be > 0
+
+        expect(parsed.height_px).to be_kind_of(Integer)
+        expect(parsed.height_px).to be > 0
+      end
+    end
+  end
+
+end

data/spec/parsers/png_parser_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe FormatParser::PNGParser do
+  describe 'is able to parse all the examples from FastImage' do
+    Dir.glob(fixtures_dir + '/*.png').each do |png_path|
+      it "is able to parse #{File.basename(png_path)}" do
+        parsed = subject.information_from_io(File.open(png_path, 'rb'))
+        expect(parsed).not_to be_nil
+        expect(parsed.file_nature).to eq(:image)
+        expect(parsed.file_type).to eq(:png)
+        expect(parsed.color_mode).to eq(:indexed)
+
+        expect(parsed.width_px).to be_kind_of(Integer)
+        expect(parsed.width_px).to be > 0
+
+        expect(parsed.height_px).to be_kind_of(Integer)
+        expect(parsed.height_px).to be > 0
+      end
+    end
+  end
+
+  it 'is able to parse an animated PNG' do
+    gif_path = fixtures_dir + "PNG/anim.png"
+
+    parsed = subject.information_from_io(File.open(gif_path, 'rb'))
+    expect(parsed).not_to be_nil
+
+    expect(parsed.width_px).to eq(320)
+    expect(parsed.height_px).to eq(180)
+    expect(parsed.has_multiple_frames).to eq(true)
+    expect(parsed.num_animation_or_video_frames).to eq(17)
+  end
+end

data/spec/parsers/psd_parser_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe FormatParser::PSDParser do
+  describe 'is able to parse all the examples from FastImage' do
+    Dir.glob(fixtures_dir + '/*.psd').each do |psd_path|
+      it "is able to parse #{File.basename(psd_path)}" do
+        parsed = subject.information_from_io(File.open(psd_path, 'rb'))
+
+        expect(parsed).not_to be_nil
+        expect(parsed.file_nature).to eq(:image)
+        expect(parsed.file_type).to eq(:psd)
+
+        expect(parsed.width_px).to be_kind_of(Integer)
+        expect(parsed.width_px).to be > 0
+
+        expect(parsed.height_px).to be_kind_of(Integer)
+        expect(parsed.height_px).to be > 0
+      end
+    end
+  end
+end

data/spec/parsers/tiff_parser_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe FormatParser::TIFFParser do
+  describe 'is able to parse all the examples from FastImage' do
+    Dir.glob(fixtures_dir + '/TIFF/*.tif').each do |tiff_path|
+      it "is able to parse #{File.basename(tiff_path)}" do
+        parsed = subject.information_from_io(File.open(tiff_path, 'rb'))
+
+        expect(parsed).not_to be_nil
+        expect(parsed.file_nature).to eq(:image)
+        expect(parsed.file_type).to eq(:tif)
+
+        expect(parsed.width_px).to be_kind_of(Integer)
+        expect(parsed.width_px).to be > 0
+
+        expect(parsed.height_px).to be_kind_of(Integer)
+        expect(parsed.height_px).to be > 0
+      end
+    end
+  end
+
+  describe 'is able to parse all the TIFF exif examples from FastImage' do
+    Dir.glob(fixtures_dir + '/exif-orientation-testimages/tiff-*/*.tif').each do |tiff_path|
+      it "is able to parse #{File.basename(tiff_path)}" do
+        parsed = subject.information_from_io(File.open(tiff_path, 'rb'))
+        expect(parsed).not_to be_nil
+
+        expect(parsed.orientation).to be_kind_of(Symbol)
+        expect(parsed.width_px).to be > 0
+
+        expect(parsed.height_px).to be_kind_of(Integer)
+        expect(parsed.height_px).to be > 0
+      end
+    end
+  end
+
+end

data/spec/read_limiter_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe "ReadLimiter" do
+  let(:io) { StringIO.new(Random.new.bytes(1024)) }
+
+  it 'does not enforce any limits with default arguments' do
+    reader = FormatParser::ReadLimiter.new(io)
+    2048.times { reader.seek(1) }
+    2048.times { reader.read(4) }
+  end
+
+  it 'enforces the number of seeks' do
+    reader = FormatParser::ReadLimiter.new(io, max_seeks: 4)
+    4.times { reader.seek(1) }
+    expect {
+      reader.seek(1)
+    }.to raise_error(/Seek budget exceeded/)
+  end
+
+  it 'enforces the number of reads' do
+    reader = FormatParser::ReadLimiter.new(io, max_reads: 4)
+    4.times { reader.read(1) }
+    expect {
+      reader.read(1)
+    }.to raise_error(/calls exceeded \(4 max\)/)
+  end
+
+  it 'enforces the number of bytes read' do
+    reader = FormatParser::ReadLimiter.new(io, max_bytes: 512)
+    reader.read(512)
+    expect {
+      reader.read(1)
+    }.to raise_error(/bytes budget \(512\) exceeded/)
+  end
+end