format_parser 0.1.7 → 0.2.0

data/lib/parsers/gif_parser.rb

@@ -1,12 +1,15 @@
 class FormatParser::GIFParser
+  include FormatParser::IOUtils
+  include FormatParser::DSL
+
   HEADERS = ['GIF87a', 'GIF89a'].map(&:b)
   NETSCAPE_AND_AUTHENTICATION_CODE = 'NETSCAPE2.0'
 
-  include FormatParser::IOUtils
+  natures :image
+  formats :gif
 
-  def information_from_io(io)
+  def call(io)
     io = FormatParser::IOConstraint.new(io)
-
     header = safe_read(io, 6)
     return unless HEADERS.include?(header)
 
@@ -38,8 +41,8 @@ class FormatParser::GIFParser
     potentially_netscape_app_header = safe_read(io, 64)
     is_animated = potentially_netscape_app_header.include?(NETSCAPE_AND_AUTHENTICATION_CODE)
 
-    FormatParser::FileInformation.image(
-      file_type: :gif,
+    FormatParser::Image.new(
+      format: :gif,
       width_px: w,
       height_px: h,
       has_multiple_frames: is_animated,

data/lib/parsers/jpeg_parser.rb

@@ -1,5 +1,6 @@
 class FormatParser::JPEGParser
   include FormatParser::IOUtils
+  include FormatParser::DSL
 
   class InvalidStructure < StandardError
   end
@@ -10,7 +11,10 @@ class FormatParser::JPEGParser
   SOS_MARKER  = 0xDA  # start of stream
   APP1_MARKER = 0xE1  # maybe EXIF
 
-  def information_from_io(io)
+  natures :image
+  formats :jpg
+
+  def call(io)
     @buf = FormatParser::IOConstraint.new(io)
     @width             = nil
     @height            = nil
@@ -50,21 +54,13 @@ class FormatParser::JPEGParser
       end
 
       # Return at the earliest possible opportunity
-      if @width && @height && @orientation
-        file_info = FormatParser::FileInformation.image(
-          file_type: :jpg,
+      if @width && @height
+        return  FormatParser::Image.new(
+          format: :jpg,
           width_px: @width,
           height_px: @height,
           orientation: @orientation
         )
-        return file_info
-      elsif @width && @height
-        file_info = FormatParser::FileInformation.image(
-          file_type: :jpg,
-          width_px: @width,
-          height_px: @height
-        )
-        return file_info
       end
     end
     nil # We could not parse anything

data/lib/parsers/moov_parser.rb

@@ -1,6 +1,6 @@
 class FormatParser::MOOVParser
   include FormatParser::IOUtils
-
+  include FormatParser::DSL
   require_relative 'moov_parser/decoder'
 
   # Maps values of the "ftyp" atom to something
@@ -12,11 +12,14 @@ class FormatParser::MOOVParser
     "m4a " => :m4a,
   }
 
+  natures :video
+  formats *FTYP_MAP.values
+
   # It is currently not documented and not particularly well-tested,
   # so not considered a public API for now
-  private_constant :Decoder 
+  private_constant :Decoder
 
-  def information_from_io(io)
+  def call(io)
     return nil unless matches_moov_definition?(io)
 
     # Now we know we are in a MOOV, so go back and parse out the atom structure.
@@ -51,9 +54,8 @@ class FormatParser::MOOVParser
       media_duration_s = duration / timescale.to_f
     end
 
-    FormatParser::FileInformation.new(
-      file_nature: :video,
-      file_type: file_type_from_moov_type(file_type),
+    FormatParser::Video.new(
+      format: format_from_moov_type(file_type),
       width_px: width,
       height_px: height,
       media_duration_seconds: media_duration_s,
@@ -63,7 +65,7 @@ class FormatParser::MOOVParser
 
   private
 
-  def file_type_from_moov_type(file_type)
+  def format_from_moov_type(file_type)
     FTYP_MAP.fetch(file_type, :mov)
   end
 

data/lib/parsers/mp3_parser.rb

@@ -23,7 +23,11 @@ class FormatParser::MP3Parser
   # Default frame size for mp3
   SAMPLES_PER_FRAME = 1152
 
-  def information_from_io(io)
+  include FormatParser::DSL
+  natures :audio
+  formats :mp3
+
+  def call(io)
     # Read the last 128 bytes which might contain ID3v1
     id3_v1 = ID3V1.attempt_id3_v1_extraction(io)
     # Read the header bytes that might contain ID3v1
@@ -42,9 +46,8 @@ class FormatParser::MP3Parser
 
     first_frame = initial_frames.first
 
-    file_info = FormatParser::FileInformation.new(
-      file_nature: :audio,
-      file_type: :mp3,
+    file_info = FormatParser::Audio.new(
+      format: :mp3,
       num_audio_channels: first_frame.channels,
       audio_sample_rate_hz: first_frame.sample_rate,
       # media_duration_frames is omitted because the frames

data/lib/parsers/png_parser.rb

@@ -1,4 +1,10 @@
 class FormatParser::PNGParser
+  include FormatParser::IOUtils
+  include FormatParser::DSL
+
+  natures :image
+  formats :png
+
   PNG_HEADER_BYTES = [137, 80, 78, 71, 13, 10, 26, 10].pack('C*')
   COLOR_TYPES = {
     0 => :grayscale,
@@ -13,15 +19,13 @@ class FormatParser::PNGParser
     6 => true,
   }
 
-  include FormatParser::IOUtils
 
   def chunk_length_and_type(io)
     safe_read(io, 8).unpack("Na4")
   end
 
-  def information_from_io(io)
+  def call(io)
     io = FormatParser::IOConstraint.new(io)
-
     magic_bytes = safe_read(io, PNG_HEADER_BYTES.bytesize)
     return unless magic_bytes == PNG_HEADER_BYTES
 
@@ -66,8 +70,8 @@ class FormatParser::PNGParser
       num_frames, loop_n_times = safe_read(io, 8).unpack('NN')
     end
 
-    FormatParser::FileInformation.image(
-      file_type: :png,
+    FormatParser::Image.new(
+      format: :png,
       width_px: w,
       height_px: h,
       has_transparency: has_transparency,

data/lib/parsers/psd_parser.rb

@@ -1,10 +1,13 @@
 class FormatParser::PSDParser
-  PSD_HEADER = [0x38, 0x42, 0x50, 0x53]
   include FormatParser::IOUtils
+  include FormatParser::DSL
 
-  def information_from_io(io)
-    io = FormatParser::IOConstraint.new(io)
+  PSD_HEADER = [0x38, 0x42, 0x50, 0x53]
+  natures :image
+  formats :psd
 
+  def call(io)
+    io = FormatParser::IOConstraint.new(io)
     magic_bytes = safe_read(io, 4).unpack("C4")
 
     return unless magic_bytes == PSD_HEADER
@@ -12,8 +15,8 @@ class FormatParser::PSDParser
     # We can be reasonably certain this is a PSD so we grab the height
     # and width bytes
     w,h = safe_read(io, 22).unpack("x10N2")
-    FormatParser::FileInformation.image(
-      file_type: :psd,
+    FormatParser::Image.new(
+      format: :psd,
       width_px: w,
       height_px: h,
     )

data/lib/parsers/tiff_parser.rb

@@ -1,34 +1,30 @@
 class FormatParser::TIFFParser
+  include FormatParser::IOUtils
+  include FormatParser::DSL
+
   LITTLE_ENDIAN_TIFF_HEADER_BYTES = [0x49, 0x49, 0x2A, 0x0]
   BIG_ENDIAN_TIFF_HEADER_BYTES = [0x4D, 0x4D, 0x0, 0x2A]
   WIDTH_TAG  = 0x100
   HEIGHT_TAG = 0x101
 
-  include FormatParser::IOUtils
+  natures :image
+  formats :tif
 
-  def information_from_io(io)
+  def call(io)
     io = FormatParser::IOConstraint.new(io)
-
     magic_bytes = safe_read(io, 4).unpack("C4")
     endianness = scan_tiff_endianness(magic_bytes)
     return unless endianness
     w, h = read_tiff_by_endianness(io, endianness)
     scanner = FormatParser::EXIFParser.new(:tiff, io)
     scanner.scan_image_exif
-    if scanner.orientation
-      FormatParser::FileInformation.image(
-        file_type: :tif,
+    return FormatParser::Image.new(
+        format: :tif,
         width_px: w,
         height_px: h,
+        # might be nil if EXIF metadata wasn't found
         orientation: scanner.orientation
       )
-    else
-      FormatParser::FileInformation.image(
-        file_type: :tif,
-        width_px: w,
-        height_px: h
-      )
-    end
   end
 
   # TIFFs can be either big or little endian, so we check here

data/lib/parsers/wav_parser.rb

@@ -1,9 +1,11 @@
 class FormatParser::WAVParser
   include FormatParser::IOUtils
+  include FormatParser::DSL
 
-  def information_from_io(io)
-    io.seek(0)
+  natures :audio
+  formats :wav
 
+  def call(io)
     # Read the RIFF header. Chunk descriptor should be RIFF, the size should 
     # contain the size of the entire file in bytes minus 8 bytes for the 
     # two fields not included in this count: chunk_id and size.
@@ -88,9 +90,8 @@ class FormatParser::WAVParser
   def file_info(fmt_data, sample_frames)
     return unless fmt_data[:sample_rate] > 0
     duration_in_seconds = sample_frames / fmt_data[:sample_rate].to_f
-    FormatParser::FileInformation.new(
-      file_nature: :audio,
-      file_type: :wav,
+    FormatParser::Audio.new(
+      format: :wav,
       num_audio_channels: fmt_data[:channels],
       audio_sample_rate_hz: fmt_data[:sample_rate],
       media_duration_frames: sample_frames,

data/lib/video.rb

@@ -0,0 +1,33 @@
+module FormatParser
+  class Video
+    NATURE = :video
+
+    attr_accessor :width_px
+
+    attr_accessor :height_px
+
+    # Type of the file (e.g :mp3)
+    attr_accessor :format
+
+    # Duration of the media object (be it audio or video) in seconds,
+    # as a Float
+    attr_accessor :media_duration_seconds
+
+    # Duration of the media object in addressable frames or samples,
+    # as an Integer
+    attr_accessor :media_duration_frames
+
+    # If a parser wants to provide any extra information to the caller
+    # it can be placed here
+    attr_accessor :intrinsics
+
+    # Only permits assignments via defined accessors
+    def initialize(**attributes)
+      attributes.map { |(k, v)| public_send("#{k}=", v) }
+    end
+
+    def nature
+      NATURE
+    end
+  end
+end

data/spec/aiff_parser_spec.rb

@@ -2,10 +2,10 @@ 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'))
+    parse_result = subject.call(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.nature).to eq(:audio)
+    expect(parse_result.format).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)
@@ -13,10 +13,10 @@ describe FormatParser::AIFFParser do
   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'))
+    parse_result = subject.call(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.nature).to eq(:audio)
+    expect(parse_result.format).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)

data/spec/file_information_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
-describe FormatParser::FileInformation do
+describe FormatParser::Image 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)
+      result = described_class.new(format: :jpg, width_px: 42, height_px: 10, image_orientation: 1)
+      expect(result.nature).to eq(:image)
+      expect(result.format).to eq(:jpg)
       expect(result.width_px).to eq(42)
       expect(result.height_px).to eq(10)
       expect(result.image_orientation).to eq(1)

data/spec/format_parser_spec.rb

@@ -3,12 +3,12 @@ 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
+    expect(FormatParser.parse(d)).to be_empty
   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
+    expect(FormatParser.parse(d)).to be_empty
   end
 
   describe 'with fuzzing' do
@@ -21,6 +21,34 @@ describe FormatParser do
     end
   end
 
+  describe 'multiple values return' do
+    let(:blob) { StringIO.new(Random.new.bytes(512 * 1024)) }
+    let(:audio) { FormatParser::Audio.new(format: :aiff, num_audio_channels: 1) }
+    let(:image) { FormatParser::Image.new(format: :dpx, width_px: 1, height_px: 1) }
+
+    context '#parse called without any option' do
+      before do
+        expect_any_instance_of(FormatParser::AIFFParser).to receive(:call).and_return(audio)
+        expect_any_instance_of(FormatParser::DPXParser).to receive(:call).and_return(image)
+      end
+
+      subject { FormatParser.parse(blob) }
+
+      it { is_expected.to include(image) }
+      it { is_expected.to include(audio) }
+    end
+
+    context '#parse called with hash options' do
+      before do
+        expect_any_instance_of(FormatParser::DPXParser).to receive(:call).and_return(image)
+      end
+
+      subject { FormatParser.parse(blob, formats: [:dpx], returns: :one) }
+
+      it { is_expected.to eq(image) }
+    end
+  end
+
   describe 'when parsing fixtures' do
     Dir.glob(fixtures_dir + '/**/*.*').sort.each do |fixture_path|
       it "parses #{fixture_path} without raising any errors" do

data/spec/parsers/dpx_parser_spec.rb

@@ -4,11 +4,11 @@ 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'))
+        parsed = subject.call(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)
+        expect(parsed.nature).to eq(:image)
+        expect(parsed.format).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
@@ -21,7 +21,7 @@ describe FormatParser::DPXParser do
 
     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)
+      parsed = subject.call(fi)
       expect(parsed.width_px).to eq(1920)
       expect(parsed.height_px).to eq(1080)
     end

data/spec/parsers/fdx_parser_spec.rb

@@ -4,19 +4,19 @@ describe FormatParser::FDXParser do
   describe 'is able to parse the sample file' do
     Dir.glob(fixtures_dir + '/XML/*.fdx').each do |fdx_path|
       it "is able to parse #{File.basename(fdx_path)}" do
-        parsed = subject.information_from_io(File.open(fdx_path, 'rb'))
+        parsed = subject.call(File.open(fdx_path, 'rb'))
         expect(parsed).not_to be_nil
-        expect(parsed.file_nature).to eq(:document)
-        expect(parsed.file_type).to eq(:fdx)
+        expect(parsed.nature).to eq(:document)
+        expect(parsed.format).to eq(:fdx)
         expect(parsed.document_type).to eq(:script)
       end
     end
   end
-  
+
   describe 'does not parse other XML files as FDX' do
     Dir.glob(fixtures_dir + '/*.svg').each do |svg_path|
       it 'returns nil when parsing a non-fdx xml file' do
-        parsed = subject.information_from_io(File.open(svg_path, 'rb'))
+        parsed = subject.call(File.open(svg_path, 'rb'))
         expect(parsed).to eq(nil)
       end
     end