format_parser 0.16.1 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80362b6ee92ad34550681e8c0447dcb93b11071beac25d743356a9c0b7a548f9
-  data.tar.gz: c40fbcae9bd5417420ff5ea573c24f65462f3b0cf5269fc65024e6a237c98f45
+  metadata.gz: 45efce1fcb5395b66713b4704911473a6aaf6beab8dced2275299d05d42f051c
+  data.tar.gz: 760d1d686400e97cb58296bbf06862be7a19fedd6b2684075530c089d6685eac
 SHA512:
-  metadata.gz: 7f20f7206574ea204393662e29251dc079ce615c593b21c0c4c35f3ba74a08fc9582e15443f23e45771ee2cb73b5b691ee6a31d37f5fb99e847d09d4c2e003cd
-  data.tar.gz: 6a23e2bb7797a5834e0b2867096240a29ea899d2301f1496c94b2e9d35d29698dc8599bef7185785f7a26fc929bff1e9dda1f5d7a96bbfc37227b1a2d42b3c4b
+  metadata.gz: 0f3b357ff7b4121c4cad07a82ca94f13a4e92f3657e8984aa61a1c1a67f6144f726174a09b3b99c3c29b75dcd4c81970a5613e0e5a79e7c4eef52dbcdb779a50
+  data.tar.gz: 712e87ef7d506abcf7096d16c738058320dac9c1f2b2557ce08c6576748b37d3041bbe3d43260dcf846bfa7062a5de2840e30782e8c8edaabd15a6b19146d344

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.17.0
+* Remove parser factories. A parser should respond to `likely_match?` and `call`. If a parser has to be instantiated anew for
+  every call the parser should take care of instantiating itself.
+* Add support for BMP files with core headers (older version of the BMP format)
+
+## 0.16.2
+* All EXIF: Deal with EXIF orientations that get parsed as an array of [Orientation, nil] due to incorrect padding
+
 ## 0.16.1
 * All EXIF: Make sure the 0 orientation does not get silently treated as orientation 8, mislabling
   images which are not rotated as being rotated (orientation changed)

data/lib/format_parser.rb

@@ -244,40 +244,25 @@ module FormatParser
 
     fitting_by_natures = assemble_parser_set[@parsers_per_nature, desired_natures]
     fitting_by_formats = assemble_parser_set[@parsers_per_format, desired_formats]
-    factories = fitting_by_natures & fitting_by_formats
+    parsers = fitting_by_natures & fitting_by_formats
 
-    if factories.empty?
+    if parsers.empty?
       raise ArgumentError, "No parsers provide both natures #{desired_natures.inspect} and formats #{desired_formats.inspect}"
     end
 
     # Order the parsers according to their priority value. The ones having a lower
     # value will sort higher and will be applied sooner
-    factories_in_order_of_priority = factories.to_a.sort do |parser_factory_a, parser_factory_b|
-      @parser_priorities[parser_factory_a] <=> @parser_priorities[parser_factory_b]
+    parsers_in_order_of_priority = parsers.to_a.sort do |parser_a, parser_b|
+      @parser_priorities[parser_a] <=> @parser_priorities[parser_b]
     end
 
     # If there is one parser that is more likely to match, place it first
-    if first_match = factories_in_order_of_priority.find { |f| f.respond_to?(:likely_match?) && f.likely_match?(filename_hint) }
-      factories_in_order_of_priority.delete(first_match)
-      factories_in_order_of_priority.unshift(first_match)
+    if first_match = parsers_in_order_of_priority.find { |f| f.respond_to?(:likely_match?) && f.likely_match?(filename_hint) }
+      parsers_in_order_of_priority.delete(first_match)
+      parsers_in_order_of_priority.unshift(first_match)
     end
 
-    factories_in_order_of_priority.map { |callable_or_class| instantiate_parser(callable_or_class) }
-  end
-
-  # Instantiates a parser object (an object that responds to `#call`) from a given class
-  # or returns the parameter as is if it is callable by itself - i.e. if it is a Proc
-  #
-  # @param callable_or_responding_to_new[#call, #new] a callable or a Class/Module
-  # @return [#call] a parser that can be called with an IO-ish argument
-  def self.instantiate_parser(callable_or_responding_to_new)
-    if callable_or_responding_to_new.respond_to?(:call)
-      callable_or_responding_to_new
-    elsif callable_or_responding_to_new.respond_to?(:new)
-      callable_or_responding_to_new.new
-    else
-      raise ArgumentError, 'A parser should be either a class with an instance method #call or a Proc'
-    end
+    parsers_in_order_of_priority
   end
 
   def self.string_to_lossy_utf8(str)

data/lib/format_parser/version.rb

@@ -1,3 +1,3 @@
 module FormatParser
-  VERSION = '0.16.1'
+  VERSION = '0.17.0'
 end

data/lib/parsers/aiff_parser.rb

@@ -18,7 +18,7 @@ class FormatParser::AIFFParser
     'ANNO',
   ]
 
-  def self.likely_match?(filename)
+  def likely_match?(filename)
     filename =~ /\.aiff?$/i
   end
 
@@ -84,5 +84,5 @@ class FormatParser::AIFFParser
     (sign == '1' ? -1.0 : 1.0) * (fraction.to_f / ((1 << 63) - 1)) * (2**exponent)
   end
 
-  FormatParser.register_parser self, natures: :audio, formats: :aiff
+  FormatParser.register_parser new, natures: :audio, formats: :aiff
 end

data/lib/parsers/bmp_parser.rb

@@ -4,9 +4,9 @@ class FormatParser::BMPParser
   include FormatParser::IOUtils
 
   VALID_BMP = 'BM'
-  PERMISSIBLE_PIXEL_ARRAY_LOCATIONS = 40..512
+  PERMISSIBLE_PIXEL_ARRAY_LOCATIONS = 26..512
 
-  def self.likely_match?(filename)
+  def likely_match?(filename)
     filename =~ /\.bmp$/i
   end
 
@@ -21,14 +21,41 @@ class FormatParser::BMPParser
     return unless PERMISSIBLE_PIXEL_ARRAY_LOCATIONS.cover?(pix_array_location)
 
     dib_header = safe_read(io, 40)
+    header_size = dib_header.unpack('V')[0]
+    case header_size
+    when 12 # OS21XBITMAPHEADER
+      parse_bitmap_core_header(dib_header)
+    else # More modern implementations
+      parse_modern_header(dib_header)
+    end
+  end
+
+  def parse_bitmap_core_header(dib_header)
+    _header_size, width, height, _num_color_planes, bit_depth = dib_header.unpack('VSSSS')
+
+    # In core bitmap format an unsigned int is used for dimensions,
+    # no inverse scan order is possible
+    data_order = :normal
+
+    FormatParser::Image.new(
+      format: :bmp,
+      width_px: width,
+      height_px: height,
+      color_mode: :rgb,
+      intrinsics: {
+        data_order: data_order,
+        bits_per_pixel: bit_depth
+      }
+    )
+  end
 
-    _header_size, width, height, _planes, _bits_per_pixel,
+  def parse_modern_header(dib_header)
+    _header_size, width, height, _planes, bits_per_pixel,
     _compression_method, _image_size, horizontal_res,
     vertical_res, _n_colors, _i_colors = dib_header.unpack('Vl<2v2V2l<2V2')
 
     # There are cases where the height might by negative indicating the data
     # is ordered from top to bottom instead of bottom to top
-    # http://www.dragonwins.com/domains/getteched/bmp/bmpfileformat.htm#The%20Image%20Header
     data_order = height < 0 ? :inverse : :normal
 
     FormatParser::Image.new(
@@ -39,10 +66,11 @@ class FormatParser::BMPParser
       intrinsics: {
         vertical_resolution: vertical_res,
         horizontal_resolution: horizontal_res,
-        data_order: data_order
+        data_order: data_order,
+        bits_per_pixel: bits_per_pixel,
       }
     )
   end
 
-  FormatParser.register_parser self, natures: :image, formats: :bmp
+  FormatParser.register_parser new, natures: :image, formats: :bmp
 end

data/lib/parsers/cr2_parser.rb

@@ -7,7 +7,7 @@ class FormatParser::CR2Parser
   TIFF_HEADER = [0x49, 0x49, 0x2a, 0x00]
   CR2_HEADER  = [0x43, 0x52, 0x02, 0x00]
 
-  def self.likely_match?(filename)
+  def likely_match?(filename)
     filename =~ /\.cr2$/i
   end
 
@@ -44,5 +44,5 @@ class FormatParser::CR2Parser
     nil
   end
 
-  FormatParser.register_parser self, natures: :image, formats: :cr2
+  FormatParser.register_parser new, natures: :image, formats: :cr2
 end

data/lib/parsers/dpx_parser.rb

@@ -19,7 +19,7 @@ class FormatParser::DPXParser
 
   private_constant :ByteOrderHintIO
 
-  def self.likely_match?(filename)
+  def likely_match?(filename)
     filename =~ /\.dpx$/i
   end
 
@@ -59,5 +59,5 @@ class FormatParser::DPXParser
     )
   end
 
-  FormatParser.register_parser self, natures: :image, formats: :dpx
+  FormatParser.register_parser new, natures: :image, formats: :dpx
 end

data/lib/parsers/exif_parser.rb

@@ -42,7 +42,7 @@ module FormatParser::EXIFParser
 
   class EXIFResult < SimpleDelegator
     def rotated?
-      __getobj__.orientation.to_i > 4
+      orientation.to_i > 4
     end
 
     def to_json(*maybe_coder)
@@ -52,7 +52,11 @@ module FormatParser::EXIFParser
     end
 
     def orientation
-      __getobj__.orientation.to_i
+      # In some EXIF tags the value type is set oddly - it unpacks into multiple values,
+      # and it will look like this: [#<EXIFR::TIFF::Orientation:TopLeft(1)>, nil]
+      orientation_values = Array(__getobj__.orientation)
+      last_usable_value = orientation_values.compact[-1] # Use the last non-nil one
+      last_usable_value.to_i
     end
 
     def orientation_sym
@@ -162,4 +166,6 @@ module FormatParser::EXIFParser
       raw_exif_data ? EXIFResult.new(raw_exif_data) : nil
     end
   end
+
+  extend self
 end

data/lib/parsers/fdx_parser.rb

@@ -1,7 +1,7 @@
 class FormatParser::FDXParser
   include FormatParser::IOUtils
 
-  def self.likely_match?(filename)
+  def likely_match?(filename)
     filename =~ /\.fdx$/i
   end
 
@@ -30,5 +30,5 @@ class FormatParser::FDXParser
     end
   end
 
-  FormatParser.register_parser self, natures: :document, formats: :fdx
+  FormatParser.register_parser new, natures: :document, formats: :fdx
 end

data/lib/parsers/flac_parser.rb

@@ -5,7 +5,7 @@ class FormatParser::FLACParser
   MAGIC_BYTE_STRING = 'fLaC'
   BLOCK_HEADER_BYTES = 4
 
-  def self.likely_match?(filename)
+  def likely_match?(filename)
     filename =~ /\.flac$/i
   end
 
@@ -75,5 +75,5 @@ class FormatParser::FLACParser
     s.unpack('B*')[0].to_i(2)
   end
 
-  FormatParser.register_parser self, natures: :audio, formats: :flac
+  FormatParser.register_parser new, natures: :audio, formats: :flac
 end

data/lib/parsers/gif_parser.rb

@@ -4,7 +4,7 @@ class FormatParser::GIFParser
   HEADERS = ['GIF87a', 'GIF89a'].map(&:b)
   NETSCAPE_AND_AUTHENTICATION_CODE = 'NETSCAPE2.0'
 
-  def self.likely_match?(filename)
+  def likely_match?(filename)
     filename =~ /\.gif$/i
   end
 
@@ -48,5 +48,5 @@ class FormatParser::GIFParser
     )
   end
 
-  FormatParser.register_parser self, natures: :image, formats: :gif, priority: 0
+  FormatParser.register_parser new, natures: :image, formats: :gif, priority: 0
 end

data/lib/parsers/jpeg_parser.rb

@@ -17,6 +17,10 @@ class FormatParser::JPEGParser
     filename =~ /\.jpe?g$/i
   end
 
+  def self.call(io)
+    new.call(io)
+  end
+
   def call(io)
     @buf = FormatParser::IOConstraint.new(io)
     @width             = nil

data/lib/parsers/moov_parser.rb

@@ -11,7 +11,7 @@ class FormatParser::MOOVParser
     'm4a ' => :m4a,
   }
 
-  def self.likely_match?(filename)
+  def likely_match?(filename)
     filename =~ /\.(mov|m4a|ma4|mp4|aac)$/i
   end
 
@@ -87,5 +87,5 @@ class FormatParser::MOOVParser
     maybe_atom_size >= minimum_ftyp_atom_size && maybe_ftyp_atom_signature == 'ftyp'
   end
 
-  FormatParser.register_parser self, natures: :video, formats: FTYP_MAP.values, priority: 1
+  FormatParser.register_parser new, natures: :video, formats: FTYP_MAP.values, priority: 1
 end

data/lib/parsers/mp3_parser.rb

@@ -53,7 +53,7 @@ class FormatParser::MP3Parser
     end
   end
 
-  def self.likely_match?(filename)
+  def likely_match?(filename)
     filename =~ /\.mp3$/i
   end
 
@@ -297,5 +297,5 @@ class FormatParser::MP3Parser
     attrs
   end
 
-  FormatParser.register_parser self, natures: :audio, formats: :mp3, priority: 99
+  FormatParser.register_parser new, natures: :audio, formats: :mp3, priority: 99
 end

data/lib/parsers/ogg_parser.rb

@@ -6,7 +6,7 @@ class FormatParser::OggParser
   # Maximum size of an Ogg page
   MAX_POSSIBLE_PAGE_SIZE = 65307
 
-  def self.likely_match?(filename)
+  def likely_match?(filename)
     filename =~ /\.ogg$/i
   end
 
@@ -218,5 +218,5 @@ class FormatParser::OggParser
     0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
   ].freeze
 
-  FormatParser.register_parser self, natures: :audio, formats: :ogg
+  FormatParser.register_parser new, natures: :audio, formats: :ogg
 end

data/lib/parsers/pdf_parser.rb

@@ -9,7 +9,7 @@ class FormatParser::PDFParser
   #
   PDF_MARKER = /%PDF-1\.[0-8]{1}/
 
-  def self.likely_match?(filename)
+  def likely_match?(filename)
     filename =~ /\.(pdf|ai)$/i
   end
 
@@ -21,5 +21,5 @@ class FormatParser::PDFParser
     FormatParser::Document.new(format: :pdf)
   end
 
-  FormatParser.register_parser self, natures: :document, formats: :pdf, priority: 1
+  FormatParser.register_parser new, natures: :document, formats: :pdf, priority: 1
 end

data/lib/parsers/png_parser.rb

@@ -15,7 +15,7 @@ class FormatParser::PNGParser
     6 => true,
   }
 
-  def self.likely_match?(filename)
+  def likely_match?(filename)
     filename =~ /\.png$/i
   end
 
@@ -75,5 +75,5 @@ class FormatParser::PNGParser
   end
 
   # Give it priority 1 since priority 0 is reserved for JPEG, our most popular
-  FormatParser.register_parser self, natures: :image, formats: :png, priority: 1
+  FormatParser.register_parser new, natures: :image, formats: :png, priority: 1
 end

data/lib/parsers/psd_parser.rb

@@ -3,7 +3,7 @@ class FormatParser::PSDParser
 
   PSD_HEADER = [0x38, 0x42, 0x50, 0x53]
 
-  def self.likely_match?(filename)
+  def likely_match?(filename)
     filename =~ /\.psd$/i # Maybe also PSB at some point
   end
 
@@ -23,5 +23,5 @@ class FormatParser::PSDParser
     )
   end
 
-  FormatParser.register_parser self, natures: :image, formats: :psd
+  FormatParser.register_parser new, natures: :image, formats: :psd
 end

data/lib/parsers/tiff_parser.rb

@@ -5,7 +5,7 @@ class FormatParser::TIFFParser
   MAGIC_LE = [0x49, 0x49, 0x2A, 0x0].pack('C4')
   MAGIC_BE = [0x4D, 0x4D, 0x0, 0x2A].pack('C4')
 
-  def self.likely_match?(filename)
+  def likely_match?(filename)
     filename =~ /\.tiff?$/i
   end
 
@@ -43,5 +43,5 @@ class FormatParser::TIFFParser
     safe_read(io, 2) == 'CR'
   end
 
-  FormatParser.register_parser self, natures: :image, formats: :tif
+  FormatParser.register_parser new, natures: :image, formats: :tif
 end

data/lib/parsers/wav_parser.rb

@@ -1,7 +1,7 @@
 class FormatParser::WAVParser
   include FormatParser::IOUtils
 
-  def self.likely_match?(filename)
+  def likely_match?(filename)
     filename =~ /\.wav$/i
   end
 
@@ -99,5 +99,5 @@ class FormatParser::WAVParser
     )
   end
 
-  FormatParser.register_parser self, natures: :audio, formats: :wav
+  FormatParser.register_parser new, natures: :audio, formats: :wav
 end

data/lib/parsers/zip_parser.rb

@@ -5,7 +5,7 @@ class FormatParser::ZIPParser
   include OfficeFormats
   include FormatParser::IOUtils
 
-  def self.likely_match?(filename)
+  def likely_match?(filename)
     filename =~ /\.(zip|docx|keynote|numbers|pptx|xlsx)$/i
   end
 
@@ -58,5 +58,5 @@ class FormatParser::ZIPParser
     end
   end
 
-  FormatParser.register_parser self, natures: [:archive, :document], formats: :zip, priority: 2
+  FormatParser.register_parser new, natures: [:archive, :document], formats: :zip, priority: 2
 end

data/spec/parsers/bmp_parser_spec.rb

@@ -17,6 +17,7 @@ describe FormatParser::BMPParser do
     expect(parsed.intrinsics[:vertical_resolution]).to eq(2834)
     expect(parsed.intrinsics[:horizontal_resolution]).to eq(2834)
     expect(parsed.intrinsics[:data_order]).to eq(:normal)
+    expect(parsed.intrinsics[:bits_per_pixel]).to eq(24)
   end
 
   it 'parses a BMP file with negative height_px values (divergent scan order)' do
@@ -35,6 +36,7 @@ describe FormatParser::BMPParser do
     expect(parsed.intrinsics[:vertical_resolution]).to eq(2835)
     expect(parsed.intrinsics[:horizontal_resolution]).to eq(2835)
     expect(parsed.intrinsics[:data_order]).to eq(:inverse)
+    expect(parsed.intrinsics[:bits_per_pixel]).to eq(24)
   end
 
   it 'parses a BMP where the pixel array location is other than 54' do
@@ -52,6 +54,32 @@ describe FormatParser::BMPParser do
     expect(parsed.intrinsics).not_to be_nil
   end
 
+  it 'parses various BMP headers' do
+    bmp_path = fixtures_dir + '/BMP/test_v5header.bmp'
+    parsed = subject.call(File.open(bmp_path, 'rb'))
+
+    expect(parsed).not_to be_nil
+    expect(parsed.nature).to eq(:image)
+    expect(parsed.format).to eq(:bmp)
+    expect(parsed.color_mode).to eq(:rgb)
+    expect(parsed.width_px).to eq(40)
+    expect(parsed.height_px).to eq(27)
+    expect(parsed.intrinsics[:bits_per_pixel]).to eq(24)
+    expect(parsed.intrinsics[:data_order]).to eq(:normal)
+
+    bmp_path = fixtures_dir + '/BMP/test_coreheader.bmp'
+    parsed = subject.call(File.open(bmp_path, 'rb'))
+
+    expect(parsed).not_to be_nil
+    expect(parsed.nature).to eq(:image)
+    expect(parsed.format).to eq(:bmp)
+    expect(parsed.color_mode).to eq(:rgb)
+    expect(parsed.width_px).to eq(40)
+    expect(parsed.height_px).to eq(27)
+    expect(parsed.intrinsics[:bits_per_pixel]).to eq(24)
+    expect(parsed.intrinsics[:data_order]).to eq(:normal)
+  end
+
   it 'refuses to parse a BMP where the pixel array location is very large' do
     junk_data = [
       'BM',

data/spec/parsers/exif_parser_spec.rb

@@ -1,15 +1,11 @@
 require 'spec_helper'
 
 describe FormatParser::EXIFParser do
-  let(:subject) do
-    Object.new.tap { |o| o.extend FormatParser::EXIFParser }
-  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
-        result = subject.exif_from_tiff_io(File.open(tiff_path, 'rb'))
+        result = described_class.exif_from_tiff_io(File.open(tiff_path, 'rb'))
         expect(result).not_to be_nil
         expect(result.orientation_sym).to be_kind_of(Symbol)
         # Filenames in this dir correspond with the orientation of the file
@@ -18,6 +14,14 @@ describe FormatParser::EXIFParser do
     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|
+      described_class.exif_from_tiff_io(f)
+    end
+    expect(exif_data.orientation).to eq(1)
+  end
+
   describe 'IOExt' do
     it 'supports readbyte' do
       io = FormatParser::EXIFParser::IOExt.new(StringIO.new('hello'))

data/spec/parsers/zip_parser_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe FormatParser::ZIPParser do
   it 'provides filename hints' do
-    expect(FormatParser::ZIPParser).to be_likely_match('file.zip')
-    expect(FormatParser::ZIPParser).not_to be_likely_match('file.tif')
+    expect(subject).to be_likely_match('file.zip')
+    expect(subject).not_to be_likely_match('file.tif')
   end
 
   it 'parses a ZIP archive with Zip64 extra fields (due to the number of files)' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: format_parser
 version: !ruby/object:Gem::Version
-  version: 0.16.1
+  version: 0.17.0
 platform: ruby
 authors:
 - Noah Berman
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-06 00:00:00.000000000 Z
+date: 2019-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ks
@@ -303,8 +303,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: A library for efficient parsing of file metadata