omnizip 0.3.2 → 0.3.4

data/docs/guides/archive-formats/rpm-format.adoc

@@ -0,0 +1,249 @@
+---
+title: RPM Format
+nav_order: 9
+parent: Archive Formats
+grand_parent: Guides
+---
+
+[[rpm-format]]
+== Purpose
+
+RPM (Red Hat Package Manager) is the standard package format for Red Hat-based Linux distributions (RHEL, CentOS, Fedora). RPM packages contain software binaries, metadata, and scripts packaged in a single archive with a CPIO payload compressed using gzip, bzip2, xz, or zstd.
+
+== Key Characteristics
+
+[cols="1,3"]
+|===
+|Property |Value
+
+|Compression
+|gzip, bzip2, xz, or zstd
+
+|Encryption
+|GPG signature verification
+
+|Archive Support
+|Single package with CPIO payload
+
+|Large Files
+|Limited by CPIO and compression
+
+|Best For
+|Linux software distribution, RPM-based systems
+|===
+
+== Basic Usage
+
+=== Read RPM Package Metadata
+
+[source,ruby]
+----
+# Open and read RPM metadata
+rpm = Omnizip::Rpm.open('package.rpm')
+
+puts "Name: #{rpm.name}"
+puts "Version: #{rpm.version}"
+puts "Release: #{rpm.release}"
+puts "Architecture: #{rpm.arch}"
+puts "Summary: #{rpm.summary}"
+puts "Description: #{rpm.description}"
+
+# List package contents
+rpm.each_entry do |entry|
+  puts "#{entry.path} (#{entry.size} bytes)"
+end
+
+rpm.close
+----
+
+=== Extract RPM Package
+
+[source,ruby]
+----
+# Extract all files from RPM
+Omnizip::Rpm.extract('package.rpm', '/output/directory/')
+
+# Extract specific files
+Omnizip::Rpm.open('package.rpm') do |rpm|
+  rpm.extract_files(['usr/bin/app', 'usr/share/man/man1/app.1.gz'], '/output/')
+end
+----
+
+=== Check RPM Signature
+
+[source,ruby]
+----
+# Verify RPM signature (requires GPG keys)
+rpm = Omnizip::Rpm.open('package.rpm')
+if rpm.signed?
+  puts "Package is GPG signed"
+  puts "Key ID: #{rpm.signature_key_id}"
+end
+----
+
+== RPM Structure
+
+RPM packages consist of:
+
+. **Lead** - 96 bytes identifying the package
+. **Signature** - Header with cryptographic signatures
+. **Header** - Metadata (name, version, dependencies, scripts)
+. **Payload** - CPIO archive compressed with gzip/bzip2/xz/zstd
+
+[source,ruby]
+----
+# Internal RPM structure
+rpm = Omnizip::Rpm.open('package.rpm')
+
+# Access lead
+puts rpm.lead.inspect
+
+# Access signature
+puts rpm.signature.inspect
+
+# Access header (metadata)
+puts rpm.header.inspect
+
+# Access payload directly (compressed CPIO)
+puts rpm.payload.inspect
+----
+
+== Payload Extraction
+
+The RPM payload is a CPIO archive that can be extracted:
+
+[source,ruby]
+----
+# Extract only the payload (files)
+Omnizip::Rpm.open('package.rpm') do |rpm|
+  rpm.extract_payload('/output/directory/')
+end
+
+# Access payload entries directly
+Omnizip::Rpm.open('package.rpm') do |rpm|
+  rpm.each_payload_entry do |entry|
+    puts "Entry: #{entry.path}"
+    puts "Content: #{entry.read[0, 100]}..."
+  end
+end
+----
+
+== Compression Types
+
+RPM supports four payload compression formats:
+
+[cols="2,1,1"]
+|===
+|Format |Extension |Compression Ratio
+
+|gzip
+|.gz
+|Good
+
+|bzip2
+|.bz2
+|Better
+
+|xz
+|.xz
+|Best
+
+|zstd
+|.zst
+|Best (modern)
+|===
+
+[source,ruby]
+----
+# Check compression type
+rpm = Omnizip::Rpm.open('package.rpm')
+puts "Compression: #{rpm.compression_type}"
+
+# Handle different compression types
+case rpm.compression_type
+when :gzip
+  puts "Using gzip decompression"
+when :bzip2
+  puts "Using bzip2 decompression"
+when :xz
+  puts "Using xz decompression"
+when :zstd
+  puts "Using zstd decompression"
+end
+----
+
+== Scriptlets
+
+RPM packages can contain pre/post install scripts:
+
+[source,ruby]
+----
+# Access scriptlets
+rpm = Omnizip::Rpm.open('package.rpm')
+
+puts "Pre-install script: #{rpm.pre_install_script}"
+puts "Post-install script: #{rpm.post_install_script}"
+puts "Pre-uninstall script: #{rpm.pre_uninstall_script}"
+puts "Post-uninstall script: #{rpm.post_uninstall_script}"
+----
+
+== Dependencies
+
+RPM packages declare dependencies:
+
+[source,ruby]
+----
+# Access dependencies
+rpm = Omnizip::Rpm.open('package.rpm')
+
+# Required packages
+puts "Requires:"
+rpm.requires.each do |dep|
+  puts "  #{dep.name} #{dep.version}"
+end
+
+# Provided capabilities
+puts "Provides:"
+rpm.provides.each do |cap|
+  puts "  #{cap.name}"
+end
+
+# Required capabilities
+puts "Requires:"
+rpm.requires.each do |req|
+  puts "  #{req.name} #{req.version}"
+end
+
+# Conflicts
+puts "Conflicts:"
+rpm.conflicts.each do |conf|
+  puts "  #{conf.name} #{conf.version}"
+end
+----
+
+== File Information
+
+RPM tracks detailed file information:
+
+[source,ruby]
+----
+# Access file entries
+Omnizip::Rpm.open('package.rpm') do |rpm|
+  rpm.each_file do |file|
+    puts "Path: #{file.path}"
+    puts "Size: #{file.size}"
+    puts "Mode: #{file.mode.to_s(8)}"
+    puts "Owner: #{file.owner}"
+    puts "Group: #{file.group}"
+    puts "MD5: #{file.md5}" if file.md5
+    puts "Is config: #{file.config?}"
+    puts "Is doc: #{file.doc?}"
+  end
+end
+----
+
+== See Also
+
+* link:tar-format.html[TAR Format] - Related archive format
+* link:xz-format.html[XZ Format] - XZ compression used in some RPMs
+* link:cpio-format.html[CPIO Format] - Underlying payload format

data/docs/index.adoc

@@ -66,6 +66,8 @@ Follow this learning path:
 * link:guides/archive-formats/tar-format.html[TAR archives]
 * link:guides/archive-formats/gzip-format.html[GZIP files]
 * link:guides/archive-formats/xz-format.html[XZ files]
+* link:guides/archive-formats/rpm-format.html[RPM packages]
+* link:guides/archive-formats/ole-format.html[OLE compound documents]
 
 **Advanced Features**
 
@@ -113,7 +115,7 @@ Omnizip supports 6 major compression algorithms:
 
 === Supported Archive Formats
 
-Omnizip supports 10 archive formats:
+Omnizip supports 12 archive formats:
 
 [cols="1,3,2"]
 |===
@@ -154,13 +156,21 @@ Omnizip supports 10 archive formats:
 |BZIP2
 |BZIP2 compressed files
 |Text file compression
+
+|RPM
+|RPM package archives with CPIO payload
+|Linux package management
+
+|OLE
+|OLE compound documents (MSI, DOC, XLS, PPT)
+|Windows compound files, installers
 |===
 
 === Key Features
 
 * **Pure Ruby** - No native dependencies, works on any Ruby platform
 * **Registry-Based** - Extensible plugin architecture for algorithms and formats
-* **Multiple Formats** - Support for 10+ archive formats
+* **Multiple Formats** - Support for 12+ archive formats
 * **Compression Profiles** - Smart algorithm selection based on file type
 * **Solid Archives** - Shared dictionary for better compression ratios
 * **Multi-Volume** - Split archives across multiple files

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

@@ -74,7 +74,8 @@ module Omnizip
         #
         # @return [void]
         def reset_models
-          if (ENV["DEBUG_RESET_MODELS"]) && (ENV["LZMA_DEBUG_DISTANCE"])
+          if ENV.fetch("DEBUG_RESET_MODELS",
+                       nil) && ENV.fetch("LZMA_DEBUG_DISTANCE", nil)
             puts "    [DistanceCoder.reset_models] Resetting #{@slot_encoders.size} len_states, each with #{@slot_encoders[0]&.size || '?'} models"
           end
           @slot_encoders.each do |len_state_models|
@@ -82,7 +83,8 @@ module Omnizip
           end
           @pos_encoders.each(&:reset)
           @align_encoder.each(&:reset)
-          if (ENV["DEBUG_RESET_MODELS"]) && (ENV["LZMA_DEBUG_DISTANCE"])
+          if ENV.fetch("DEBUG_RESET_MODELS",
+                       nil) && ENV.fetch("LZMA_DEBUG_DISTANCE", nil)
             puts "    [DistanceCoder.reset_models] Done resetting"
           end
         end
@@ -153,9 +155,11 @@ module Omnizip
                                                         )
 
           # DEBUG: Trace all when LZMA_DEBUG_DISTANCE is set
-          trace_all = ENV["LZMA_DEBUG_DISTANCE"]
+          trace_all = ENV.fetch("LZMA_DEBUG_DISTANCE", nil)
 
-          if (trace_325 || trace_large || trace_all) && (ENV["LZMA_DEBUG_DISTANCE"])
+          if (trace_325 || trace_large || trace_all) && ENV.fetch(
+            "LZMA_DEBUG_DISTANCE", nil
+          )
             puts "  [DistanceCoder.decode ##{$distance_decode_count}] START - len_state=#{len_state}"
             puts "    BEFORE: range=#{range_decoder.range.inspect}, code=#{range_decoder.code.inspect}"
           end
@@ -163,7 +167,9 @@ module Omnizip
           slot = decode_tree(range_decoder, @slot_encoders[len_state],
                              NUM_DIST_SLOT_BITS)
 
-          if (debug_this || trace_large || trace_all) && (ENV["LZMA_DEBUG_DISTANCE"])
+          if (debug_this || trace_large || trace_all) && ENV.fetch(
+            "LZMA_DEBUG_DISTANCE", nil
+          )
             puts "  [DistanceCoder.decode ##{$distance_decode_count}] len_state=#{len_state}, slot=#{slot}"
             puts "    @slot_encoders[#{len_state}] object_id=#{@slot_encoders[len_state].object_id}"
           end
@@ -172,7 +178,7 @@ module Omnizip
           if slot < START_POS_MODEL_INDEX
             # Slots 0-3: No extra bits
             $distance_decode_count += 1
-            if debug_this && (ENV["LZMA_DEBUG_DISTANCE"])
+            if debug_this && ENV.fetch("LZMA_DEBUG_DISTANCE", nil)
               puts "    -> distance=#{slot}"
             end
             slot
@@ -187,7 +193,7 @@ module Omnizip
                                                   base - slot - 1,
                                                   footer_bits)
               $distance_decode_count += 1
-              if debug_this && (ENV["LZMA_DEBUG_DISTANCE"])
+              if debug_this && ENV.fetch("LZMA_DEBUG_DISTANCE", nil)
                 puts "    -> distance=#{result} (slot #{slot})"
               end
             else
@@ -213,14 +219,16 @@ module Omnizip
 
               # Use decode_direct_bits_with_base to match XZ Utils rc_direct
               # rc_direct builds on the base value iteratively
-              result = range_decoder.decode_direct_bits_with_base(num_direct_bits, result)
+              result = range_decoder.decode_direct_bits_with_base(
+                num_direct_bits, result
+              )
 
               # Decode low 4 bits using aligned encoder (reverse tree)
               low_bits = decode_reverse_tree(range_decoder,
                                              @align_encoder,
                                              0,
                                              DIST_ALIGN_BITS)
-              if trace_326 && (ENV["LZMA_DEBUG_DISTANCE"])
+              if trace_326 && ENV.fetch("LZMA_DEBUG_DISTANCE", nil)
                 puts "    TRACE_326: low_bits=#{low_bits}"
               end
 
@@ -228,7 +236,9 @@ module Omnizip
               # NOTE: slot value is NOT added (XZ Utils pattern - line 513 adds symbol for EOPM check only)
               result = (result << DIST_ALIGN_BITS) + low_bits
               $distance_decode_count += 1
-              if (debug_this || trace_large) && (ENV["LZMA_DEBUG_DISTANCE"])
+              if (debug_this || trace_large) && ENV.fetch(
+                "LZMA_DEBUG_DISTANCE", nil
+              )
                 puts "    -> slot=#{slot}, result_after_direct=#{result >> DIST_ALIGN_BITS}, low_bits=#{low_bits}, distance=#{result}"
               end
               if result > 100000
@@ -314,10 +324,10 @@ module Omnizip
         # @return [void]
         def encode_tree(range_encoder, models, symbol, num_bits)
           m = 1
-          trace_all = ENV["TRACE_ALL_SLOT_ENCODE"]
+          trace_all = ENV.fetch("TRACE_ALL_SLOT_ENCODE", nil)
           iteration = 0
 
-          if trace_all && (ENV["LZMA_DEBUG_ENCODE"])
+          if trace_all && ENV.fetch("LZMA_DEBUG_ENCODE", nil)
             puts "    [encode_tree START] RECEIVED symbol=#{symbol}, num_bits=#{num_bits}"
             puts "      BEFORE: range=#{range_encoder.range}, low=#{range_encoder.low}"
           end
@@ -325,7 +335,7 @@ module Omnizip
           (num_bits - 1).downto(0) do |i|
             iteration += 1
             bit = (symbol >> i) & 1
-            if trace_all && (ENV["LZMA_DEBUG_ENCODE"])
+            if trace_all && ENV.fetch("LZMA_DEBUG_ENCODE", nil)
               model_idx = m
               puts "      [#{iteration}/#{num_bits}] i=#{i}, bit=#{bit}, m=#{m}, model_idx=#{model_idx}, prob=#{models[m].probability}"
             end
@@ -333,7 +343,7 @@ module Omnizip
             m = (m << 1) | bit
           end
 
-          if trace_all && (ENV["LZMA_DEBUG_ENCODE"])
+          if trace_all && ENV.fetch("LZMA_DEBUG_ENCODE", nil)
             puts "      AFTER: range=#{range_encoder.range}, low=#{range_encoder.low}"
             puts "    [encode_tree END] ENCODED symbol=#{symbol}"
           end
@@ -350,10 +360,10 @@ module Omnizip
           symbol = 0
           trace_this = (num_bits == 6 && ENV.fetch("TRACE_SLOT_DECODE",
                                                    nil)) || ($distance_decode_count == 28)
-          trace_all = ENV["TRACE_ALL_SLOT_DECODE"]
+          trace_all = ENV.fetch("TRACE_ALL_SLOT_DECODE", nil)
           iteration = 0
 
-          if (trace_this || trace_all) && (ENV["LZMA_DEBUG_DISTANCE"])
+          if (trace_this || trace_all) && ENV.fetch("LZMA_DEBUG_DISTANCE", nil)
             puts "    [decode_tree START] num_bits=#{num_bits}, range=#{range_decoder.range}, code=#{range_decoder.code}"
             puts "      models array object_id=#{models.object_id}"
           end
@@ -364,11 +374,12 @@ module Omnizip
             bit = range_decoder.decode_bit(model)
             m = (m << 1) | bit
             symbol |= (bit << i)
-            if (trace_this || trace_all) && (ENV["LZMA_DEBUG_DISTANCE"])
+            if (trace_this || trace_all) && ENV.fetch("LZMA_DEBUG_DISTANCE",
+                                                      nil)
               puts "      [#{iteration}/#{num_bits}] i=#{i}, bit=#{bit}, m=#{m}, model.object_id=#{model.object_id}, prob=#{model.probability}, symbol=#{symbol}"
             end
           end
-          if (trace_this || trace_all) && (ENV["LZMA_DEBUG_DISTANCE"])
+          if (trace_this || trace_all) && ENV.fetch("LZMA_DEBUG_DISTANCE", nil)
             puts "    [decode_tree END] symbol=#{symbol}"
           end
           symbol

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

@@ -76,7 +76,8 @@ module Omnizip
                     XzEncoderAdapter.new(output, options)
                   else
                     # Use SdkEncoder (7-Zip LZMA SDK compatible) - DEFAULT
-                    Implementations::SevenZip::LZMA::Encoder.new(output, options)
+                    Implementations::SevenZip::LZMA::Encoder.new(output,
+                                                                 options)
                   end
         end
 

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

@@ -70,7 +70,8 @@ module Omnizip
         # @param pos_state [Integer] Position state for tree selection
         # @return [void]
         def encode(range_encoder, length, pos_state)
-          trace_encode = ENV.fetch("LZMA_DEBUG_ENCODE", nil) && ENV.fetch("TRACE_LENGTH_CODER", nil)
+          trace_encode = ENV.fetch("LZMA_DEBUG_ENCODE",
+                                   nil) && ENV.fetch("TRACE_LENGTH_CODER", nil)
 
           if trace_encode
             puts "    [LengthCoder.encode] START: length=#{length}, pos_state=#{pos_state}"
@@ -138,7 +139,8 @@ module Omnizip
         # @param pos_state [Integer] Position state for tree selection
         # @return [Integer] Decoded length value (before adding MATCH_LEN_MIN)
         def decode(range_decoder, pos_state)
-          trace_decode = ENV.fetch("LZMA_DEBUG_DISTANCE", nil) && ENV.fetch("TRACE_LENGTH_CODER", nil)
+          trace_decode = ENV.fetch("LZMA_DEBUG_DISTANCE",
+                                   nil) && ENV.fetch("TRACE_LENGTH_CODER", nil)
 
           if trace_decode
             caller_loc = caller_locations(2, 1).first
@@ -160,7 +162,8 @@ module Omnizip
             if trace_decode
               puts "      Using LOW tree"
             end
-            result = decode_tree(range_decoder, @low[pos_state], NUM_LEN_LOW_BITS)
+            result = decode_tree(range_decoder, @low[pos_state],
+                                 NUM_LEN_LOW_BITS)
           elsif range_decoder.decode_bit(@choice2).zero?
             # Mid tree
             if trace_decode

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

@@ -281,7 +281,8 @@ module Omnizip
           end
 
           result = symbol - 0x100
-          if trace_233 || (ENV.fetch("TRACE_MATCHED_DECODE", nil) && lit_state == 96)
+          if trace_233 || (ENV.fetch("TRACE_MATCHED_DECODE",
+                                     nil) && lit_state == 96)
             puts "\n  FINAL RESULT: 0x#{result.to_s(16).upcase} ('#{result.chr}')"
             if trace_233
               puts "  Result bits: #{result_bits.join}"

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

@@ -151,7 +151,7 @@ module Omnizip
               @input.read(footer_size)
               @member_size += footer_size
             else
-              data_to_crc = decoded_data || +''
+              data_to_crc = decoded_data || +""
               calculated_crc = Omnizip::Checksums::Crc32.calculate(data_to_crc)
               @uncompressed_size = data_to_crc.bytesize
 
@@ -211,31 +211,45 @@ module Omnizip
           # Step 1: Verify magic bytes (SEQ_ID_STRING)
           # Reference: lzip_decoder.c:104-153
           magic_bytes = @input.read(4)
-          raise Omnizip::DecompressionError, "Incomplete .lz header: missing magic bytes" if magic_bytes.nil? || magic_bytes.bytesize < 4
+          if magic_bytes.nil? || magic_bytes.bytesize < 4
+            raise Omnizip::DecompressionError,
+                  "Incomplete .lz header: missing magic bytes"
+          end
 
           4.times do |i|
             if magic_bytes.getbyte(i) != MAGIC[i]
-              raise Omnizip::DecompressionError, "Invalid .lz header: magic bytes don't match LZIP (expected #{MAGIC.map { |b| "0x#{b.to_s(16).upcase}" }.join(' ')}, got #{magic_bytes.bytes.map { |b| "0x#{b.to_s(16).upcase}" }.join(' ')})"
+              raise Omnizip::DecompressionError, "Invalid .lz header: magic bytes don't match LZIP (expected #{MAGIC.map do |b|
+                "0x#{b.to_s(16).upcase}"
+              end.join(' ')}, got #{magic_bytes.bytes.map do |b|
+                                    "0x#{b.to_s(16).upcase}"
+                                  end.join(' ')})"
             end
           end
 
           # Step 2: Read version byte (SEQ_VERSION)
           # Reference: lzip_decoder.c:156-174
           version_byte = @input.getbyte
-          raise Omnizip::DecompressionError, "Incomplete .lz header: missing version byte" if version_byte.nil?
+          if version_byte.nil?
+            raise Omnizip::DecompressionError,
+                  "Incomplete .lz header: missing version byte"
+          end
 
           @version = version_byte
 
           # We support version 0 and unextended version 1
           # Reference: lzip_decoder.c:163-164
           if @version > 1
-            raise Omnizip::UnsupportedFormatError, "Unsupported .lz version: #{@version} (only 0 and 1 are supported)"
+            raise Omnizip::UnsupportedFormatError,
+                  "Unsupported .lz version: #{@version} (only 0 and 1 are supported)"
           end
 
           # Step 3: Parse dictionary size (SEQ_DICT_SIZE)
           # Reference: lzip_decoder.c:177-222
           dict_size_byte = @input.getbyte
-          raise Omnizip::DecompressionError, "Incomplete .lz header: missing dictionary size byte" if dict_size_byte.nil?
+          if dict_size_byte.nil?
+            raise Omnizip::DecompressionError,
+                  "Incomplete .lz header: missing dictionary size byte"
+          end
 
           # Decode dictionary size from the encoded byte
           # The five lowest bits are for the base-2 logarithm of the dictionary size
@@ -247,7 +261,8 @@ module Omnizip
           # Validate range: [4 KiB, 512 MiB]
           # Reference: lzip_decoder.c:198-199
           if b2log < 12 || b2log > 29 || (b2log == 12 && fracnum.positive?)
-            raise Omnizip::DecompressionError, "Invalid .lz header: dictionary size byte 0x#{dict_size_byte.to_s(16).upcase} is out of valid range"
+            raise Omnizip::DecompressionError,
+                  "Invalid .lz header: dictionary size byte 0x#{dict_size_byte.to_s(16).upcase} is out of valid range"
           end
 
           # Calculate: 2^[b2log] - [fracnum] * 2^([b2log] - 4)
@@ -255,8 +270,14 @@ module Omnizip
           @dict_size = (1 << b2log) - (fracnum << (b2log - 4))
 
           # Sanity checks
-          raise Omnizip::DecompressionError, "Dictionary size calculation error: too small" if @dict_size < MIN_DICT_SIZE
-          raise Omnizip::DecompressionError, "Dictionary size calculation error: too large" if @dict_size > MAX_DICT_SIZE
+          if @dict_size < MIN_DICT_SIZE
+            raise Omnizip::DecompressionError,
+                  "Dictionary size calculation error: too small"
+          end
+          if @dict_size > MAX_DICT_SIZE
+            raise Omnizip::DecompressionError,
+                  "Dictionary size calculation error: too large"
+          end
         end
 
         # Verify .lz format footer
@@ -273,7 +294,10 @@ module Omnizip
         def verify_footer(calculated_crc)
           footer_size = @version.zero? ? LZIP_V0_FOOTER_SIZE : LZIP_V1_FOOTER_SIZE
           footer = @input.read(footer_size)
-          raise Omnizip::DecompressionError, "Incomplete .lz footer: expected #{footer_size} bytes, got #{footer&.bytesize || 0}" if footer.nil? || footer.bytesize < footer_size
+          if footer.nil? || footer.bytesize < footer_size
+            raise Omnizip::DecompressionError,
+                  "Incomplete .lz footer: expected #{footer_size} bytes, got #{footer&.bytesize || 0}"
+          end
 
           # Update member_size to include the footer
           @member_size += footer_size
@@ -284,7 +308,8 @@ module Omnizip
 
           # Verify CRC32
           if calculated_crc != stored_crc
-            raise Omnizip::ChecksumError, "CRC32 mismatch: calculated 0x#{calculated_crc.to_s(16).upcase}, stored 0x#{stored_crc.to_s(16).upcase}"
+            raise Omnizip::ChecksumError,
+                  "CRC32 mismatch: calculated 0x#{calculated_crc.to_s(16).upcase}, stored 0x#{stored_crc.to_s(16).upcase}"
           end
 
           # Parse and verify uncompressed size (little-endian)
@@ -294,7 +319,8 @@ module Omnizip
             (footer.getbyte(10) << 48) | (footer.getbyte(11) << 56)
 
           if @uncompressed_size != stored_uncompressed_size
-            raise Omnizip::ChecksumError, "Uncompressed size mismatch: decoded #{@uncompressed_size}, stored #{stored_uncompressed_size}"
+            raise Omnizip::ChecksumError,
+                  "Uncompressed size mismatch: decoded #{@uncompressed_size}, stored #{stored_uncompressed_size}"
           end
 
           # For version 1, verify member size
@@ -305,7 +331,8 @@ module Omnizip
               (footer.getbyte(18) << 48) | (footer.getbyte(19) << 56)
 
             if @member_size != stored_member_size
-              raise Omnizip::ChecksumError, "Member size mismatch: decoded #{@member_size}, stored #{stored_member_size}"
+              raise Omnizip::ChecksumError,
+                    "Member size mismatch: decoded #{@member_size}, stored #{stored_member_size}"
             end
           end
         end

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

@@ -84,7 +84,8 @@ module Omnizip
           prob_before = model.probability if trace_model_updates
 
           # DEBUG: Trace is_rep bit decoding
-          trace_is_rep = ENV.fetch("TRACE_IS_REP_BITS", nil) && (bound > 1_000_000)
+          trace_is_rep = ENV.fetch("TRACE_IS_REP_BITS",
+                                   nil) && (bound > 1_000_000)
 
           if trace_is_rep
             puts "  [RangeDecoder.decode_bit] BEFORE: range=#{@range}, code=#{@code}, bound=#{bound}, prob=#{model.probability}"
@@ -118,7 +119,8 @@ module Omnizip
           end
 
           # DEBUG: Trace decode_bit for specific problematic state
-          if ENV.fetch("TRACE_SPECIFIC_DECODE", nil) && @range == 0x40000000 && @code == 0x21407d82
+          if ENV.fetch("TRACE_SPECIFIC_DECODE",
+                       nil) && @range == 0x40000000 && @code == 0x21407d82
             puts "    === CRITICAL DECODE_BIT (MATCHED LITERAL) ==="
             puts "    BEFORE: range=0x#{@range.to_s(16)} (#{@range})"
             puts "    BEFORE: code=0x#{@code.to_s(16)} (#{@code})"
@@ -219,6 +221,38 @@ module Omnizip
           result
         end
 
+        # Decode a cumulative frequency value
+        #
+        # This is used by PPMd for decoding symbols based on their
+        # frequency distribution. Returns the cumulative frequency
+        # that can be mapped back to a symbol.
+        #
+        # @param total_freq [Integer] Total frequency of all symbols in context
+        # @return [Integer] The cumulative frequency value
+        def decode_freq(total_freq)
+          normalize
+          range_freq = @range / total_freq
+          @code / range_freq
+        end
+
+        # Normalize after decoding a symbol with frequency
+        #
+        # After using decode_freq to get the cumulative frequency,
+        # call this to update the range decoder state.
+        #
+        # @param cum_freq [Integer] Cumulative frequency of decoded symbol
+        # @param freq [Integer] Frequency of decoded symbol
+        # @param total_freq [Integer] Total frequency of all symbols
+        # @return [void]
+        def normalize_freq(cum_freq, freq, total_freq)
+          range_freq = @range / total_freq
+          low_bound = range_freq * cum_freq
+          high_bound = range_freq * (cum_freq + freq)
+
+          @code -= low_bound
+          @range = (high_bound - low_bound) & 0xFFFFFFFF
+        end
+
         # Decode bits directly using a base value (XZ Utils rc_direct pattern)
         #
         # This method implements the XZ Utils rc_direct macro which is used