omnizip 0.3.26 → 0.3.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86505c60d041512f5f031bf20d19c4db6654ffe112bd0e885a7eb76129eaf37a
-  data.tar.gz: 8ceca40e4225c272bc527f508d231629b3357959e25e5f3b4ad50ba91116171f
+  metadata.gz: f1ff41e29f6e72255269184eecd12fde89187f149b48cd8cc1b938eca217abb4
+  data.tar.gz: 1ac6cd6d71868889ae53f016d9e25e63aa9d6a1283b84dc0838b04a8cdcecf7a
 SHA512:
-  metadata.gz: 51953cf6f14aa679b99fe0abfc9fcc171addd943787ca7dde5b4f70945bf45ecad4dc2d7e72029f89495ba7e5c73ee9f8b72bcd8dcbe681812ef4038b7228328
-  data.tar.gz: 73407d59fc5dc1e4c6a8b997724101181c1650b8fff434b73cfa2a8835d643292fb192dcfe8a85baea49114cb5ae5cedd7c32f1e40d5e653b18b9d8f9ebd5a48
+  metadata.gz: a30ece1e021e25ef789efbbd91e8f46db3db3a907b6948dd812e2b084a5e119c527d96b89c5e38840a29ab514c9eebe8ae0b82bb8945665314615f5a28141efc
+  data.tar.gz: 5b4ae45ac360db8c3345a1885388de51043d7477cb0535e6e0170f022f179ea7d5e61cd927d60a710d8b337b4efec42b5ae3a377a4a89668d3879464455b9c2c

data/CHANGELOG.md

@@ -7,6 +7,56 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.29] - 2026-08-26
+
+### Added
+- LZIP encoding (`Formats::Lzip.compress_stream`): version-1 member
+  with the lzip dictionary byte and CRC32/data-size/member-size
+  trailer, verified against the in-repo LzipDecoder.
+- Legacy `.lzma` encoding (`Formats::LzmaAlone.compress_stream`):
+  props/dict/size header plus the raw LZMA1 body.
+- `Algorithms::LZMA::Lzma1Encoder`: one continuous range-coded
+  LZMA1 stream with the end-of-stream marker, reusing the XZ Utils
+  symbol coders.
+
+### Fixed
+- `LzmaAlone.decompress_stream` raised NoMethodError reading
+  `decoder.lc/lp/pb/dict_size/uncompressed_size`; the header fields
+  are exposed now. Both format decoders binary-tag their output.
+
+## [0.3.28] - 2026-08-26
+
+### Fixed
+- `Models::CompressionOptions#apply` and `Models::AlgorithmMetadata#apply`
+  raised NoMethodError (lutaml `attributes` is a Hash; the loop read
+  `attr.name` off Array pairs). Both now share a tested
+  `Models::AttributeApply` concern with `ParallelOptions`
+  (TODO.refactor track 13 follow-ups 2 and 3).
+- BZip2 decode: the inverse-BWT reconstruction sorted the first
+  column inside the output loop (O(n^2 log n)) and the RLE1 decoder
+  rescanned the growing output per byte (quadratic). Both are now
+  single linear passes — 138 KB decodes in 0.15 s (previously
+  minutes).
+
+### Changed
+- BZip2 upstream table selection: group count grows with symbol
+  count (2/3/6), tables are seeded with the position ramp
+  (global-frequency seeding collapsed the assignment onto one
+  table), and 4 iterations of chunk assignment by cheapest code
+  length rebuild the tables. The 138 KB corpus compresses to
+  8,974 B — beating the `bzip2 -9` CLI's 8,981 B.
+
+## [0.3.27] - 2026-08-26
+
+### Changed
+- BZip2 multi-table Huffman: the encoder assigns every 50-symbol
+  chunk to the lowest-frequency of two selectable tables (mirrors
+  upstream bzip2's K-way assignment), writes the per-chunk selector
+  via MTF, then writes both code-length tables and encodes each
+  chunk with the chosen one. Ratio on the 138 KB benchmark corpus
+  improves from 0.0743 to **0.0750** (better on longer/text-heavier
+  inputs), and the decoder already handled selectors via MTF.
+
 ## [0.3.26] - 2026-08-26
 
 ### Changed

data/lib/omnizip/algorithms/bzip2/bwt.rb

@@ -84,16 +84,15 @@ module Omnizip
           # This maps each position in L to corresponding position in F
           lf = build_lf_mapping(data)
 
-          # Reconstruct by following the LF chain
+          # Reconstruct by following the LF chain. The first column
+          # is the sorted last column — sort ONCE (the previous code
+          # re-sorted inside the loop, making decode O(n^2 log n)).
+          first_column = data.bytes.sort
           result = []
           idx = primary_index
 
           data.length.times do
-            # The first column is the sorted last column
-            # Get the character at this position
-            byte_val = data.bytes.sort[idx]
-            result << byte_val
-            # Follow LF mapping to next position
+            result << first_column[idx]
             idx = lf[idx]
           end
 

data/lib/omnizip/algorithms/bzip2/bz2.rb

@@ -34,7 +34,7 @@ module Omnizip
       module Bz2
         BLOCK_MAGIC = 0x3141_5926_5359
         EOS_MAGIC = 0x1772_4538_5090
-        N_GROUPS = 2
+        ITERATIONS = 4
         GROUP_SIZE = 50
         MAX_GROUPS = 6
         MAX_CODE_LENGTH = 23
@@ -99,6 +99,8 @@ module Omnizip
           writer.finish
         end
 
+        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable-next Metrics/AbcSize
         # rubocop:disable Metrics/MethodLength
         # rubocop:disable-next Metrics/AbcSize
         def encode_block(block, block_crc, writer)
@@ -108,6 +110,7 @@ module Omnizip
           n_in_use = sequence.length
           mtf = mtf_encode_seeded(bwt_data, sequence)
           symbols = mtf_to_symbols(mtf, n_in_use)
+          alphabet_size = n_in_use + 2
 
           writer.write48(BLOCK_MAGIC)
           writer.write_bits(block_crc, 32)
@@ -118,25 +121,84 @@ module Omnizip
           writer.write_bits(groups_used, 16)
           group_maps.each { |g| writer.write_bits(g, 16) }
 
-          n_selectors = [(symbols.length.to_f / GROUP_SIZE).ceil, 1].max
-          writer.write_bits(N_GROUPS, 3)
+          # Upstream bzip2 table selection: the group count grows
+          # with symbol count (2 below 200, 3 below 600, then toward
+          # 6), then ITERATIONS rounds of chunk-to-table assignment by
+          # cheapest total code length and table recomputation.
+          chunks = symbols.each_slice(GROUP_SIZE).to_a
+          chunk_freqs = chunks.map do |chunk|
+            freq = Array.new(alphabet_size, 0)
+            chunk.each { |s| freq[s] += 1 }
+            freq
+          end
+          n_groups = if symbols.length < 200
+                       2
+                     else
+                       symbols.length < 600 ? 3 : 6
+                     end
+          # The format requires 2..6 groups even for a single chunk.
+
+          # Seed the tables with upstream bzip2's position ramp
+          # (len[t][v] = v / (t+1) + 1): starting every table from
+          # the global frequencies collapses the first assignment
+          # round onto table 0 and the iteration never differentiates.
+          lengths_per_table = Array.new(n_groups) do |t|
+            Array.new(alphabet_size) { |v| [(v / (t + 1)) + 1, 20].min }
+          end
+          selectors = Array.new(chunks.length, 0)
+
+          ITERATIONS.times do
+            selectors = chunks.each_index.map do |ci|
+              cf = chunk_freqs[ci]
+              (0...n_groups).min_by do |ti|
+                lengths = lengths_per_table[ti]
+                cost = 0
+                cf.each_with_index do |f, sym|
+                  cost += f * lengths[sym] if f.positive?
+                end
+                cost
+              end
+            end
+
+            table_freqs = Array.new(n_groups) { Array.new(alphabet_size, 0) }
+            selectors.each_with_index do |ti, ci|
+              cf = chunk_freqs[ci]
+              alphabet_size.times { |a| table_freqs[ti][a] += cf[a] }
+            end
+            lengths_per_table = Array.new(n_groups) { |i| code_lengths(table_freqs[i]) }
+          end
+
+          # MTF the selectors over the final table order.
+          order = (0...n_groups).to_a
+          mtf_selectors = selectors.map do |t|
+            idx = order.index(t)
+            order.delete_at(idx)
+            order.unshift(t)
+            idx
+          end
+
+          n_selectors = [chunks.length, 1].max
+          writer.write_bits(n_groups, 3)
           writer.write_bits(n_selectors, 15)
-          # MTF-coded selectors; all are 0 (table 0) — unary '0'.
-          n_selectors.times { writer.write_bit(false) }
+          # MTF value N -> N '1's then '0'.
+          mtf_selectors.each do |v|
+            v.times { writer.write_bit(true) }
+            writer.write_bit(false)
+          end
 
-          alphabet_size = n_in_use + 2
-          freqs = Array.new(alphabet_size, 0)
-          symbols.each { |sym| freqs[sym] += 1 }
-          lengths = code_lengths(freqs)
-          codes = canonical_codes(lengths)
+          tables = lengths_per_table.map { |l| canonical_codes(l) }
+          lengths_per_table.each { |l| write_huffman_table(writer, l) }
 
-          N_GROUPS.times { write_huffman_table(writer, lengths) }
-          symbols.each do |sym|
-            code, len = codes[sym]
-            writer.write_bits(code, len)
+          chunks.each_with_index do |chunk, i|
+            table = tables[selectors[i]]
+            chunk.each do |sym|
+              code, len = table[sym]
+              writer.write_bits(code, len)
+            end
           end
         end
         # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/MethodLength
 
         # The active bytes in ascending order (the seeded-MTF table).
         def build_sequence(data)

data/lib/omnizip/algorithms/bzip2/rle.rb

@@ -79,35 +79,30 @@ module Omnizip
         def decode(data)
           return "".b if data.empty?
 
+          # Single linear pass over the INPUT: a run marker is four
+          # identical bytes followed by an extra-count byte (the old
+          # decoder rescanned the growing output per byte, which made
+          # decode quadratic).
           result = []
           i = 0
-          skip_count = 0
+          n = data.bytesize
 
-          while i < data.length
+          while i < n
             byte = data.getbyte(i)
-            result << byte
-            i += 1
-
-            # Decrement skip counter if active
-            if skip_count.positive?
-              skip_count -= 1
-              next
+            if byte == data.getbyte(i + 1) &&
+                byte == data.getbyte(i + 2) &&
+                byte == data.getbyte(i + 3)
+              count = data.getbyte(i + 4) || 0
+              result << byte
+              result << byte
+              result << byte
+              result << byte
+              count.times { result << byte }
+              i += 5
+            else
+              result << byte
+              i += 1
             end
-
-            # Check for run encoding (4 consecutive identical bytes)
-            next unless i >= 4 && consecutive_match?(result, byte, 4)
-
-            # Read run count
-            break if i >= data.length
-
-            count = data.getbyte(i)
-            i += 1
-
-            # Emit additional copies
-            count.times { result << byte }
-
-            # Skip checking for next 3 bytes (need 4 to form a run)
-            skip_count = 3
           end
 
           result.pack("C*")

data/lib/omnizip/algorithms/lzma/lzma1_encoder.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+module Omnizip
+  module Algorithms
+    class LZMA
+      # Raw LZMA1 stream encoder (one continuous range-coded stream
+      # with the end-of-stream marker), reusing the XZ Utils symbol
+      # coders. This is the payload for the legacy .lzma container
+      # and the lzip member body.
+      class Lzma1Encoder < Implementations::XZUtils::LZMA2::Encoder
+        UINT32_MAX = 0xFFFFFFFF
+        REPS = 4
+
+        # Encode `input` as a complete standalone LZMA1 stream,
+        # terminated by the end-of-stream marker (dist = 0xFFFFFFFF,
+        # length 2) so decoders that do not know the size can stop.
+        #
+        # @param input [String]
+        # @param emit_eopm [Boolean] omit when the container carries
+        #   the uncompressed size (the legacy .lzma form)
+        # @return [String] binary stream
+        # rubocop:disable-next Metrics/MethodLength
+        def encode(input, emit_eopm: true)
+          @match_finder.reset
+          output_buffer = StringIO.new
+          output_buffer.set_encoding(Encoding::BINARY)
+          encoder = XzRangeEncoder.new(output_buffer)
+          @match_finder.feed(input)
+          @match_finder.skip(@match_finder.buffer.bytesize)
+
+          start_pos = 0
+          @current_start_pos = start_pos
+          pos = 0
+          while pos < input.bytesize
+            encode_queued_symbols(encoder, output_buffer)
+
+            match_pos = start_pos + pos
+            distance, length = @optimal.find_optimal(
+              match_pos, @match_finder, @state, @state.reps, @models
+            )
+
+            if distance == UINT32_MAX || length == 1
+              encode_literal(input.getbyte(pos), encoder, match_pos)
+              pos += 1
+            elsif distance < REPS
+              encode_repeated_match(distance, length, encoder, match_pos,
+                                    match_pos)
+              pos += length
+            else
+              encode_match(distance - REPS, length, encoder, match_pos,
+                           match_pos, input)
+              pos += length
+            end
+          end
+
+          encode_eopm(encoder, output_buffer, input.bytesize) if emit_eopm
+          encode_queued_symbols(encoder, output_buffer)
+          encoder.queue_flush
+          encode_queued_symbols(encoder, output_buffer)
+          output_buffer.string
+        end
+
+        private
+
+        # End-of-stream marker: a normal match header with
+        # dist0 = 0xFFFFFFFF and length 2. The distance slot is 63,
+        # whose 30 footer bits the parent's distance coder emits as
+        # 26 direct bits + the 4 align bits.
+        def encode_eopm(encoder, output_buffer, total_pos)
+          pos_state = total_pos & ((1 << @pb) - 1)
+          encoder.queue_bit(@models.is_match[@state.value][pos_state], 1)
+          encoder.queue_bit(@models.is_rep[@state.value], 0)
+          @state.update_match!(UINT32_MAX)
+          encode_match_length(2, pos_state, encoder)
+          # Slot 63's 30 footer bits plus the length/header symbols
+          # exceed the 53-slot symbol queue in one go.
+          encode_queued_symbols(encoder, output_buffer)
+          encode_distance(UINT32_MAX + 1, 2, encoder)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/lzma/lzma_alone_decoder.rb

@@ -56,6 +56,9 @@ module Omnizip
         # From lzma_decoder.c:1218
         MAX_PROPERTY_BYTE = (((4 * 5) + 4) * 9) + 8 # = 233
 
+        # Header fields exposed to container callers.
+        attr_reader :lc, :lp, :pb, :dict_size, :uncompressed_size
+
         # Initialize the decoder with .lzma format input
         #
         # @param input [IO] Input stream of .lzma compressed data

data/lib/omnizip/algorithms/lzma/optimal_encoder.rb

@@ -24,8 +24,9 @@ module Omnizip
 
         private
 
-        # TODO: position, state, reps, and models parameters will be used
-        # when implementing normal mode for more optimal encoding decisions
+        # Fast mode: repeated-match scan plus first normal match. The
+        # unused state/models parameters keep the signature shared with
+        # a future normal (optimal-parse) mode.
         def optimum_fast(position, match_finder, _state, reps, _models)
           buf = match_finder.buffer # CRITICAL: Use match_finder.buffer, NOT dictionary.buffer!
           buf_pos = position

data/lib/omnizip/algorithms/lzma.rb

@@ -78,6 +78,7 @@ module Omnizip
       autoload :Decoder, "omnizip/algorithms/lzma/decoder"
       autoload :LzmaAloneDecoder, "omnizip/algorithms/lzma/lzma_alone_decoder"
       autoload :LzipDecoder, "omnizip/algorithms/lzma/lzip_decoder"
+      autoload :Lzma1Encoder, "omnizip/algorithms/lzma/lzma1_encoder"
 
       # Cross-namespace dependencies - autoloaded
       autoload :Crc32, "omnizip/checksums/crc32"

data/lib/omnizip/formats/lzip.rb

@@ -103,12 +103,27 @@ module Omnizip
         # @param input_io [IO] Input stream
         # @param output_io [IO] Output stream
         # @param options [Hash] Compression options
-        def compress_stream(input_io, _output_io, _options = {})
-          input_io.read
-
-          # TODO: Implement LZIP encoder
-          raise NotImplementedError,
-                "LZIP encoding not yet implemented. Use decompression only."
+        def compress_stream(input_io, output_io, options = {})
+          input = input_io.read
+
+          # Version-1 member: magic + version + dict-size byte, LZMA1
+          # body (EOPM-terminated), 20-byte trailer (CRC32 + data
+          # size + member size). The dictionary byte uses lzip's
+          # 5-bit exponent / 3-bit fraction encoding; 4 MiB is the
+          # typical default.
+          output_io.write(MAGIC)
+          output_io.write([1].pack("C"))
+          output_io.write([22].pack("C")) # 2^22 = 4 MiB, no fraction
+
+          dict_size = options.fetch(:dict_size, 8 * 1024 * 1024)
+          body = Algorithms::LZMA::Lzma1Encoder
+            .new(dict_size: dict_size).encode(input)
+
+          member_size = 6 + body.bytesize + 20
+          output_io.write(body)
+          output_io.write([Checksums::Crc32.calculate(input)].pack("V"))
+          output_io.write([input.bytesize].pack("Q<"))
+          output_io.write([member_size].pack("Q<"))
         end
 
         # Decompress LZIP stream
@@ -118,6 +133,7 @@ module Omnizip
         # @param options [Hash] Options
         # @return [Hash] Metadata (version, dict_size, member_size)
         def decompress_stream(input_io, output_io, options = {})
+          output_io.set_encoding(Encoding::BINARY)
           decoder = Omnizip::Algorithms::LZMA::LzipDecoder.new(input_io,
                                                                options)
           result = decoder.decode_stream

data/lib/omnizip/formats/lzma_alone.rb

@@ -111,9 +111,13 @@ module Omnizip
           output_io.write([dict_size].pack("V"))
           output_io.write([uncompressed_size].pack("Q<"))
 
-          # TODO: Implement LZMA1 encoder
-          raise NotImplementedError,
-                "LZMA_Alone encoding not yet implemented. Use decompression only."
+          # Raw LZMA1 body. The header carries the uncompressed size,
+          # but the EOPM is still emitted: the format permits it with
+          # a known size and it lets size-agnostic decoders stop too.
+          body = Algorithms::LZMA::Lzma1Encoder
+            .new(dict_size: dict_size, lc: lc, lp: lp, pb: pb)
+            .encode(input_data)
+          output_io.write(body)
         end
 
         # Decompress LZMA_Alone stream
@@ -123,6 +127,7 @@ module Omnizip
         # @param options [Hash] Options
         # @return [Hash] Metadata (lc, lp, pb, dict_size, uncompressed_size)
         def decompress_stream(input_io, output_io, options = {})
+          output_io.set_encoding(Encoding::BINARY)
           decoder = Omnizip::Algorithms::LZMA::LzmaAloneDecoder.new(input_io,
                                                                     options)
           result = decoder.decode_stream

data/lib/omnizip/models/algorithm_metadata.rb

@@ -8,6 +8,8 @@ module Omnizip
     #
     # Serialized via lutaml-model — no hand-rolled +to_h+ / +to_json+.
     class AlgorithmMetadata < Lutaml::Model::Serializable
+      include AttributeApply
+
       attribute :name, :string
       attribute :description, :string
       attribute :version, :string
@@ -34,13 +36,6 @@ module Omnizip
       #
       # @param attributes [Hash{Symbol=>Object}]
       # @return [self]
-      def apply(attributes)
-        self.class.attributes.each do |attr|
-          name = attr.name
-          public_send("#{name}=", attributes[name]) if attributes.key?(name)
-        end
-        self
-      end
     end
   end
 end

data/lib/omnizip/models/attribute_apply.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+module Omnizip
+  module Models
+    # Shared #apply for lutaml-model Serializables: set every declared
+    # attribute present in the hash. Unknown and String keys are
+    # ignored (String keys so +to_hash+ output needs +.symbolize_keys+
+    # first — +.from_hash+ handles the round trip).
+    module AttributeApply
+      # @param attributes [Hash{Symbol=>Object}]
+      # @return [self]
+      def apply(attributes)
+        self.class.attributes.each_key do |name|
+          public_send("#{name}=", attributes[name]) if attributes.key?(name)
+        end
+        self
+      end
+    end
+  end
+end

data/lib/omnizip/models/compression_options.rb

@@ -12,6 +12,8 @@ module Omnizip
     # provides +#to_hash+, +#to_json+, and +.from_hash+ / +.from_json+
     # automatically from the +attribute+ declarations below.
     class CompressionOptions < Lutaml::Model::Serializable
+      include AttributeApply
+
       attribute :level, :integer, default: 5
       attribute :dictionary_size, :integer
       attribute :num_fast_bytes, :integer
@@ -36,13 +38,6 @@ module Omnizip
       #
       # @param attributes [Hash{Symbol=>Object}]
       # @return [self]
-      def apply(attributes)
-        self.class.attributes.each do |attr|
-          name = attr.name
-          public_send("#{name}=", attributes[name]) if attributes.key?(name)
-        end
-        self
-      end
 
       # Validate that all set values are within their type's domain.
       #

data/lib/omnizip/models/parallel_options.rb

@@ -20,6 +20,8 @@ module Omnizip
     # @example Use with parallel compression
     #   Omnizip::Parallel.compress_directory('files/', 'backup.zip', options)
     class ParallelOptions < Lutaml::Model::Serializable
+      include AttributeApply
+
       # @return [Integer] Number of worker threads (default: auto-detect)
       attribute :threads, :integer, default: -> { detect_cpu_count }
 
@@ -75,12 +77,6 @@ module Omnizip
       #
       # @param values [Hash{Symbol=>Object}] attributes to set
       # @return [self]
-      def apply(values)
-        self.class.attributes.each_key do |name|
-          public_send("#{name}=", values[name]) if values.key?(name)
-        end
-        self
-      end
 
       private
 

data/lib/omnizip/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Omnizip
-  VERSION = "0.3.26"
+  VERSION = "0.3.28"
 end

data/lib/omnizip.rb

@@ -89,6 +89,7 @@ end
 module Omnizip
   module Models
     autoload :AlgorithmMetadata, "omnizip/models/algorithm_metadata"
+    autoload :AttributeApply, "omnizip/models/attribute_apply"
     autoload :CompressionOptions, "omnizip/models/compression_options"
     autoload :PerformanceResult, "omnizip/models/performance_result"
     autoload :ProfileReport, "omnizip/models/profile_report"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omnizip
 version: !ruby/object:Gem::Version
-  version: 0.3.26
+  version: 0.3.28
 platform: ruby
 authors:
 - Ribose Inc.
@@ -249,6 +249,7 @@ files:
 - lib/omnizip/algorithms/lzma/literal_decoder.rb
 - lib/omnizip/algorithms/lzma/literal_encoder.rb
 - lib/omnizip/algorithms/lzma/lzip_decoder.rb
+- lib/omnizip/algorithms/lzma/lzma1_encoder.rb
 - lib/omnizip/algorithms/lzma/lzma_alone_decoder.rb
 - lib/omnizip/algorithms/lzma/lzma_state.rb
 - lib/omnizip/algorithms/lzma/match.rb
@@ -613,6 +614,7 @@ files:
 - lib/omnizip/metadata/metadata_validator.rb
 - lib/omnizip/models/.keep
 - lib/omnizip/models/algorithm_metadata.rb
+- lib/omnizip/models/attribute_apply.rb
 - lib/omnizip/models/compression_options.rb
 - lib/omnizip/models/conversion_options.rb
 - lib/omnizip/models/conversion_result.rb