format_parser 0.26.0 → 0.29.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1074a8172a2830a11df0fb7874936c2b8abab8d74fd39985f9c9f7b72d5b348c
-  data.tar.gz: 5eafd2d610cd30bc85a056bd1c31331bcb49e8ce6b5b538cd13e280b138be7db
+  metadata.gz: 75ee83f55840e3031d4d60d8dc07ca038812188613e2b740079e1c965efb2886
+  data.tar.gz: 31c3ee84434560c18e6ea74a23160b909e6f880f52b2ed6f0e888e847c557bd9
 SHA512:
-  metadata.gz: 5ce396a71fedd82b8041bcb6c833e559c7eef74886e73095eaf0b3d21e0c0d49b1620a83aba9796a8134dd5a7fc679156cd967cf82cba95b5941941be73d70c4
-  data.tar.gz: '0395e5a8fb35e860060e9c3b040b788aaad97eb5883f2d662b418156f1f3986bc4a26a814b9a8552ce7dcbd271da27e977cfb77a5e5b155ebd35db6a49a97719'
+  metadata.gz: 536cfb1bac7926f56ba760959d7c5a0905d3b2b0944b16248b6c81be00b722dad894a8d6d5773134fb0471e42d016a20be15e3d5a01c671f0cc65658f2fc05b4
+  data.tar.gz: cb3f73df051b8612cb6d0e1a4e55c045e461bf2c5e4667dd6e461e779b1f39d01be8d70d084e252e5198a966ac590129286811f5822808a0c980c2ad72a087a1

data/.github/workflows/main.yml

@@ -0,0 +1,104 @@
+name: CI
+
+on: [push,pull_request]
+
+env:
+  BUNDLE_PATH: vendor/bundle
+
+jobs:
+  lint:
+    name: Code Style
+    runs-on: ubuntu-18.04
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository
+    strategy:
+      matrix:
+        ruby:
+          - 2.7
+          - 2.6
+          - 2.5
+          - 2.4
+          - 2.3
+          - 2.2
+          - jruby
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - name: Gemfile Cache
+        uses: actions/cache@v2
+        with:
+          path: Gemfile.lock
+          key: ${{ runner.os }}-gemlock-${{ matrix.ruby }}-${{ hashFiles('Gemfile', 'format_parser.gemspec') }}
+          restore-keys: |
+            ${{ runner.os }}-gemlock-${{ matrix.ruby }}-
+      - name: Bundle Cache
+        id: cache-gems
+        uses: actions/cache@v2
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-gems-${{ matrix.ruby }}-${{ hashFiles('Gemfile', 'Gemfile.lock', 'format_parser.gemspec') }}
+          restore-keys: |
+            ${{ runner.os }}-gems-${{ matrix.ruby }}-
+            ${{ runner.os }}-gems-
+      - name: Bundle Install
+        if: steps.cache-gems.outputs.cache-hit != 'true'
+        run: bundle install --jobs 4 --retry 3
+      - name: Rubocop Cache
+        uses: actions/cache@v2
+        with:
+          path: ~/.cache/rubocop_cache
+          key: ${{ runner.os }}-rubocop-${{ hashFiles('.rubocop.yml') }}
+          restore-keys: |
+            ${{ runner.os }}-rubocop-
+      - name: Rubocop
+        run: bundle exec rubocop
+  test:
+    name: Specs
+    runs-on: ubuntu-18.04
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository
+    strategy:
+      matrix:
+        ruby:
+          - 2.7
+          - 2.6
+          - 2.5
+          - 2.4
+          - 2.3
+          - 2.2
+          - jruby
+        experimental: [false]
+        include:
+          - ruby: 3.0
+            experimental: true
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - name: Gemfile Cache
+        uses: actions/cache@v2
+        with:
+          path: Gemfile.lock
+          key: ${{ runner.os }}-gemlock-${{ matrix.ruby }}-${{ hashFiles('Gemfile', 'format_parser.gemspec') }}
+          restore-keys: |
+            ${{ runner.os }}-gemlock-${{ matrix.ruby }}-
+      - name: Bundle Cache
+        id: cache-gems
+        uses: actions/cache@v2
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-gems-${{ matrix.ruby }}-${{ hashFiles('Gemfile', 'Gemfile.lock', 'format_parser.gemspec') }}
+          restore-keys: |
+            ${{ runner.os }}-gems-${{ matrix.ruby }}-
+            ${{ runner.os }}-gems-
+      - name: Bundle Install
+        if: steps.cache-gems.outputs.cache-hit != 'true'
+        run: bundle install --jobs 4 --retry 3
+      - name: RSpec
+        continue-on-error: ${{ matrix.experimental }}
+        run: bundle exec rake parallel:spec

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 0.29.1
+* Fix handling of 200 responses with `parse_http` as well as handling of very small responses which do not need range access
+
+## 0.29.0
+* Add option `headers:` to `FormatParser.parse_http`
+
+## 0.28.0
+* Change `FormatParser.parse_http` to follow HTTP redirects
+
+## 0.27.0
+* Add `#content_type` on `Result` return values which makes sense for the detected filetype
+
 ## 0.26.0
 * Add support for M3U format files
 

data/format_parser.gemspec

@@ -34,6 +34,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'exifr', '~> 1', '>= 1.3.8'
   spec.add_dependency 'id3tag', '~> 0.14'
   spec.add_dependency 'faraday', '~> 0.13'
+  spec.add_dependency 'faraday_middleware', '~> 0.14'
   spec.add_dependency 'measurometer', '~> 1'
 
   spec.add_development_dependency 'rspec', '~> 3.0'

data/lib/archive.rb

@@ -26,6 +26,9 @@ module FormatParser
     # it can be placed here
     attr_accessor :intrinsics
 
+    # The MIME type of the archive
+    attr_accessor :content_type
+
     # Only permits assignments via defined accessors
     def initialize(**attributes)
       attributes.map { |(k, v)| public_send("#{k}=", v) }

data/lib/audio.rb

@@ -35,6 +35,9 @@ module FormatParser
     # it can be placed here
     attr_accessor :intrinsics
 
+    # The MIME type of the sound file
+    attr_accessor :content_type
+
     # Only permits assignments via defined accessors
     def initialize(**attributes)
       attributes.map { |(k, v)| public_send("#{k}=", v) }

data/lib/document.rb

@@ -7,6 +7,7 @@ module FormatParser
     attr_accessor :format
     attr_accessor :document_type
     attr_accessor :page_count
+    attr_accessor :content_type
 
     # Only permits assignments via defined accessors
     def initialize(**attributes)

data/lib/format_parser/version.rb

@@ -1,3 +1,3 @@
 module FormatParser
-  VERSION = '0.26.0'
+  VERSION = '0.29.1'
 end

data/lib/format_parser.rb

@@ -88,13 +88,14 @@ module FormatParser
   # given to `.parse`. The accepted keyword arguments are the same as the ones for `parse`.
   #
   # @param url[String, URI] the HTTP(S) URL to request the object from using Faraday and `Range:` requests
+  # @param headers[Hash] (optional) the HTTP headers to request the object from using Faraday
   # @param kwargs the keyword arguments to be delegated to `.parse`
   # @see {.parse}
-  def self.parse_http(url, **kwargs)
+  def self.parse_http(url, headers: {}, **kwargs)
     # Do not extract the filename, since the URL
     # can really be "anything". But if the caller
     # provides filename_hint it will be carried over
-    parse(RemoteIO.new(url), **kwargs)
+    parse(RemoteIO.new(url, headers: headers), **kwargs)
   end
 
   # Parses the file at the given `path` and returns the results as if it were any IO

data/lib/image.rb

@@ -64,6 +64,9 @@ module FormatParser
     # it can be placed here
     attr_accessor :intrinsics
 
+    # The MIME type of the image file
+    attr_accessor :content_type
+
     # Only permits assignments via defined accessors
     def initialize(**attributes)
       attributes.map { |(k, v)| public_send("#{k}=", v) }

data/lib/parsers/aiff_parser.rb

@@ -1,6 +1,8 @@
 class FormatParser::AIFFParser
   include FormatParser::IOUtils
 
+  AIFF_MIME_TYPE = 'audio/x-aiff'
+
   # Known chunk types we can omit when parsing,
   # grossly lifted from http://www.muratnkonar.com/aiff/
   KNOWN_CHUNKS = [
@@ -70,7 +72,8 @@ class FormatParser::AIFFParser
       num_audio_channels: channels,
       audio_sample_rate_hz: sample_rate.to_i,
       media_duration_frames: sample_frames,
-      media_duration_seconds: duration_in_seconds
+      media_duration_seconds: duration_in_seconds,
+      content_type: AIFF_MIME_TYPE,
     )
   end
 

data/lib/parsers/bmp_parser.rb

@@ -5,6 +5,7 @@ class FormatParser::BMPParser
 
   VALID_BMP = 'BM'
   PERMISSIBLE_PIXEL_ARRAY_LOCATIONS = 26..512
+  BMP_MIME_TYPE = 'image/bmp'
 
   def likely_match?(filename)
     filename =~ /\.bmp$/i
@@ -42,6 +43,7 @@ class FormatParser::BMPParser
       width_px: width,
       height_px: height,
       color_mode: :rgb,
+      content_type: BMP_MIME_TYPE,
       intrinsics: {
         data_order: data_order,
         bits_per_pixel: bit_depth
@@ -63,6 +65,7 @@ class FormatParser::BMPParser
       width_px: width,
       height_px: height.abs,
       color_mode: :rgb,
+      content_type: BMP_MIME_TYPE,
       intrinsics: {
         vertical_resolution: vertical_res,
         horizontal_resolution: horizontal_res,

data/lib/parsers/cr2_parser.rb

@@ -6,6 +6,7 @@ class FormatParser::CR2Parser
 
   TIFF_HEADER = [0x49, 0x49, 0x2a, 0x00]
   CR2_HEADER  = [0x43, 0x52, 0x02, 0x00]
+  CR2_MIME_TYPE = 'image/x-canon-cr2'
 
   def likely_match?(filename)
     filename =~ /\.cr2$/i
@@ -39,6 +40,7 @@ class FormatParser::CR2Parser
       display_height_px: exif_data.rotated? ? w : h,
       orientation: exif_data.orientation_sym,
       intrinsics: {exif: exif_data},
+      content_type: CR2_MIME_TYPE,
     )
   rescue EXIFR::MalformedTIFF
     nil

data/lib/parsers/dpx_parser.rb

@@ -6,6 +6,11 @@ class FormatParser::DPXParser
   BE_MAGIC = 'SDPX'
   LE_MAGIC = BE_MAGIC.reverse
 
+  # There is no official MIME type for DPX, so we have
+  # to invent something useful. We will prefix it with x-
+  # to indicate that it is a vendor subtype
+  DPX_MIME_TYPE = 'image/x-dpx'
+
   class ByteOrderHintIO < SimpleDelegator
     def initialize(io, is_little_endian)
       super(io)
@@ -61,6 +66,7 @@ class FormatParser::DPXParser
       display_width_px: display_w,
       display_height_px: display_h,
       intrinsics: dpx_structure,
+      content_type: DPX_MIME_TYPE,
     )
   end
 

data/lib/parsers/flac_parser.rb

@@ -4,6 +4,7 @@ class FormatParser::FLACParser
   MAGIC_BYTES = 4
   MAGIC_BYTE_STRING = 'fLaC'
   BLOCK_HEADER_BYTES = 4
+  FLAC_MIME_TYPE = 'audio/x-flac'
 
   def likely_match?(filename)
     filename =~ /\.flac$/i
@@ -61,6 +62,7 @@ class FormatParser::FLACParser
       audio_sample_rate_hz: sample_rate,
       media_duration_seconds: duration,
       media_duration_frames: total_samples,
+      content_type: FLAC_MIME_TYPE,
       intrinsics: {
         bits_per_sample: bits_per_sample,
         minimum_frame_size: minimum_frame_size,

data/lib/parsers/gif_parser.rb

@@ -3,6 +3,7 @@ class FormatParser::GIFParser
 
   HEADERS = ['GIF87a', 'GIF89a'].map(&:b)
   NETSCAPE_AND_AUTHENTICATION_CODE = 'NETSCAPE2.0'
+  GIF_MIME_TYPE = 'image/gif'
 
   def likely_match?(filename)
     filename =~ /\.gif$/i
@@ -45,6 +46,7 @@ class FormatParser::GIFParser
       height_px: h,
       has_multiple_frames: is_animated,
       color_mode: :indexed,
+      content_type: GIF_MIME_TYPE
     )
   end
 

data/lib/parsers/jpeg_parser.rb

@@ -12,6 +12,7 @@ class FormatParser::JPEGParser
   APP1_MARKER = 0xE1  # maybe EXIF
   EXIF_MAGIC_STRING = "Exif\0\0".b
   MUST_FIND_NEXT_MARKER_WITHIN_BYTES = 1024
+  JPEG_MIME_TYPE = 'image/jpeg'
 
   def self.likely_match?(filename)
     filename =~ /\.jpe?g$/i
@@ -88,6 +89,7 @@ class FormatParser::JPEGParser
         display_height_px: dh,
         orientation: flat_exif.orientation_sym,
         intrinsics: {exif: flat_exif},
+        content_type: JPEG_MIME_TYPE
       )
 
       return result

data/lib/parsers/m3u_parser.rb

@@ -2,6 +2,7 @@ class FormatParser::M3UParser
   include FormatParser::IOUtils
 
   HEADER = '#EXTM3U'
+  M3U8_MIME_TYPE = 'application/vnd.apple.mpegurl' # https://en.wikipedia.org/wiki/M3U#Internet_media_types
 
   def likely_match?(filename)
     filename =~ /\.m3u8?$/i
@@ -14,7 +15,8 @@ class FormatParser::M3UParser
     return unless HEADER.eql?(header)
 
     FormatParser::Text.new(
-      format: :m3u
+      format: :m3u,
+      content_type: M3U8_MIME_TYPE,
     )
   end
   FormatParser.register_parser new, natures: :text, formats: :m3u

data/lib/parsers/moov_parser.rb

@@ -11,6 +11,12 @@ class FormatParser::MOOVParser
     'm4a ' => :m4a,
   }
 
+  # https://tools.ietf.org/html/rfc4337#section-2
+  # There is also video/quicktime which we should be able to capture
+  # here, but there is currently no detection for MOVs versus MP4s
+  MP4_AU_MIME_TYPE = 'audio/mp4'
+  MP4_MIXED_MIME_TYPE = 'video/mp4'
+
   def likely_match?(filename)
     filename =~ /\.(mov|m4a|ma4|mp4|aac|m4v)$/i
   end
@@ -49,10 +55,12 @@ class FormatParser::MOOVParser
     end
 
     # M4A only contains audio, while MP4 and friends can contain video.
-    if format_from_moov_type(file_type) == :m4a
+    fmt = format_from_moov_type(file_type)
+    if fmt == :m4a
       FormatParser::Audio.new(
         format: format_from_moov_type(file_type),
         media_duration_seconds: media_duration_s,
+        content_type: MP4_AU_MIME_TYPE,
         intrinsics: atom_tree,
       )
     else
@@ -61,6 +69,7 @@ class FormatParser::MOOVParser
         width_px: width,
         height_px: height,
         media_duration_seconds: media_duration_s,
+        content_type: MP4_MIXED_MIME_TYPE,
         intrinsics: atom_tree,
       )
     end

data/lib/parsers/mp3_parser.rb

@@ -32,7 +32,7 @@ class FormatParser::MP3Parser
   MAGIC_LE = [0x49, 0x49, 0x2A, 0x0].pack('C4')
   MAGIC_BE = [0x4D, 0x4D, 0x0, 0x2A].pack('C4')
   TIFF_HEADER_BYTES = [MAGIC_LE, MAGIC_BE]
-
+  MP3_MIME_TYPE = 'audio/mpeg'
   # Wraps the Tag object returned by ID3Tag in such
   # a way that a usable JSON representation gets
   # returned
@@ -104,7 +104,8 @@ class FormatParser::MP3Parser
       # do not tell anything of substance
       num_audio_channels: first_frame.channels,
       audio_sample_rate_hz: first_frame.sample_rate,
-      intrinsics: id3tags_hash.merge(id3tags: tags)
+      intrinsics: id3tags_hash.merge(id3tags: tags),
+      content_type: MP3_MIME_TYPE,
     )
 
     extra_file_attirbutes = fetch_extra_attributes_from_id3_tags(id3tags_hash)

data/lib/parsers/ogg_parser.rb

@@ -3,8 +3,8 @@
 class FormatParser::OggParser
   include FormatParser::IOUtils
 
-  # Maximum size of an Ogg page
   MAX_POSSIBLE_PAGE_SIZE = 65307
+  OGG_MIME_TYPE = 'audio/ogg'
 
   def likely_match?(filename)
     filename =~ /\.ogg$/i
@@ -45,7 +45,8 @@ class FormatParser::OggParser
       format: :ogg,
       audio_sample_rate_hz: sample_rate,
       num_audio_channels: channels,
-      media_duration_seconds: duration
+      media_duration_seconds: duration,
+      content_type: OGG_MIME_TYPE,
     )
   end
 

data/lib/parsers/pdf_parser.rb

@@ -1,6 +1,5 @@
 class FormatParser::PDFParser
   include FormatParser::IOUtils
-
   # First 9 bytes of a PDF should be in this format, according to:
   #
   #  https://stackoverflow.com/questions/3108201/detect-if-pdf-file-is-correct-header-pdf
@@ -8,6 +7,7 @@ class FormatParser::PDFParser
   # There are however exceptions, which are left out for now.
   #
   PDF_MARKER = /%PDF-1\.[0-8]{1}/
+  PDF_CONTENT_TYPE = 'application/pdf'
 
   def likely_match?(filename)
     filename =~ /\.(pdf|ai)$/i
@@ -18,7 +18,7 @@ class FormatParser::PDFParser
 
     return unless safe_read(io, 9) =~ PDF_MARKER
 
-    FormatParser::Document.new(format: :pdf)
+    FormatParser::Document.new(format: :pdf, content_type: PDF_CONTENT_TYPE)
   end
 
   FormatParser.register_parser new, natures: :document, formats: :pdf, priority: 1

data/lib/parsers/png_parser.rb

@@ -14,6 +14,7 @@ class FormatParser::PNGParser
     4 => true, # Grayscale with alpha
     6 => true,
   }
+  PNG_MIME_TYPE = 'image/png'
 
   def likely_match?(filename)
     filename =~ /\.png$/i
@@ -67,6 +68,7 @@ class FormatParser::PNGParser
       color_mode: color_mode,
       has_multiple_frames: has_animation,
       num_animation_or_video_frames: num_frames,
+      content_type: PNG_MIME_TYPE,
     )
   end
 

data/lib/parsers/psd_parser.rb

@@ -2,6 +2,7 @@ class FormatParser::PSDParser
   include FormatParser::IOUtils
 
   PSD_HEADER = [0x38, 0x42, 0x50, 0x53]
+  PSD_MIME_TYPE = 'application/x-photoshop'
 
   def likely_match?(filename)
     filename =~ /\.psd$/i # Maybe also PSB at some point
@@ -20,6 +21,7 @@ class FormatParser::PSDParser
       format: :psd,
       width_px: w,
       height_px: h,
+      content_type: PSD_MIME_TYPE,
     )
   end
 

data/lib/parsers/tiff_parser.rb

@@ -5,6 +5,8 @@ class FormatParser::TIFFParser
   MAGIC_LE = [0x49, 0x49, 0x2A, 0x0].pack('C4')
   MAGIC_BE = [0x4D, 0x4D, 0x0, 0x2A].pack('C4')
   HEADER_BYTES = [MAGIC_LE, MAGIC_BE]
+  TIFF_MIME_TYPE = 'image/tiff'
+  ARW_MIME_TYPE = 'image/x-sony-arw'
 
   def likely_match?(filename)
     filename =~ /\.tiff?$/i
@@ -14,7 +16,10 @@ class FormatParser::TIFFParser
     io = FormatParser::IOConstraint.new(io)
 
     return unless HEADER_BYTES.include?(safe_read(io, 4))
-    io.seek(io.pos + 2) # Skip over the offset of the IFD, EXIFR will re-read it anyway
+
+    # Skip over the offset of the IFD,
+    # EXIFR will re-read it anyway
+    io.seek(io.pos + 2)
     return if cr2?(io)
 
     # The TIFF scanner in EXIFR is plenty good enough,
@@ -26,14 +31,17 @@ class FormatParser::TIFFParser
     w = exif_data.width || exif_data.pixel_x_dimension
     h = exif_data.height || exif_data.pixel_y_dimension
 
+    format = arw?(exif_data) ? :arw : :tif
+    mime_type = arw?(exif_data) ? ARW_MIME_TYPE : TIFF_MIME_TYPE
     FormatParser::Image.new(
-      format: arw?(exif_data) ? :arw : :tif, # Specify format as arw for Sony ARW format images, else tif
+      format: format,
       width_px: w,
       height_px: h,
       display_width_px: exif_data.rotated? ? h : w,
       display_height_px: exif_data.rotated? ? w : h,
       orientation: exif_data.orientation_sym,
       intrinsics: {exif: exif_data},
+      content_type: mime_type,
     )
   rescue EXIFR::MalformedTIFF
     nil

data/lib/parsers/wav_parser.rb

@@ -1,6 +1,8 @@
 class FormatParser::WAVParser
   include FormatParser::IOUtils
 
+  WAV_MIME_TYPE = 'audio/x-wav'
+
   def likely_match?(filename)
     filename =~ /\.wav$/i
   end
@@ -96,6 +98,7 @@ class FormatParser::WAVParser
       audio_sample_rate_hz: fmt_data[:sample_rate],
       media_duration_frames: sample_frames,
       media_duration_seconds: duration_in_seconds,
+      content_type: WAV_MIME_TYPE,
     )
   end
 

data/lib/parsers/zip_parser/office_formats.rb

@@ -37,15 +37,15 @@ module FormatParser::ZIPParser::OfficeFormats
     OFFICE_MARKER_FILES.subset?(filenames_set)
   end
 
-  def office_file_format_from_entry_set(filenames_set)
+  def office_file_format_and_mime_type_from_entry_set(filenames_set)
     if filenames_set.include?('word/document.xml')
-      :docx
+      [:docx, 'application/vnd.openxmlformats-officedocument.wordprocessingml.document']
     elsif filenames_set.include?('xl/workbook.xml')
-      :xlsx
+      [:xlsx, 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet']
     elsif filenames_set.include?('ppt/presentation.xml')
-      :pptx
+      [:pptx, 'application/vnd.openxmlformats-officedocument.presentationml.presentation']
     else
-      :unknown
+      [:unknown, 'application/zip']
     end
   end
 end

data/lib/parsers/zip_parser.rb

@@ -5,6 +5,8 @@ class FormatParser::ZIPParser
   include OfficeFormats
   include FormatParser::IOUtils
 
+  ZIP_MIME_TYPE = 'application/zip'
+
   def likely_match?(filename)
     filename =~ /\.(zip|docx|keynote|numbers|pptx|xlsx)$/i
   end
@@ -25,10 +27,10 @@ class FormatParser::ZIPParser
     end
 
     if office_document?(filenames_set)
-      office_format = office_file_format_from_entry_set(filenames_set)
-      FormatParser::Archive.new(nature: :document, format: office_format, entries: entries_archive)
+      office_format, mime_type = office_file_format_and_mime_type_from_entry_set(filenames_set)
+      FormatParser::Archive.new(nature: :document, format: office_format, entries: entries_archive, content_type: mime_type)
     else
-      FormatParser::Archive.new(nature: :archive,  format: :zip, entries: entries_archive)
+      FormatParser::Archive.new(nature: :archive,  format: :zip, entries: entries_archive, content_type: ZIP_MIME_TYPE)
     end
   rescue FileReader::Error
     # This is not a ZIP, or a broken ZIP.

data/lib/remote_io.rb

@@ -24,8 +24,11 @@ class FormatParser::RemoteIO
   end
 
   # @param uri[URI, String] the remote URL to obtain
-  def initialize(uri)
+  # @param headers[Hash] (optional) the HTTP headers to be used in the HTTP request
+  def initialize(uri, headers: {})
     require 'faraday'
+    require 'faraday_middleware/response/follow_redirects'
+    @headers = headers
     @uri = uri
     @pos = 0
     @remote_size = false
@@ -78,21 +81,40 @@ class FormatParser::RemoteIO
     # We use a GET and not a HEAD request followed by a GET because
     # S3 does not allow HEAD requests if you only presigned your URL for GETs, so we
     # combine the first GET of a segment and retrieving the size of the resource
-    response = Faraday.get(@uri, nil, range: 'bytes=%d-%d' % [range.begin, range.end])
+    conn = Faraday.new(headers: @headers) do |faraday|
+      faraday.use FaradayMiddleware::FollowRedirects
+      # we still need the default adapter, more details: https://blog.thecodewhisperer.com/permalink/losing-time-to-faraday
+      faraday.adapter Faraday.default_adapter
+    end
+    response = conn.get(@uri, nil, range: 'bytes=%d-%d' % [range.begin, range.end])
 
     case response.status
-    when 200, 206
+    when 200
+      # S3 returns 200 when you request a Range that is fully satisfied by the entire object,
+      # we take that into account here. Also, for very tiny responses (and also for empty responses)
+      # the responses are going to be 200 which does not mean we cannot proceed
+      # To have a good check for both of these conditions we need to know whether the ranges overlap fully
+      response_size = response.body.bytesize
+      requested_range_size = range.end - range.begin + 1
+      if response_size > requested_range_size
+        error_message = [
+          "We requested #{requested_range_size} bytes, but the server sent us more",
+          "(#{response_size} bytes) - it likely has no `Range:` support.",
+          "The error occurred when talking to #{@uri})"
+        ]
+        raise InvalidRequest.new(response.status, error_message.join("\n"))
+      end
+      [response_size, response.body]
+    when 206
       # Figure out of the server supports content ranges, if it doesn't we have no
       # business working with that server
       range_header = response.headers['Content-Range']
-      raise InvalidRequest.new(response.status, "No range support at #{@uri}") unless range_header
+      raise InvalidRequest.new(response.status, "The server replied with 206 status but no Content-Range at #{@uri}") unless range_header
 
       # "Content-Range: bytes 0-0/307404381" is how the response header is structured
       size = range_header[/\/(\d+)$/, 1].to_i
 
-      # S3 returns 200 when you request a Range that is fully satisfied by the entire object,
-      # we take that into account here. For other servers, 206 is the expected response code.
-      # Also, if we request a _larger_ range than what can be satisfied by the server,
+      # If we request a _larger_ range than what can be satisfied by the server,
       # the response is going to only contain what _can_ be sent and the status is also going
       # to be 206
       return [size, response.body]

data/lib/text.rb

@@ -5,6 +5,7 @@ module FormatParser
     NATURE = :text
 
     attr_accessor :format
+    attr_accessor :content_type
 
     # Only permits assignments via defined accessors
     def initialize(**attributes)

data/lib/video.rb

@@ -23,6 +23,9 @@ module FormatParser
     # it can be placed here
     attr_accessor :intrinsics
 
+    # The MIME type of the video
+    attr_accessor :content_type
+
     # Only permits assignments via defined accessors
     def initialize(**attributes)
       attributes.map { |(k, v)| public_send("#{k}=", v) }

data/spec/parsers/aiff_parser_spec.rb

@@ -10,6 +10,7 @@ describe FormatParser::AIFFParser do
     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)
+    expect(parse_result.content_type).to eq('audio/x-aiff')
   end
 
   it 'parses a Logic Pro created AIFF sample file having a COMT chunk before a COMM chunk' do

data/spec/parsers/bmp_parser_spec.rb

@@ -13,6 +13,8 @@ describe FormatParser::BMPParser do
     expect(parsed.width_px).to eq(40)
     expect(parsed.height_px).to eq(27)
 
+    expect(parsed.content_type).to eq('image/bmp')
+
     expect(parsed.intrinsics).not_to be_nil
     expect(parsed.intrinsics[:vertical_resolution]).to eq(2834)
     expect(parsed.intrinsics[:horizontal_resolution]).to eq(2834)
@@ -32,6 +34,8 @@ describe FormatParser::BMPParser do
     expect(parsed.width_px).to eq(1920)
     expect(parsed.height_px).to eq(1080)
 
+    expect(parsed.content_type).to eq('image/bmp')
+
     expect(parsed.intrinsics).not_to be_nil
     expect(parsed.intrinsics[:vertical_resolution]).to eq(2835)
     expect(parsed.intrinsics[:horizontal_resolution]).to eq(2835)
@@ -51,6 +55,8 @@ describe FormatParser::BMPParser do
     expect(parsed.width_px).to eq(200)
     expect(parsed.height_px).to eq(200)
 
+    expect(parsed.content_type).to eq('image/bmp')
+
     expect(parsed.intrinsics).not_to be_nil
   end
 
@@ -64,6 +70,7 @@ describe FormatParser::BMPParser do
     expect(parsed.color_mode).to eq(:rgb)
     expect(parsed.width_px).to eq(40)
     expect(parsed.height_px).to eq(27)
+    expect(parsed.content_type).to eq('image/bmp')
     expect(parsed.intrinsics[:bits_per_pixel]).to eq(24)
     expect(parsed.intrinsics[:data_order]).to eq(:normal)
 
@@ -76,6 +83,7 @@ describe FormatParser::BMPParser do
     expect(parsed.color_mode).to eq(:rgb)
     expect(parsed.width_px).to eq(40)
     expect(parsed.height_px).to eq(27)
+    expect(parsed.content_type).to eq('image/bmp')
     expect(parsed.intrinsics[:bits_per_pixel]).to eq(24)
     expect(parsed.intrinsics[:data_order]).to eq(:normal)
   end

data/spec/parsers/cr2_parser_spec.rb

@@ -17,6 +17,7 @@ describe FormatParser::CR2Parser do
         expect(parsed.height_px).to be > 0
 
         expect(parsed.orientation).not_to be_nil
+        expect(parsed.content_type).to eq('image/x-canon-cr2')
       end
     end
   end

data/spec/parsers/dpx_parser_spec.rb

@@ -15,6 +15,7 @@ describe FormatParser::DPXParser do
       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)
+      expect(parsed.content_type).to eq('image/x-dpx')
     end
   end
 

data/spec/parsers/flac_parser_spec.rb

@@ -14,6 +14,7 @@ describe FormatParser::FLACParser do
     expect(parsed.intrinsics).not_to be_nil
     expect(parsed.media_duration_frames).to eq(33810)
     expect(parsed.media_duration_seconds).to be_within(0.1).of(0.836)
+    expect(parsed.content_type).to eq('audio/x-flac')
   end
 
   it 'decodes and estimates duration for the 16bit FLAC File' do

data/spec/parsers/gif_parser_spec.rb

@@ -17,6 +17,7 @@ describe FormatParser::GIFParser do
 
         expect(parsed.height_px).to be_kind_of(Integer)
         expect(parsed.height_px).to be > 0
+        expect(parsed.content_type).to eq('image/gif')
       end
     end
   end

data/spec/parsers/jpeg_parser_spec.rb

@@ -14,6 +14,7 @@ describe FormatParser::JPEGParser do
 
         expect(parsed.height_px).to be_kind_of(Integer)
         expect(parsed.height_px).to be > 0
+        expect(parsed.content_type).to eq('image/jpeg')
       end
     end
   end

data/spec/parsers/m3u_parser_spec.rb

@@ -25,6 +25,7 @@ describe FormatParser::M3UParser do
       expect(parsed_m3u).not_to be_nil
       expect(parsed_m3u.nature).to eq(:text)
       expect(parsed_m3u.format).to eq(:m3u)
+      expect(parsed_m3u.content_type).to eq('application/vnd.apple.mpegurl')
     end
   end
 

data/spec/parsers/moov_parser_spec.rb

@@ -37,7 +37,7 @@ describe FormatParser::MOOVParser do
       expect(result.nature).to eq(:audio)
       expect(result.media_duration_seconds).to be_kind_of(Float)
       expect(result.media_duration_seconds).to be > 0
-
+      expect(result.content_type).to be_kind_of(String)
       expect(result.intrinsics).not_to be_nil
     end
   end
@@ -52,6 +52,7 @@ describe FormatParser::MOOVParser do
       expect(result.height_px).to be > 0
       expect(result.media_duration_seconds).to be_kind_of(Float)
       expect(result.media_duration_seconds).to be > 0
+      expect(result.content_type).to eq('video/mp4')
 
       expect(result.intrinsics).not_to be_nil
     end
@@ -67,6 +68,7 @@ describe FormatParser::MOOVParser do
       expect(result.height_px).to be > 0
       expect(result.media_duration_seconds).to be_kind_of(Float)
       expect(result.media_duration_seconds).to be > 0
+      expect(result.content_type).to eq('video/mp4')
 
       expect(result.intrinsics).not_to be_nil
     end
@@ -79,6 +81,7 @@ describe FormatParser::MOOVParser do
     expect(result).not_to be_nil
     expect(result.nature).to eq(:audio)
     expect(result.format).to eq(:m4a)
+    expect(result.content_type).to eq('audio/mp4')
   end
 
   it 'parses a MOV file and provides the necessary metadata' do

data/spec/parsers/mp3_parser_spec.rb

@@ -23,6 +23,7 @@ describe FormatParser::MP3Parser do
 
     expect(parsed.nature).to eq(:audio)
     expect(parsed.format).to eq(:mp3)
+    expect(parsed.content_type).to eq('audio/mpeg')
     expect(parsed.num_audio_channels).to eq(2)
     expect(parsed.audio_sample_rate_hz).to eq(48000)
     expect(parsed.intrinsics).not_to be_nil

data/spec/parsers/ogg_parser_spec.rb

@@ -6,6 +6,7 @@ describe FormatParser::OggParser do
 
     expect(parse_result.nature).to eq(:audio)
     expect(parse_result.format).to eq(:ogg)
+    expect(parse_result.content_type).to eq('audio/ogg')
     expect(parse_result.num_audio_channels).to eq(1)
     expect(parse_result.audio_sample_rate_hz).to eq(16000)
     expect(parse_result.media_duration_seconds).to be_within(0.01).of(2973.95)

data/spec/parsers/pdf_parser_spec.rb

@@ -17,6 +17,7 @@ describe FormatParser::PDFParser do
       expect(parsed_pdf).not_to be_nil
       expect(parsed_pdf.nature).to eq(:document)
       expect(parsed_pdf.format).to eq(:pdf)
+      expect(parsed_pdf.content_type).to eq('application/pdf')
     end
   end
 

data/spec/parsers/png_parser_spec.rb

@@ -15,6 +15,7 @@ describe FormatParser::PNGParser do
 
         expect(parsed.height_px).to be_kind_of(Integer)
         expect(parsed.height_px).to be > 0
+        expect(parsed.content_type).to eq('image/png')
       end
     end
   end

data/spec/parsers/psd_parser_spec.rb

@@ -15,6 +15,7 @@ describe FormatParser::PSDParser do
 
         expect(parsed.height_px).to be_kind_of(Integer)
         expect(parsed.height_px).to be > 0
+        expect(parsed.content_type).to eq('application/x-photoshop')
       end
     end
   end

data/spec/parsers/tiff_parser_spec.rb

@@ -59,6 +59,7 @@ describe FormatParser::TIFFParser do
     expect(parsed.width_px).to eq(7952)
     expect(parsed.height_px).to eq(5304)
     expect(parsed.intrinsics[:exif]).not_to be_nil
+    expect(parsed.content_type).to eq('image/x-sony-arw')
   end
 
   describe 'correctly extracts dimensions from various TIFF flavors of the same file' do

data/spec/parsers/wav_parser_spec.rb

@@ -9,6 +9,7 @@ describe FormatParser::WAVParser do
 
       expect(parse_result.nature).to eq(:audio)
       expect(parse_result.format).to eq(:wav)
+      expect(parse_result.content_type).to eq('audio/x-wav')
     end
   end
 

data/spec/parsers/zip_parser_spec.rb

@@ -14,6 +14,7 @@ describe FormatParser::ZIPParser do
     expect(result).not_to be_nil
 
     expect(result.format).to eq(:zip)
+    expect(result.content_type).to eq('application/zip')
     expect(result.nature).to eq(:archive)
     expect(result.entries.length).to eq(0xFFFF + 1)
 
@@ -58,6 +59,7 @@ describe FormatParser::ZIPParser do
     result = subject.call(fi_io)
     expect(result.nature).to eq(:document)
     expect(result.format).to eq(:docx)
+    expect(result.content_type).to eq('application/vnd.openxmlformats-officedocument.wordprocessingml.document')
 
     fixture_path = fixtures_dir + '/ZIP/sample-docx.docx'
     fi_io = File.open(fixture_path, 'rb')

data/spec/remote_fetching_spec.rb

@@ -15,18 +15,31 @@ describe 'Fetching data from HTTP remotes' do
     }
     @server = WEBrick::HTTPServer.new(options)
     @server.mount '/', WEBrick::HTTPServlet::FileHandler, fixtures_dir
+    @server.mount_proc '/redirect' do |req, res|
+      res.status = 302
+      res.header['Location'] = req.path.sub('/redirect', '')
+    end
+    @server.mount_proc '/empty' do |_req, res|
+      res.status = 200
+      res.body = ''
+    end
+    @server.mount_proc '/tiny' do |_req, res|
+      res.status = 200
+      res.body = File.read(fixtures_dir + '/test.gif')
+    end
+
     trap('INT') { @server.stop }
     @server_thread = Thread.new { @server.start }
   end
 
-  it '#parse_http is called without any option' do
+  it 'works with .parse_http called without any options' do
     result = FormatParser.parse_http('http://localhost:9399/PNG/anim.png')
 
     expect(result.format).to eq(:png)
     expect(result.height_px).to eq(180)
   end
 
-  it '#parse_http is called with hash options' do
+  it 'works with .parse_http called with additional options' do
     fake_result = double(nature: :audio, format: :aiff)
     expect_any_instance_of(FormatParser::AIFFParser).to receive(:call).and_return(fake_result)
     results = FormatParser.parse_http('http://localhost:9399/PNG/anim.png', results: :all)
@@ -35,6 +48,18 @@ describe 'Fetching data from HTTP remotes' do
     expect(results).to include(fake_result)
   end
 
+  it 'is able to cope with a 0-size resource which does not provide Content-Range' do
+    file_information = FormatParser.parse_http('http://localhost:9399/empty')
+
+    expect(file_information).to be_nil
+  end
+
+  it 'is able to cope with a tiny resource which fits into the first requested range completely' do
+    file_information = FormatParser.parse_http('http://localhost:9399/tiny')
+    expect(file_information).not_to be_nil
+    expect(file_information.nature).to eq(:image)
+  end
+
   it 'parses the animated PNG over HTTP' do
     file_information = FormatParser.parse_http('http://localhost:9399/PNG/anim.png')
     expect(file_information).not_to be_nil
@@ -91,6 +116,32 @@ describe 'Fetching data from HTTP remotes' do
     end
   end
 
+  context 'when the server responds with a redirect' do
+    it 'follows the redirect' do
+      file_information = FormatParser.parse_http('http://localhost:9399/redirect/TIFF/test.tif')
+      expect(file_information.format).to eq(:tif)
+    end
+  end
+
+  it 'sends provided HTTP headers in the request' do
+    # Faraday is required only after calling .parse_http
+    # This line is just to trigger this require, then it's possible to
+    # add an expectation of how Faraday is initialized after.
+    FormatParser.parse_http('invalid_url') rescue nil
+
+    expect(Faraday)
+      .to receive(:new)
+      .with(headers: {'test-header' => 'test-value'})
+      .and_call_original
+
+    file_information = FormatParser.parse_http(
+      'http://localhost:9399//TIFF/test.tif',
+      headers: {'test-header' => 'test-value'}
+    )
+
+    expect(file_information.format).to eq(:tif)
+  end
+
   after(:all) do
     @server.stop
     @server_thread.join(0.5)

data/spec/remote_io_spec.rb

@@ -7,7 +7,9 @@ describe FormatParser::RemoteIO do
     rio = described_class.new('https://images.invalid/img.jpg')
 
     fake_resp = double(headers: {'Content-Range' => '10-109/2577'}, status: 206, body: 'This is the response')
-    expect(Faraday).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=10-109').and_return(fake_resp)
+    faraday_conn = instance_double(Faraday::Connection, get: fake_resp)
+    allow(Faraday).to receive(:new).and_return(faraday_conn)
+    expect(faraday_conn).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=10-109')
 
     rio.seek(10)
     read_result = rio.read(100)
@@ -18,7 +20,9 @@ describe FormatParser::RemoteIO do
     rio = described_class.new('https://images.invalid/img.jpg')
 
     fake_resp = double(headers: {'Content-Range' => '10-109/2577'}, status: 200, body: 'This is the response')
-    expect(Faraday).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=10-109').and_return(fake_resp)
+    faraday_conn = instance_double(Faraday::Connection, get: fake_resp)
+    allow(Faraday).to receive(:new).and_return(faraday_conn)
+    expect(faraday_conn).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=10-109')
 
     rio.seek(10)
     read_result = rio.read(100)
@@ -29,7 +33,9 @@ describe FormatParser::RemoteIO do
     rio = described_class.new('https://images.invalid/img.jpg')
 
     fake_resp = double(headers: {}, status: 403, body: 'Please log in')
-    expect(Faraday).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199').and_return(fake_resp)
+    faraday_conn = instance_double(Faraday::Connection, get: fake_resp)
+    allow(Faraday).to receive(:new).and_return(faraday_conn)
+    expect(faraday_conn).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199')
 
     rio.seek(100)
     expect { rio.read(100) }.to raise_error(/replied with a 403 and refused/)
@@ -39,7 +45,9 @@ describe FormatParser::RemoteIO do
     rio = described_class.new('https://images.invalid/img.jpg')
 
     fake_resp = double(headers: {}, status: 416, body: 'You stepped off the ledge of the range')
-    expect(Faraday).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199').and_return(fake_resp)
+    faraday_conn = instance_double(Faraday::Connection, get: fake_resp)
+    allow(Faraday).to receive(:new).and_return(faraday_conn)
+    expect(faraday_conn).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199')
 
     rio.seek(100)
     expect(rio.read(100)).to be_nil
@@ -49,7 +57,9 @@ describe FormatParser::RemoteIO do
     rio = described_class.new('https://images.invalid/img.jpg')
 
     fake_resp = double(headers: {}, status: 403, body: 'Please log in')
-    expect(Faraday).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199').and_return(fake_resp)
+    faraday_conn = instance_double(Faraday::Connection, get: fake_resp)
+    allow(Faraday).to receive(:new).and_return(faraday_conn)
+    expect(faraday_conn).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199')
 
     rio.seek(100)
     # rubocop: disable Lint/AmbiguousBlockAssociation
@@ -60,7 +70,9 @@ describe FormatParser::RemoteIO do
     rio = described_class.new('https://images.invalid/img.jpg')
 
     fake_resp = double(headers: {}, status: 416, body: 'You jumped off the end of the file maam')
-    expect(Faraday).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199').and_return(fake_resp)
+    faraday_conn = instance_double(Faraday::Connection, get: fake_resp)
+    allow(Faraday).to receive(:new).and_return(faraday_conn)
+    expect(faraday_conn).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199')
 
     rio.seek(100)
     expect(rio.read(100)).to be_nil
@@ -69,15 +81,24 @@ describe FormatParser::RemoteIO do
   it 'does not overwrite size when the range cannot be satisfied and the response is 416' do
     rio = described_class.new('https://images.invalid/img.jpg')
 
-    fake_resp = double(headers: {'Content-Range' => 'bytes 0-0/13'}, status: 206, body: 'a')
-    expect(Faraday).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=0-0').and_return(fake_resp)
+    fake_resp1 = double(headers: {'Content-Range' => 'bytes 0-0/13'}, status: 206, body: 'a')
+    fake_resp2 = double(headers: {}, status: 416, body: 'You jumped off the end of the file maam')
+
+    faraday_conn = instance_double(Faraday::Connection)
+    allow(Faraday).to receive(:new).and_return(faraday_conn)
+    expect(faraday_conn).to receive(:get)
+      .with('https://images.invalid/img.jpg', nil, range: 'bytes=0-0')
+      .ordered
+      .and_return(fake_resp1)
+    expect(faraday_conn).to receive(:get)
+      .with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199')
+      .ordered
+      .and_return(fake_resp2)
+
     rio.read(1)
 
     expect(rio.size).to eq(13)
 
-    fake_resp = double(headers: {}, status: 416, body: 'You jumped off the end of the file maam')
-    expect(Faraday).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199').and_return(fake_resp)
-
     rio.seek(100)
     expect(rio.read(100)).to be_nil
 
@@ -88,7 +109,9 @@ describe FormatParser::RemoteIO do
     rio = described_class.new('https://images.invalid/img.jpg')
 
     fake_resp = double(headers: {}, status: 502, body: 'Guru meditation')
-    expect(Faraday).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199').and_return(fake_resp)
+    faraday_conn = instance_double(Faraday::Connection, get: fake_resp)
+    allow(Faraday).to receive(:new).and_return(faraday_conn)
+    expect(faraday_conn).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199')
 
     rio.seek(100)
     expect { rio.read(100) }.to raise_error(/replied with a 502 and we might want to retry/)
@@ -100,7 +123,9 @@ describe FormatParser::RemoteIO do
     expect(rio.pos).to eq(0)
 
     fake_resp = double(headers: {'Content-Range' => 'bytes 0-0/13'}, status: 206, body: 'a')
-    expect(Faraday).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=0-0').and_return(fake_resp)
+    faraday_conn = instance_double(Faraday::Connection, get: fake_resp)
+    allow(Faraday).to receive(:new).and_return(faraday_conn)
+    expect(faraday_conn).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=0-0')
     rio.read(1)
 
     expect(rio.pos).to eq(1)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: format_parser
 version: !ruby/object:Gem::Version
-  version: 0.26.0
+  version: 0.29.1
 platform: ruby
 authors:
 - Noah Berman
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-08 00:00:00.000000000 Z
+date: 2021-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ks
@@ -73,6 +73,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.13'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
 - !ruby/object:Gem::Dependency
   name: measurometer
   requirement: !ruby/object:Gem::Requirement
@@ -183,10 +197,10 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/main.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
-- ".travis.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - CONTRIBUTING.md

data/.travis.yml

@@ -1,12 +0,0 @@
-rvm:
-- 2.2.10
-- 2.3.8
-- 2.4.9
-- 2.5.8
-- 2.6.6
-- 2.7.2
-- jruby
-sudo: false
-cache: bundler
-script:
-  - bundle exec rake