assembly-image 2.0.0 → 2.1.1

data/lib/assembly/image.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'vips'
+require 'assembly-objectfile'
+require_relative 'image/jp2_creator'
+
+module Assembly
+  # The Image class contains methods to operate on an image.
+  class Image < Assembly::ObjectFile
+    # @return [integer] image height in pixels
+    def height
+      vips_image.height
+    end
+
+    # @return [integer] image width in pixels
+    def width
+      vips_image.width
+    end
+
+    # @return [string] full default jp2 path and filename that will be created from the given image
+    # Example:  given original file of '/dir/path_to_file.tif', gives '/dir/path_to_file.jp2'
+    def jp2_filename
+      # path is a property on Assembly::ObjectFile
+      File.extname(path).empty? ? "#{path}.jp2" : path.gsub(File.extname(path), '.jp2')
+    end
+
+    # Create a JP2 file for the current image.
+    # Important note: this will not work for multipage TIFFs.
+    #
+    # @param [String] output path to the output JP2 file (default: mirrors the source file name and path, but with a .jp2 extension)
+    # @param [Boolean] overwrite if set to false, an existing JP2 file with the same name won't be overwritten (default: false)
+    # @param [Dir] tmp_folder the temporary folder to use when creating the jp2 (default: '/tmp'); also used by imagemagick
+    # @return [Assembly::Image] object containing the generated JP2 file
+    #
+    # Example:
+    #   source_img = Assembly::Image.new('/dir/path_to_file.tif')
+    #   jp2_img = source_img.create_jp2(overwrite: true)
+    #   jp2_img.mimetype # 'image/jp2'
+    #   jp2_img.path # '/dir/path_to_file.jp2'
+    def create_jp2(**params)
+      Jp2Creator.create(self, **params)
+    end
+
+    def vips_image
+      # Disable cache. Otherwise, Vips gets confused by files with the same filename.
+      Vips.cache_set_max_files(0)
+      # autorot will only affect images that need rotation: https://www.libvips.org/API/current/libvips-conversion.html#vips-autorot
+      @vips_image ||= Vips::Image.new_from_file(path).autorot
+    end
+
+    def srgb?
+      vips_image.interpretation == :srgb
+    end
+
+    # Does the image include an ICC profile?
+    def has_profile?
+      vips_image.get_fields.include?('icc-profile-data')
+    end
+  end
+end

data/lib/assembly-image.rb

@@ -2,11 +2,10 @@
 
 module Assembly
   # the path to the gem, used to access profiles stored with the gem
-  PATH_TO_IMAGE_GEM = File.expand_path(File.dirname(__FILE__) + '/..')
+  PATH_TO_IMAGE_GEM = File.expand_path("#{File.dirname(__FILE__)}/..")
   PATH_TO_PROFILES = File.join(Assembly::PATH_TO_IMAGE_GEM, 'profiles')
   SRGB_ICC = File.join(PATH_TO_PROFILES, 'sRGBIEC6196621.icc')
   CMYK_ICC = File.join(PATH_TO_PROFILES, 'cmyk.icc')
 end
 
-require 'assembly-image/image'
-require 'assembly-image/images'
+require 'assembly/image'

data/spec/assembly/image/jp2_creator_spec.rb

@@ -3,52 +3,345 @@
 require 'spec_helper'
 
 RSpec.describe Assembly::Image::Jp2Creator do
-  subject(:result) { creator.create }
+  let(:jp2creator) { described_class.new(assembly_image, output: jp2_output_file) }
+  let(:assembly_image) { Assembly::Image.new(input_path) }
+  let(:jp2_output_file) { File.join(TEST_OUTPUT_DIR, 'test.jp2') }
 
-  let(:ai) { Assembly::Image.new(input_path) }
-  let(:input_path) { TEST_TIF_INPUT_FILE }
-  let(:creator) { described_class.new(ai, output: TEST_JP2_OUTPUT_FILE) }
+  describe '.create' do
+    subject(:result) { jp2creator.create }
 
-  before { cleanup }
+    let(:input_path) { TEST_TIF_INPUT_FILE }
 
-  context 'when given an LZW compressed RGB tif' do
-    before do
-      generate_test_image(TEST_TIF_INPUT_FILE, compress: 'lzw')
+    before { cleanup }
+
+    context 'when input path is blank' do
+      let(:input_path) { '' }
+
+      it 'raises error' do
+        expect { assembly_image.create_jp2 }.to raise_error(RuntimeError, 'input file  does not exist or is a directory')
+      end
     end
 
-    it 'creates the jp2 with a temp file' do
-      expect(File).to exist TEST_TIF_INPUT_FILE
-      expect(File).not_to exist TEST_JP2_OUTPUT_FILE
-      expect(result).to be_a_kind_of Assembly::Image
-      expect(result.path).to eq TEST_JP2_OUTPUT_FILE
-      expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+    context 'when tmp folder does not exist' do
+      before do
+        generate_test_image(input_path)
+      end
 
-      # Indicates a temp tiff was not created.
-      expect(creator.tmp_path).not_to be_nil
-      expect(result.exif.colorspace).to eq 'sRGB'
-      jp2 = Assembly::Image.new(TEST_JP2_OUTPUT_FILE)
-      expect(jp2.height).to eq 36
-      expect(jp2.width).to eq 43
+      it 'raises error' do
+        bogus_folder = '/nonexisting'
+        expect(File).not_to exist bogus_folder
+        expect { assembly_image.create_jp2(tmp_folder: bogus_folder) }.to raise_error(RuntimeError, 'tmp_folder /nonexisting does not exist')
+      end
     end
-  end
 
-  context 'when the input file is a JPEG' do
-    before do
-      generate_test_image(TEST_JPEG_INPUT_FILE)
+    context 'when no output file is specified' do
+      let(:jp2creator) { described_class.new(assembly_image) }
+      let(:jp2_output_file) { File.join(TEST_INPUT_DIR, File.basename(input_path).gsub('.tif', '.jp2')) }
+
+      before do
+        generate_test_image(input_path)
+      end
+
+      it 'creates a jp2 of the same filename and in the same location as the input' do
+        expect(File).to exist input_path # test image was generated
+        expect(File).not_to exist jp2_output_file
+        expect(assembly_image.srgb?).to be true
+        expect(assembly_image.has_profile?).to be false
+
+        expect(result).to be_a_kind_of Assembly::Image
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+        # check srgb on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.srgb?).to be true
+        expect(tmp_tiff_image.has_profile?).to be false
+      end
+    end
+
+    context 'when the output file exists and no overwriting' do
+      before do
+        generate_test_image(input_path)
+        FileUtils.touch(jp2_output_file) # just need a file with this name, don't care what
+      end
+
+      it 'raises error' do
+        expect(File).to exist input_path # test image was generated
+        expect { assembly_image.create_jp2(output: jp2_output_file) }.to raise_error(SecurityError, %r{spec/test_data/output/test.jp2 exists, cannot overwrite})
+      end
+    end
+
+    context 'when the output file exists and overwriting allowed' do
+      before do
+        generate_test_image(input_path)
+        FileUtils.touch(jp2_output_file) # just need a file with this name, don't care what
+      end
+
+      it 'recreates jp2' do
+        expect(File).to exist input_path # test image was generated
+        expect(File).to exist jp2_output_file
+        expect(assembly_image.srgb?).to be true
+        expect(assembly_image.has_profile?).to be false
+
+        result = assembly_image.create_jp2(output: jp2_output_file, overwrite: true)
+        expect(result).to be_a_kind_of Assembly::Image
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+        # check srgb on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.srgb?).to be true
+        expect(tmp_tiff_image.has_profile?).to be false
+      end
+    end
+
+    context 'when the input file is a jp2' do
+      let(:input_path) { File.join(TEST_INPUT_DIR, 'for_jp2.tif') }
+
+      before do
+        generate_test_image(input_path)
+      end
+
+      it 'raises error' do
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+
+        expect { described_class.new(Assembly::Image.new(jp2_output_file)).create }.to raise_error(RuntimeError, 'input file is not a valid image, or is the wrong mimetype')
+      end
+    end
+
+    context 'when given a tiff' do
+      before do
+        generate_test_image(input_path)
+      end
+
+      it 'gets the correct image, creates and cleans up the temporary tiff' do
+        expect(File).to exist input_path # test image was generated
+        expect(File).not_to exist jp2_output_file
+
+        expect(result).to be_a_kind_of Assembly::Image
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+        # check height and width on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.height).to eq 36
+        expect(tmp_tiff_image.width).to eq 43
+
+        expect(jp2creator.tmp_tiff_path).not_to be_nil # temporary tiff was created
+        expect(File).not_to exist jp2creator.tmp_tiff_path # the temporary tiff path is cleaned up
+      end
+    end
+
+    context 'when given an LZW compressed RGB tif' do
+      let(:input_path) { File.join(TEST_INPUT_DIR, 'lzw.tif') }
+
+      before do
+        generate_test_image(input_path, compress: 'lzw')
+      end
+
+      it 'creates the jp2' do
+        expect(File).to exist input_path
+        expect(File).not_to exist jp2_output_file
+
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+        # check height and width on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.height).to eq 36
+        expect(tmp_tiff_image.width).to eq 43
+      end
+    end
+
+    context 'when given a cmyk tif' do
+      let(:input_path) { File.join(TEST_INPUT_DIR, 'test-cmyk.tif') }
+
+      before do
+        generate_test_image(input_path, color: 'cmyk', cg_type: 'cmyk', profile: 'cmyk', bands: 4)
+      end
+
+      it 'creates an srgb jp2' do
+        expect(File).to exist input_path
+        expect(File).not_to exist jp2_output_file
+        expect(assembly_image.srgb?).to be false
+        expect(assembly_image.vips_image.interpretation).to eq :cmyk
+        expect(assembly_image.has_profile?).to be true
+
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+
+        # NOTE: we verify the CMYK has been converted to an SRGB JP2 correctly by using ruby-vips;
+        #   we have to verify this on the *temporary tiff because lipvips pkg available for circleci does not speak JP2
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.srgb?).to be true
+        expect(tmp_tiff_image.has_profile?).to be true
+      end
+    end
+
+    context 'when the input file is a JPEG' do
+      let(:input_path) { File.join(TEST_INPUT_DIR, 'test.jpg') }
+
+      before do
+        generate_test_image(input_path)
+      end
+
+      it 'creates jp2 when given a JPEG' do
+        expect(File).to exist input_path # test image was generated
+        expect(File).not_to exist jp2_output_file
+
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+        # check height and width on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.height).to eq 36
+        expect(tmp_tiff_image.width).to eq 43
+      end
+    end
+
+    context 'when the source image has no profile' do
+      let(:input_path) { File.join(TEST_INPUT_DIR, 'no_profile.tif') }
+
+      before do
+        generate_test_image(input_path)
+      end
+
+      it 'creates color jp2 without ICC profile' do
+        expect(File).to exist input_path # test image was generated
+        expect(File).not_to exist jp2_output_file
+        expect(assembly_image.srgb?).to be true
+        expect(assembly_image.has_profile?).to be false
+
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+
+        # check srgb on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.srgb?).to be true
+        expect(tmp_tiff_image.has_profile?).to be false
+      end
     end
 
-    let(:input_path) { TEST_JPEG_INPUT_FILE }
+    context 'when given a bitonal tif with bitonal image data' do
+      let(:input_path) { File.join(TEST_INPUT_DIR, 'bitonal.tif') }
+
+      before do
+        # depth of 1 says 1 bit per pixel.
+        generate_test_image(input_path, color: 'bin', bands: 1, depth: 1)
+      end
+
+      it 'creates bitonal jp2 without ICC profile' do
+        expect(File).to exist input_path # test image was generated
+        expect(File).not_to exist jp2_output_file
+        expect(assembly_image.srgb?).to be false
+        expect(assembly_image.vips_image.interpretation).to eq :'b-w'
+        expect(assembly_image.has_profile?).to be false
+
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+
+        # check srgb on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.srgb?).to be false
+        expect(tmp_tiff_image.has_profile?).to be false
+        vips_for_tmp_tiff = tmp_tiff_image.vips_image
+        expect(vips_for_tmp_tiff.bands).to eq 1
+        expect(vips_for_tmp_tiff.interpretation).to eq :'b-w'
+      end
+    end
+
+    context 'when given a color tif but bitonal image data' do
+      # NOTE: this spec was created due to ImageMagick weirdness processing this wrinkle
+      let(:input_path) { File.join(TEST_INPUT_DIR, 'color.tif') }
+
+      before do
+        # from Tony Calavano:
+        #  color: bin should threshold the pixel data to 0 or 255, bands: 3 forces it to be rgb.
+        #  It should then create a 8 bits per pixel image
+        generate_test_image(input_path, color: 'bin', bands: 3)
+      end
+
+      it 'creates color jp2 without ICC profile' do
+        expect(File).to exist input_path # test image was generated
+        expect(File).not_to exist jp2_output_file
+        expect(assembly_image.srgb?).to be true
+        expect(assembly_image.has_profile?).to be false
+
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+
+        # check srgb on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.srgb?).to be true
+        expect(tmp_tiff_image.has_profile?).to be false
+        expect(tmp_tiff_image.vips_image.bands).to eq 3
+      end
+    end
+
+    context 'when given a grayscale tif but with bitonal image data' do
+      # NOTE: this spec was created due to ImageMagick weirdness processing this wrinkle
+      let(:input_path) { File.join(TEST_INPUT_DIR, 'gray.tif') }
+
+      before do
+        # from Tony Calavano:  color: grey, bands: 1 would be a normal grayscale image with 8 bits per pixel
+        generate_test_image(input_path, color: 'bin', bands: 1)
+      end
+
+      it 'creates grayscale jp2 without ICC profile' do
+        expect(File).to exist input_path # test image was generated
+        expect(File).not_to exist jp2_output_file
+        expect(assembly_image.srgb?).to be false
+        expect(assembly_image.has_profile?).to be false
+        expect(assembly_image.vips_image.interpretation).to eq :'b-w'
+
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+
+        # check srgb on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.srgb?).to be false
+        expect(tmp_tiff_image.has_profile?).to be false
+        vips_for_tmp_tiff = tmp_tiff_image.vips_image
+        expect(vips_for_tmp_tiff.bands).to eq 1
+        expect(vips_for_tmp_tiff.interpretation).to eq :'b-w'
+      end
+    end
+
+    context 'when given a color tif but with grayscale image data (3 channels and 8 bits per pixel)' do
+      let(:input_path) { File.join(TEST_INPUT_DIR, 'color_gray.tif') }
+
+      before do
+        # this is bands: 3 with 8 bits per pixel
+        generate_test_image(input_path, color: 'grey')
+      end
+
+      it 'creates color jp2 without ICC profile' do
+        expect(File).to exist input_path # test image was generated
+        expect(File).not_to exist jp2_output_file
+        expect(assembly_image.srgb?).to be true
+        expect(assembly_image.has_profile?).to be false
+
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+
+        # check srgb on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.srgb?).to be true
+        expect(tmp_tiff_image.has_profile?).to be false
+        vips_for_tmp_tiff = tmp_tiff_image.vips_image
+        expect(vips_for_tmp_tiff.bands).to eq 3
+      end
+    end
+  end
+
+  describe '#make_tmp_tiff' do
+    subject(:tiff_file) { jp2creator.send(:make_tmp_tiff) }
 
-    it 'creates jp2 when given a JPEG' do
-      expect(File).to exist TEST_JPEG_INPUT_FILE
-      expect(File).not_to exist TEST_JP2_OUTPUT_FILE
-      expect(result).to be_a_kind_of Assembly::Image
-      expect(result.path).to eq TEST_JP2_OUTPUT_FILE
-      expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+    let(:input_path) { 'spec/test_data/color_rgb_srgb_rot90cw.tif' }
+    let(:vips_output) { Vips::Image.new_from_file(tiff_file) }
+    let(:plum) { [94.0, 58.0, 101.0] }
 
-      # Indicates a temp tiff was created.
-      expect(creator.tmp_path).not_to be_nil
-      expect(File).not_to exist creator.tmp_path
+    context 'when given a tiff with a rotation hint' do
+      it 'rotates it' do
+        expect(Vips::Image.new_from_file(input_path).getpoint(3, 3)).not_to eq plum
+        expect(vips_output.getpoint(3, 3)).to eq plum
+      end
     end
   end
 end

data/spec/assembly/image_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'fileutils'
+
+RSpec.describe Assembly::Image do
+  let(:assembly_image) { described_class.new(input_path) }
+  let(:input_path) { TEST_TIF_INPUT_FILE }
+
+  before { cleanup }
+
+  describe '#jp2_filename' do
+    it 'indicates the default jp2 filename' do
+      expect(assembly_image.jp2_filename).to eq input_path.gsub('.tif', '.jp2')
+    end
+
+    context 'with a file with no extension' do
+      let(:input_path) { '/path/to/a/file_with_no_extension' }
+
+      it 'indicates the default jp2 filename' do
+        expect(assembly_image.jp2_filename).to eq '/path/to/a/file_with_no_extension.jp2'
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -5,20 +5,14 @@ SimpleCov.start do
   add_filter 'spec'
 end
 
-bootfile = File.expand_path(File.dirname(__FILE__) + '/../config/boot')
+bootfile = File.expand_path("#{File.dirname(__FILE__)}/../config/boot")
 require bootfile
-require 'ruby-vips'
 require 'pry-byebug'
 
 TEST_INPUT_DIR       = File.join(Assembly::PATH_TO_IMAGE_GEM, 'spec', 'test_data', 'input')
 TEST_OUTPUT_DIR      = File.join(Assembly::PATH_TO_IMAGE_GEM, 'spec', 'test_data', 'output')
 TEST_TIF_INPUT_FILE  = File.join(TEST_INPUT_DIR, 'test.tif')
 TEST_JPEG_INPUT_FILE = File.join(TEST_INPUT_DIR, 'test.jpg')
-TEST_JP2_INPUT_FILE  = File.join(TEST_INPUT_DIR, 'test.jp2')
-TEST_JP2_OUTPUT_FILE = File.join(TEST_OUTPUT_DIR, 'test.jp2')
-TEST_PROFILE_DIR     = File.join(Assembly::PATH_TO_IMAGE_GEM, 'profiles')
-TEST_DATA_DIR        = File.join(Assembly::PATH_TO_IMAGE_GEM, 'spec', 'test_data')
-TEST_DRUID           = 'nx288wh8889'
 
 RSpec.configure do |config|
   # rspec-expectations config goes here. You can use an alternate
@@ -175,10 +169,10 @@ def generate_test_image(file, params = {})
 
   temp_array = color_gauge_values(cg_type)
   temp_image = Vips::Image.black(width, height, bands: temp_array.first.size)
-  (0..4).each do |i|
+  5.times do |i|
     b = (box_size * i) + (line_size * (i + 1))
     # d = b + box_size - line_size
-    (0...6).each do |j|
+    6.times do |j|
       a = (box_size * j) + (line_size * (j + 1))
       # c = a + box_size - line_size
       colors = temp_array.shift
@@ -204,7 +198,7 @@ def generate_test_image(file, params = {})
 
   options = {}
   unless profile.nil?
-    profile_file = File.join(TEST_PROFILE_DIR, profile + '.icc')
+    profile_file = File.join(Assembly::PATH_TO_IMAGE_GEM, 'profiles', "#{profile}.icc")
     options.merge!(profile: profile_file)
   end
 
@@ -235,14 +229,3 @@ def remove_files(dir)
     File.delete(fn) if !File.directory?(fn) && File.basename(fn) != '.empty'
   end
 end
-
-RSpec::Matchers.define :be_a_jp2 do
-  match do |actual|
-    if File.exist?(actual)
-      exif = MiniExiftool.new actual
-      exif['mimetype'] == 'image/jp2'
-    else
-      false
-    end
-  end
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: assembly-image
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Peter Mangiafico
@@ -11,42 +11,36 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-06-27 00:00:00.000000000 Z
+date: 2023-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: assembly-objectfile
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ">"
       - !ruby/object:Gem::Version
-        version: 1.6.4
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ">"
       - !ruby/object:Gem::Version
-        version: 1.6.4
+        version: '6.1'
 - !ruby/object:Gem::Dependency
-  name: mini_exiftool
+  name: assembly-objectfile
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3'
+        version: 1.6.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3'
+        version: 1.6.4
 - !ruby/object:Gem::Dependency
   name: ruby-vips
   requirement: !ruby/object:Gem::Requirement
@@ -145,20 +139,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: Contains classes to create derivative image files and perform other image
   operations
 email:
@@ -175,6 +155,7 @@ files:
 - ".rubocop_todo.yml"
 - ".rvmrc.example"
 - Gemfile
+- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
@@ -182,25 +163,16 @@ files:
 - bin/console
 - config/boot.rb
 - lib/assembly-image.rb
-- lib/assembly-image/image.rb
-- lib/assembly-image/images.rb
-- lib/assembly-image/jp2_creator.rb
+- lib/assembly/image.rb
+- lib/assembly/image/jp2_creator.rb
 - profiles/AdobeRGB1998.icc
 - profiles/DotGain20.icc
 - profiles/cmyk.icc
 - profiles/sRGBIEC6196621.icc
 - spec/assembly/image/jp2_creator_spec.rb
-- spec/image_spec.rb
-- spec/images_spec.rb
+- spec/assembly/image_spec.rb
 - spec/spec_helper.rb
-- spec/test_data/color_cmyk_tagged.tif
-- spec/test_data/color_cmyk_untagged.tif
-- spec/test_data/color_rgb_adobergb1998_lzw.tif
-- spec/test_data/color_rgb_srgb.jpg
-- spec/test_data/color_rgb_srgb.tif
 - spec/test_data/color_rgb_srgb_rot90cw.tif
-- spec/test_data/color_rgb_untagged.tif
-- spec/test_data/gray_gray_untagged.tif
 - spec/test_data/input/.empty
 - spec/test_data/output/.empty
 homepage: ''
@@ -222,7 +194,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Ruby immplementation of image services needed to prepare objects to be accessioned