cabriolet 0.2.2 → 0.2.4

data/lib/cabriolet/decompressors/lzx.rb

@@ -129,8 +129,8 @@ module Cabriolet
         @num_offsets = POSITION_SLOTS[window_bits - 15] << 3
         @maintree_maxsymbols = NUM_CHARS + @num_offsets
 
-        # Initialize window
-        @window = "\0" * @window_size
+        # Initialize window (must be binary to avoid UTF-8 character vs byte mismatch)
+        @window = ("\0" * @window_size).b
         @window_posn = 0
         @frame_posn = 0
         @frame = 0
@@ -149,7 +149,7 @@ module Cabriolet
         # Intel E8 transformation state
         @intel_filesize = 0
         @intel_started = false
-        @e8_buf = "\0" * FRAME_SIZE
+        @e8_buf = ("\0" * FRAME_SIZE).b
 
         # Initialize bitstream (LZX uses MSB-first bit ordering per libmspack lzxd.c)
         @bitstream = Binary::Bitstream.new(io_system, input, buffer_size,
@@ -162,6 +162,12 @@ module Cabriolet
         @offset = 0
         @output_ptr = 0
         @output_end = 0
+
+        # Per libmspack: pending frame data for multi-file extraction.
+        # When a decompress call ends mid-frame, the unwritten portion
+        # of the frame is stored here for the next call to output.
+        @pending_frame_data = nil
+        @pending_frame_offset = 0
       end
 
       # Set output length (for Intel E8 processing)
@@ -172,8 +178,30 @@ module Cabriolet
         @output_length = length if length.positive?
       end
 
+      # Free resources used by the decompressor
+      #
+      # Releases large memory buffers to prevent memory leaks when
+      # the decompressor is no longer needed.
+      #
+      # @return [void]
+      def free
+        @window = nil
+        @e8_buf = nil
+        @pending_frame_data = nil
+        @bitstream = nil
+        @maintree_lengths = nil
+        @length_lengths = nil
+        @pretree_lengths = nil
+        @aligned_lengths = nil
+      end
+
       # Decompress LZX data
       #
+      # Per libmspack lzxd.c: the decompressor always decodes full frames
+      # (32KB) into the window, but may output fewer bytes if the caller
+      # requests less. When multiple files share a folder, decompress is
+      # called per file, so partial-frame data must carry over between calls.
+      #
       # @param bytes [Integer] Number of bytes to decompress
       # @return [Integer] Number of bytes decompressed
       def decompress(bytes)
@@ -183,7 +211,30 @@ module Cabriolet
         read_intel_header unless @header_read
 
         total_written = 0
-        end_frame = ((@offset + bytes) / FRAME_SIZE) + 1
+
+        # Output any pending frame data from the previous partial-frame write.
+        # This handles multi-file extraction where the previous call ended
+        # mid-frame and the next file's data starts in the same frame.
+        if @pending_frame_data
+          avail = @pending_frame_data.bytesize - @pending_frame_offset
+          write_amount = [bytes, avail].min
+          io_system.write(output,
+                          @pending_frame_data[@pending_frame_offset,
+                                              write_amount])
+          total_written += write_amount
+          @offset += write_amount
+          @pending_frame_offset += write_amount
+
+          if @pending_frame_offset >= @pending_frame_data.bytesize
+            @pending_frame_data = nil
+            @pending_frame_offset = 0
+          end
+        end
+
+        remaining = bytes - total_written
+        return total_written if remaining <= 0
+
+        end_frame = ((@offset + remaining) / FRAME_SIZE) + 1
 
         while @frame < end_frame
           # Check reset interval - reset offset registers at frame boundaries
@@ -217,20 +268,47 @@ module Cabriolet
                          @window[@frame_posn, frame_size]
                        end
 
-          # Write frame
+          # Defensive guard: frame_data should never be nil if the >= window
+          # wrap checks below are correct. If it is, the stream is corrupt
+          # or a regression has been introduced.
+          if frame_data.nil?
+            if @salvage
+              warn "Salvage: nil frame data at frame_posn=#{@frame_posn}, frame=#{@frame}"
+              break
+            end
+
+            raise DecompressionError,
+                  "LZX: nil frame data at position #{@frame_posn}, frame_size=#{frame_size}"
+          end
+
+          # Write frame - per libmspack: offset tracks actual output bytes,
+          # not full frame bytes. Save unwritten remainder for next call.
           write_amount = [bytes - total_written, frame_size].min
           io_system.write(output, frame_data[0, write_amount])
           total_written += write_amount
-          @offset += frame_size
+          @offset += write_amount
 
-          # Advance frame
+          # Store pending data if partial frame write
+          if write_amount < frame_size
+            @pending_frame_data = frame_data
+            @pending_frame_offset = write_amount
+          end
+
+          # Advance frame (always by full frame, matching decode position)
           @frame += 1
           @frame_posn += frame_size
-          @frame_posn = 0 if @frame_posn == @window_size
-          @window_posn = 0 if @window_posn == @window_size
-
-          # Re-align bitstream (byte_align is safe to call even if already aligned)
-          @bitstream.byte_align
+          @frame_posn = 0 if @frame_posn >= @window_size
+          @window_posn = 0 if @window_posn >= @window_size
+
+          # Re-align bitstream to 16-bit word boundary between frames.
+          # Per libmspack lzxd.c: LZX frames are padded to 16-bit word
+          # boundaries (not 8-bit byte boundaries) because the bitstream
+          # reads data in 16-bit little-endian words.
+          if @bitstream.bits_left.positive?
+            @bitstream.ensure_bits(16)
+          end
+          remove = @bitstream.bits_left & 15
+          @bitstream.skip_bits(remove) if remove.positive?
         end
 
         total_written
@@ -313,14 +391,27 @@ module Cabriolet
           # Read new block header if needed
           read_block_header if @block_remaining.zero?
 
-          # Decode as much as possible
+          # Decode as much as possible from the current block
           this_run = [@block_remaining, bytes_todo].min
           bytes_todo -= this_run
           @block_remaining -= this_run
 
           case @block_type
           when BLOCKTYPE_VERBATIM, BLOCKTYPE_ALIGNED
-            decode_huffman_block(this_run)
+            remaining = decode_huffman_block(this_run)
+
+            # Per libmspack lzxd.c: if a match caused overrun (this_run
+            # went negative in the inner loop), adjust block_remaining.
+            # This happens when a match crosses a block boundary within
+            # a frame (bytes_todo limited this_run, not block_remaining).
+            if remaining.negative?
+              overrun = -remaining
+              if overrun > @block_remaining
+                raise DecompressionError,
+                      "Match overrun (#{overrun}) exceeds block remaining (#{@block_remaining})"
+              end
+              @block_remaining -= overrun
+            end
           when BLOCKTYPE_UNCOMPRESSED
             decode_uncompressed_block(this_run)
           else
@@ -337,9 +428,11 @@ module Cabriolet
       #
       # @return [void]
       def read_block_header
-        # Align for uncompressed blocks - this ensures correct byte alignment
-        # when reading the R0, R1, R2 values from the block header
-        @bitstream.byte_align if @block_type == BLOCKTYPE_UNCOMPRESSED && @block_length.allbits?(1)
+        # Per libmspack lzxd.c: when transitioning FROM an uncompressed block
+        # with ODD length, skip 1 raw padding byte to maintain 16-bit alignment.
+        if @block_type == BLOCKTYPE_UNCOMPRESSED && @block_length.odd?
+          @bitstream.read_raw_byte
+        end
 
         # Read block type (3 bits)
         @block_type = @bitstream.read_bits(3)
@@ -549,15 +642,23 @@ module Cabriolet
 
       # Read uncompressed block header
       #
+      # Per libmspack lzxd.c: for uncompressed blocks, the bitstream is
+      # flushed (bit_buffer=0, bits_left=0) and R0/R1/R2 are read directly
+      # from the raw input stream (i_ptr), NOT through the MSB bitstream.
+      # Reading through the MSB bitstream would byte-swap each 16-bit word.
+      #
       # @return [void]
       def read_uncompressed_block_header
         @intel_started = true
 
-        # Align to byte boundary
-        @bitstream.byte_align
+        # Per libmspack: if bits_left == 0, ensure we have data available
+        @bitstream.ensure_bits(16) if @bitstream.bits_left.zero?
+
+        # Flush bit buffer - discard any remaining bits (alignment padding)
+        @bitstream.flush_bit_buffer
 
-        # Read R0, R1, R2
-        bytes = Array.new(12) { @bitstream.read_bits(8) }
+        # Read R0, R1, R2 directly from raw input (bypassing bitstream)
+        bytes = Array.new(12) { @bitstream.read_raw_byte }
         @r0 = bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24)
         @r1 = bytes[4] | (bytes[5] << 8) | (bytes[6] << 16) | (bytes[7] << 24)
         @r2 = bytes[8] | (bytes[9] << 8) | (bytes[10] << 16) | (bytes[11] << 24)
@@ -565,8 +666,13 @@ module Cabriolet
 
       # Decode Huffman-compressed block
       #
+      # Per libmspack lzxd.c: the inner decode loop uses this_run as its
+      # counter. A match can cause this_run to go negative (overrun past
+      # the planned run length). The caller must adjust block_remaining
+      # for any overrun.
+      #
       # @param run_length [Integer] Number of bytes to decode
-      # @return [void]
+      # @return [Integer] Final run_length (0 or negative if overrun)
       def decode_huffman_block(run_length)
         while run_length.positive?
           # Decode main symbol
@@ -586,6 +692,8 @@ module Cabriolet
             run_length -= match_length
           end
         end
+
+        run_length
       end
 
       # Decode and copy a match
@@ -599,7 +707,7 @@ module Cabriolet
         # Decode match length
         match_length = main_element & NUM_PRIMARY_LENGTHS
         if match_length == NUM_PRIMARY_LENGTHS
-          if @length_empty
+          if @length_empty || @length_tree.nil?
             raise DecompressionError,
                   "Length tree needed but empty"
           end
@@ -747,11 +855,15 @@ module Cabriolet
 
       # Decode uncompressed block
       #
+      # Per libmspack lzxd.c: uncompressed block data is read directly from
+      # the raw input stream (i_ptr), NOT through the MSB bitstream. The bit
+      # buffer was already flushed when the uncompressed block header was read.
+      #
       # @param run_length [Integer] Number of bytes to decode
       # @return [void]
       def decode_uncompressed_block(run_length)
         run_length.times do
-          byte = @bitstream.read_bits(8)
+          byte = @bitstream.read_raw_byte
           @window.setbyte(@window_posn, byte)
           @window_posn += 1
         end

data/lib/cabriolet/decompressors/mszip.rb

@@ -62,8 +62,8 @@ salvage: false, **_kwargs)
         super(io_system, input, output, buffer_size)
         @fix_mszip = fix_mszip
 
-        # Initialize sliding window
-        @window = "\0" * FRAME_SIZE
+        # Initialize sliding window (must be binary to avoid UTF-8 character vs byte mismatch)
+        @window = ("\0" * FRAME_SIZE).b
         @window_posn = 0
         @bytes_output = 0
         @window_offset = 0 # Offset into window for unconsumed data (for multi-file CFDATA blocks)
@@ -77,6 +77,25 @@ salvage: false, **_kwargs)
         @distance_lengths = Array.new(DISTANCE_MAXSYMBOLS, 0)
         @literal_tree = nil
         @distance_tree = nil
+
+        # Cache ENV lookups once at initialization
+        @debug_mszip = ENV.fetch("DEBUG_MSZIP", nil)
+        @debug_mszip_symbols = ENV.fetch("DEBUG_MSZIP_SYMBOLS", nil)
+      end
+
+      # Free resources used by the decompressor
+      #
+      # Releases memory buffers to prevent memory leaks when
+      # the decompressor is no longer needed.
+      #
+      # @return [void]
+      def free
+        @window = nil
+        @bitstream = nil
+        @literal_lengths = nil
+        @distance_lengths = nil
+        @literal_tree = nil
+        @distance_tree = nil
       end
 
       # Decompress MSZIP data
@@ -86,14 +105,14 @@ salvage: false, **_kwargs)
       def decompress(bytes)
         total_written = 0
 
-        if ENV["DEBUG_MSZIP"]
+        if @debug_mszip
           warn "DEBUG MSZIP.decompress(#{bytes}): ENTRY bytes_output=#{@bytes_output} window_offset=#{@window_offset} window_posn=#{@window_posn}"
         end
 
         while bytes.positive?
           # Check if we have buffered data from previous inflate
           if @bytes_output.positive?
-            if ENV["DEBUG_MSZIP"]
+            if @debug_mszip
               warn "DEBUG MSZIP: Using buffered data: bytes_output=#{@bytes_output} window_offset=#{@window_offset}"
             end
 
@@ -105,7 +124,7 @@ salvage: false, **_kwargs)
             @bytes_output -= write_amount
             @window_offset += write_amount
 
-            if ENV["DEBUG_MSZIP"]
+            if @debug_mszip
               warn "DEBUG MSZIP: After buffer write: total_written=#{total_written} bytes_remaining=#{bytes} bytes_output=#{@bytes_output}"
             end
 
@@ -120,13 +139,13 @@ salvage: false, **_kwargs)
 
           # Read 'CK' signature (marks start of MSZIP frame)
           # Every MSZIP frame starts with a CK signature
-          if ENV["DEBUG_MSZIP"]
+          if @debug_mszip
             warn "DEBUG MSZIP: Reading CK signature (new MSZIP frame)"
           end
           read_signature
 
           # Inflate the MSZIP frame (processes deflate blocks until last_block or window full)
-          if ENV["DEBUG_MSZIP"]
+          if @debug_mszip
             warn "DEBUG MSZIP: Calling inflate_block"
           end
 
@@ -142,14 +161,14 @@ salvage: false, **_kwargs)
             @bytes_output = FRAME_SIZE
           end
 
-          if ENV["DEBUG_MSZIP"]
+          if @debug_mszip
             warn "DEBUG MSZIP: After inflate_block: bytes_output=#{@bytes_output} window_posn=#{@window_posn}"
           end
 
           # Now we have data in the window buffer - loop back to write from it
         end
 
-        if ENV["DEBUG_MSZIP"]
+        if @debug_mszip
           warn "DEBUG MSZIP.decompress: EXIT total_written=#{total_written}"
         end
 
@@ -160,7 +179,7 @@ salvage: false, **_kwargs)
 
       # Read and verify 'CK' signature
       def read_signature
-        if ENV["DEBUG_MSZIP"]
+        if @debug_mszip
           warn "DEBUG read_signature: Before byte_align"
         end
 
@@ -171,7 +190,7 @@ salvage: false, **_kwargs)
         c = @bitstream.read_bits(8)
         k = @bitstream.read_bits(8)
 
-        if ENV["DEBUG_MSZIP"]
+        if @debug_mszip
           warn "DEBUG read_signature: Read 0x#{c.to_s(16)} 0x#{k.to_s(16)} (expected 'C'=0x43 'K'=0x4B)"
         end
 
@@ -188,7 +207,7 @@ salvage: false, **_kwargs)
 
             if c == SIGNATURE_BYTE_C && k == SIGNATURE_BYTE_K
               found = true
-              if ENV["DEBUG_MSZIP"]
+              if @debug_mszip
                 warn "DEBUG read_signature: Found CK signature after searching"
               end
               break
@@ -211,7 +230,7 @@ salvage: false, **_kwargs)
         last_block = @bitstream.read_bits(1)
         block_type = @bitstream.read_bits(2)
 
-        if ENV["DEBUG_MSZIP"]
+        if @debug_mszip
           warn "DEBUG inflate_block: First block: last_block=#{last_block} block_type=#{block_type}"
         end
 
@@ -230,7 +249,7 @@ salvage: false, **_kwargs)
             raise DecompressionError, "Invalid block type: #{block_type}"
           end
 
-          if ENV["DEBUG_MSZIP"]
+          if @debug_mszip
             warn "DEBUG inflate_block: After block: last_block=#{last_block} window_posn=#{@window_posn}"
           end
 
@@ -383,7 +402,7 @@ salvage: false, **_kwargs)
       def inflate_huffman_block
         symbol_count = 0
         loop do
-          if ENV["DEBUG_MSZIP_SYMBOLS"]
+          if @debug_mszip_symbols
             warn "DEBUG inflate_huffman_block: window_posn=#{@window_posn} bytes_output=#{@bytes_output}"
           end
 
@@ -394,7 +413,7 @@ salvage: false, **_kwargs)
           )
           symbol_count += 1
 
-          if ENV["DEBUG_MSZIP_SYMBOLS"] || ENV["DEBUG_MSZIP"]
+          if @debug_mszip || @debug_mszip_symbols
             warn "DEBUG inflate_huffman_block[#{symbol_count}]: decoded code=#{code} (#{'0x%02x' % code if code < 256})"
           end
 
@@ -405,7 +424,7 @@ salvage: false, **_kwargs)
             flush_window if @window_posn == FRAME_SIZE
           elsif code == 256
             # End of block
-            if ENV["DEBUG_MSZIP"] || ENV["DEBUG_MSZIP_SYMBOLS"]
+            if @debug_mszip || @debug_mszip_symbols
               warn "DEBUG inflate_huffman_block: END OF BLOCK (window_posn=#{@window_posn})"
             end
             break

data/lib/cabriolet/decompressors/quantum.rb

@@ -2,30 +2,16 @@
 
 require_relative "../quantum_shared"
 
-# Compatibility shim for String#bytesplice (added in Ruby 3.2)
-unless String.method_defined?(:bytesplice)
-  module StringBytespliceCompat
-    # Compatibility implementation of bytesplice for Ruby < 3.2
-    # Uses clear/append which is slower but works with mutable strings
-    def bytesplice(index, length, other_string, other_index = 0,
-other_length = nil)
-      other_length ||= other_string.bytesize
-
-      # Build new string content
-      prefix = byteslice(0, index)
-      middle = other_string.byteslice(other_index, other_length)
-      suffix = byteslice((index + length)..-1)
-      new_content = prefix + middle + suffix
-
-      # Modify receiver in place
-      clear
-      self << new_content
-
-      self
+# Helper for 5-argument bytesplice (added in Ruby 3.3)
+# Ruby 3.2 has bytesplice but only 2-3 argument forms
+unless String.method_defined?(:window_splice)
+  class String
+    # Copy bytes from source string into self at specified position
+    # Works on all Ruby versions including 3.2 which lacks 5-arg bytesplice
+    def window_splice(dest_idx, dest_len, src, src_idx, src_len)
+      self[dest_idx, dest_len] = src.byteslice(src_idx, src_len)
     end
   end
-
-  String.prepend(StringBytespliceCompat)
 end
 
 module Cabriolet
@@ -60,13 +46,8 @@ module Cabriolet
         @window_bits = window_bits
         @window_size = 1 << window_bits
 
-        # Initialize window (mutable for Ruby < 3.2 bytesplice compatibility)
-        @window = if String.method_defined?(:bytesplice)
-                    "\0" * @window_size
-                  else
-                    # In Ruby < 3.2, create mutable window using String.new
-                    String.new("\0" * @window_size)
-                  end
+        # Initialize window (must be binary to avoid UTF-8 character vs byte mismatch)
+        @window = ("\0" * @window_size).b
         @window_posn = 0
         @frame_todo = FRAME_SIZE
 
@@ -83,6 +64,21 @@ module Cabriolet
         initialize_models
       end
 
+      # Free resources used by the decompressor
+      #
+      # Releases memory buffers to prevent memory leaks when
+      # the decompressor is no longer needed.
+      #
+      # @return [void]
+      def free
+        @window = nil
+        @bitstream = nil
+        @m0sym = @m1sym = @m2sym = @m3sym = nil
+        @m4sym = @m5sym = @m6sym = @m6lsym = nil
+        @model0 = @model1 = @model2 = @model3 = nil
+        @model4 = @model5 = @model6 = @model6len = nil
+      end
+
       # Decompress Quantum data
       #
       # @param bytes [Integer] Number of bytes to decompress
@@ -403,7 +399,7 @@ module Cabriolet
         end
       end
 
-      # Bulk copy using bytesplice for better performance on longer matches
+      # Bulk copy using window_splice for better performance on longer matches
       def copy_match_bulk(offset, length)
         if offset > @window_posn
           # Match wraps around window
@@ -418,21 +414,23 @@ module Cabriolet
 
           if copy_len < length
             # Copy from end, then from beginning
-            @window.bytesplice(@window_posn, copy_len, @window, src_pos,
-                               copy_len)
+            @window.window_splice(@window_posn, copy_len, @window, src_pos,
+                                  copy_len)
             @window_posn += copy_len
             remaining = length - copy_len
-            @window.bytesplice(@window_posn, remaining, @window, 0, remaining)
+            @window.window_splice(@window_posn, remaining, @window, 0,
+                                  remaining)
             @window_posn += remaining
           else
             # Copy entirely from end
-            @window.bytesplice(@window_posn, length, @window, src_pos, length)
+            @window.window_splice(@window_posn, length, @window, src_pos,
+                                  length)
             @window_posn += length
           end
         else
-          # Normal copy - use bytesplice for bulk operation
+          # Normal copy - use window_splice for bulk operation
           src_pos = @window_posn - offset
-          @window.bytesplice(@window_posn, length, @window, src_pos, length)
+          @window.window_splice(@window_posn, length, @window, src_pos, length)
           @window_posn += length
         end
       end

data/lib/cabriolet/file_manager.rb

@@ -29,13 +29,13 @@ module Cabriolet
     # @param options [Hash] Format-specific options
     # @return [FileEntry] Added entry
     # @raise [ArgumentError] if file doesn't exist
-    def add_file(source_path, archive_path = nil, **options)
+    def add_file(source_path, archive_path = nil, **)
       archive_path ||= File.basename(source_path)
 
       entry = FileEntry.new(
         source: source_path,
         archive_path: archive_path,
-        **options,
+        **,
       )
 
       @entries << entry
@@ -48,11 +48,11 @@ module Cabriolet
     # @param archive_path [String] Path in archive
     # @param options [Hash] Format-specific options
     # @return [FileEntry] Added entry
-    def add_data(data, archive_path, **options)
+    def add_data(data, archive_path, **)
       entry = FileEntry.new(
         data: data,
         archive_path: archive_path,
-        **options,
+        **,
       )
 
       @entries << entry

data/lib/cabriolet/format_base.rb

@@ -44,7 +44,7 @@ module Cabriolet
     # @param size [Integer] Data size
     # @param options [Hash] Additional options for the compressor
     # @return [Object] Compressor instance
-    def create_compressor(algorithm, input, output, size, **options)
+    def create_compressor(algorithm, input, output, size, **)
       @algorithm_factory.create(
         algorithm,
         :compressor,
@@ -52,7 +52,7 @@ module Cabriolet
         input,
         output,
         size,
-        **options,
+        **,
       )
     end
 
@@ -64,7 +64,7 @@ module Cabriolet
     # @param size [Integer] Data size
     # @param options [Hash] Additional options for the decompressor
     # @return [Object] Decompressor instance
-    def create_decompressor(algorithm, input, output, size, **options)
+    def create_decompressor(algorithm, input, output, size, **)
       @algorithm_factory.create(
         algorithm,
         :decompressor,
@@ -72,7 +72,7 @@ module Cabriolet
         input,
         output,
         size,
-        **options,
+        **,
       )
     end
   end

data/lib/cabriolet/hlp/compressor.rb

@@ -45,8 +45,8 @@ module Cabriolet
       # @param output_file [String] Output file path
       # @param options [Hash] Format options
       # @return [Integer] Bytes written
-      def generate(output_file, **options)
-        @quickhelp.generate(output_file, **options)
+      def generate(output_file, **)
+        @quickhelp.generate(output_file, **)
       end
 
       # Create a Windows Help format HLP file

data/lib/cabriolet/huffman/decoder.rb

@@ -52,8 +52,14 @@ num_symbols = nil)
                   "Huffman decode error: code too long"
           end
 
-          # Get the next bit from bit buffer at position idx
-          bit = (bitstream.peek_bits(idx + 1) >> idx) & 1
+          # Get the next bit from bit buffer at position idx.
+          # LSB mode: peek_bits returns bottom n bits; bit idx is at position idx.
+          # MSB mode: peek_bits returns top n bits right-justified; bit idx is the LSB.
+          bit = if bitstream.bit_order == :msb
+                  bitstream.peek_bits(idx + 1) & 1
+                else
+                  (bitstream.peek_bits(idx + 1) >> idx) & 1
+                end
 
           # Follow the tree path: (current_entry << 1) | bit
           next_idx = (sym << 1) | bit

data/lib/cabriolet/plugin.rb

@@ -190,10 +190,10 @@ module Cabriolet
     # @example Register a format-specific decompressor
     #   register_algorithm(:special, SpecialDecompressor,
     #                     category: :decompressor, format: :cab)
-    def register_algorithm(type, klass, **options)
+    def register_algorithm(type, klass, **)
       raise PluginError, "Plugin manager not available" unless @manager
 
-      Cabriolet.algorithm_factory.register(type, klass, **options)
+      Cabriolet.algorithm_factory.register(type, klass, **)
     end
 
     # Register a format handler

data/lib/cabriolet/plugin_manager.rb

@@ -259,11 +259,11 @@ module Cabriolet
         else
           @plugins.select { |_, entry| entry[:state] == state }
             .transform_values do |entry|
-              {
-                metadata: entry[:metadata],
-                state: entry[:state],
-                error: entry[:error],
-              }
+            {
+              metadata: entry[:metadata],
+              state: entry[:state],
+              error: entry[:error],
+            }
           end
         end
       end