omnizip 0.4.7-arm-linux

data/lib/omnizip/formats/xz.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Omnizip
+  module Formats
+    # XZ compression format
+    # Creates .xz files compatible with XZ Utils
+    class Xz
+      # Nested classes - autoloaded
+      autoload :Reader, "omnizip/formats/xz/reader"
+      autoload :Writer, "omnizip/formats/xz/writer"
+
+      class << self
+        # Create a .xz file from input data
+        # @param input [String, IO] Input data to compress
+        # @param output [String, IO] Output file path or IO object
+        # @param options [Hash] Compression options
+        # @option options [Integer] :dict_size Dictionary size (default: 8MB to match XZ Utils preset 6)
+        # @option options [Integer] :check Check type (default: CRC64)
+        def create(input, output = nil, options = {})
+          encoder = ::Omnizip::Formats::XzImpl::StreamEncoder.new(
+            check_type: options[:check] || ::Omnizip::Formats::XzConst::CHECK_CRC64,
+            dict_size: options[:dict_size] || (64 * 1024 * 1024),
+          )
+
+          compressed = encoder.encode(input)
+
+          if output
+            Omnizip::IO::Sink.for(output).write(compressed)
+          else
+            compressed
+          end
+        end
+
+        # Convenience method with block syntax
+        # @example
+        #   Xz.create_file('output.xz') do |xz|
+        #     xz.add_data('Hello, XZ!')
+        #   end
+        def create_file(path, options = {})
+          builder = Builder.new(options)
+          yield builder if block_given?
+
+          compressed = create(builder.data, nil, options)
+          File.binwrite(path, compressed)
+        end
+
+        # Decode XZ data (alias for decompress with no output)
+        # @param input [String, IO] Input XZ data or file path
+        # @return [String] Decompressed data
+        def decode(input)
+          decompress(input)
+        end
+
+        # Decompress XZ, LZIP (.lz), or LZMA_Alone (.lzma) data
+        #
+        # This method automatically detects the format based on magic bytes and
+        # routes to the appropriate decoder:
+        # - XZ format (.xz): Container format with stream header/footer/index
+        # - LZIP format (.lz): Standalone format with "LZIP" magic and CRC32 footer
+        # - LZMA_Alone format (.lzma): Legacy standalone format with properties byte
+        #
+        # @param input [String, IO] Input data or file path
+        # @param output [String, IO, nil] Output file path or IO object
+        # @param options [Hash] Options (reserved for future use)
+        # @return [String, nil] Decompressed data (if output is nil)
+        def decompress(input, output = nil, _options = {})
+          data = Omnizip::IO::Source.for(input).read
+
+          # Detect format and decode
+          decompressed = decode_lzma_data(data)
+
+          if output
+            Omnizip::IO::Sink.for(output).write(decompressed)
+            nil
+          else
+            decompressed
+          end
+        end
+
+        private
+
+        # Decode LZMA-based data by detecting format
+        # @param data [String] Input data
+        # @return [String] Decompressed data
+        def decode_lzma_data(data)
+          format = detect_lzma_format(data)
+
+          case format
+          when :lz
+            Backends.decompress("lzip", data, Backends::UNKNOWN_LENGTH) do
+              decode_lzip(data)
+            end
+          when :lzma_alone
+            Backends.decompress("lzma-alone", data, Backends::UNKNOWN_LENGTH) do
+              decode_lzma_alone(data)
+            end
+          when :xz
+            Backends.decompress("xz", data, Backends::UNKNOWN_LENGTH) do
+              decode_xz_stream(data)
+            end
+          else
+            raise FormatError, "Unknown LZMA format: cannot detect valid format"
+          end
+        end
+
+        # Detect LZMA format from magic bytes
+        # @param data [String] Input data
+        # @return [Symbol] Format type (:xz, :lz, :lzma_alone)
+        def detect_lzma_format(data)
+          return :unknown if data.nil? || data.bytesize < 4
+
+          first_bytes = data.byteslice(0, 6).bytes.to_a
+
+          # Check XZ magic: FD 37 7A 58 5A 00
+          # Reference: xz-file-format-1.2.1.txt Section 2.1.1.1
+          if first_bytes[0] == 0xFD && first_bytes[1] == 0x37 &&
+              first_bytes[2] == 0x7A && first_bytes[3] == 0x58 &&
+              first_bytes[4] == 0x5A && first_bytes[5].zero?
+            return :xz
+          end
+
+          # Check LZIP magic: 4C 5A 49 50 ("LZIP")
+          # Reference: /Users/mulgogi/src/external/xz/src/liblzma/common/lzip_decoder.c:106
+          if first_bytes[0] == 0x4C && first_bytes[1] == 0x5A &&
+              first_bytes[2] == 0x49 && first_bytes[3] == 0x50
+            return :lz
+          end
+
+          # Default to LZMA_Alone (legacy format, no magic bytes)
+          # The format starts with properties byte, dictionary size, and uncompressed size
+          # Reference: /Users/mulgogi/src/external/xz/src/liblzma/common/alone_decoder.c
+          :lzma_alone
+        end
+
+        # Decode LZIP format (.lz files)
+        # @param data [String] Input data
+        # @return [String] Decompressed data
+        def decode_lzip(data)
+          input = StringIO.new(data)
+          decoder = Omnizip::Algorithms::LZMA::LzipDecoder.new(input)
+          decoder.decode_stream
+        rescue StandardError => e
+          raise FormatError, "Failed to decode LZIP format: #{e.message}"
+        end
+
+        # Decode LZMA_Alone format (.lzma files)
+        # @param data [String] Input data
+        # @return [String] Decompressed data
+        def decode_lzma_alone(data)
+          input = StringIO.new(data)
+          decoder = Omnizip::Algorithms::LZMA::LzmaAloneDecoder.new(input)
+          decoder.decode_stream
+        rescue StandardError => e
+          raise FormatError, "Failed to decode LZMA_Alone format: #{e.message}"
+        end
+
+        # Decode XZ format stream
+        # @param data [String] Input data
+        # @return [String] Decompressed data
+        def decode_xz_stream(data)
+          input_io = StringIO.new(data.b)
+          reader = Reader.new(input_io)
+          reader.read
+        rescue StandardError => e
+          raise FormatError, "Failed to decode XZ format: #{e.message}"
+        end
+
+        # Alias for compatibility
+        alias decode decompress
+        alias extract decompress
+
+        # Entry method for archive-like interface
+        # @param input [String, IO] Input XZ data or file path
+        # @param options [Hash] Options (reserved)
+        # @yield [Entry] Yields entry (XZ has single data stream)
+        # @return [String, Entry] Decompressed data or Entry if no block given
+        def extract_entry(input, options = {})
+          data = decompress(input, nil, options)
+
+          entry = Entry.new(data)
+          if block_given?
+            yield entry
+          else
+            entry
+          end
+        end
+      end
+
+      # Builder class for convenient file creation
+      class Builder
+        attr_reader :data
+
+        def initialize(_options = {})
+          @data = String.new(encoding: Encoding::BINARY)
+        end
+
+        def add_data(content)
+          @data << content.to_s.dup.force_encoding(Encoding::BINARY)
+        end
+
+        def add_file(path)
+          content = File.binread(path)
+          add_data(content)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/xz_const.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    # XZ Format Constants (from XZ Utils specification)
+    module XzConst
+      # XZ Stream magic bytes
+      MAGIC = [0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00].freeze
+
+      # Footer magic bytes
+      FOOTER_MAGIC = [0x59, 0x5A].freeze
+
+      # Header and footer sizes
+      STREAM_HEADER_SIZE = 12
+      STREAM_FOOTER_SIZE = 12
+
+      # Stream flags size
+      STREAM_FLAGS_SIZE = 2
+
+      # Block header constraints
+      BLOCK_HEADER_SIZE_MIN = 8
+      BLOCK_HEADER_SIZE_MAX = 1024
+
+      # Backward size constraints
+      BACKWARD_SIZE_MIN = 4
+      BACKWARD_SIZE_MAX = (1 << 34) - 4 # ~17 GB
+
+      # Check types (from lzma/check.h)
+      CHECK_NONE = 0
+      CHECK_CRC32 = 1
+      CHECK_CRC64 = 4
+      CHECK_SHA256 = 10
+
+      # VLI (Variable Length Integer) constants
+      VLI_UNKNOWN = 0xFFFFFFFFFFFFFFFF # LZMA_VLI_UNKNOWN
+      VLI_BYTES_MAX = 9
+
+      # Filter IDs (from lzma/check.h)
+      # XZ Utils uses LZMA_FILTER_LZMA2 = 0x21 (as defined in lzma/lzma12.h:61)
+      FILTER_LZMA2 = 0x21
+
+      # Maximum number of filters in a chain
+      FILTERS_MAX = 4
+
+      # Index indicator (byte value that signals start of index)
+      INDEX_INDICATOR = 0x00
+    end
+  end
+end