omnizip 0.4.7-aarch64-linux

data/lib/omnizip/formats/zip/zip64_extra_field.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Zip
+      # ZIP64 Extended Information Extra Field
+      # Used in local/central headers when sizes exceed 32-bit limits
+      class Zip64ExtraField
+        include Omnizip::Formats::Zip::Constants
+
+        attr_accessor :tag, :size, :uncompressed_size, :compressed_size,
+                      :relative_header_offset, :disk_start_number
+
+        def initialize(
+          tag: ZIP64_EXTRA_FIELD_TAG,
+          uncompressed_size: nil,
+          compressed_size: nil,
+          relative_header_offset: nil,
+          disk_start_number: nil
+        )
+          @tag = tag
+          @uncompressed_size = uncompressed_size
+          @compressed_size = compressed_size
+          @relative_header_offset = relative_header_offset
+          @disk_start_number = disk_start_number
+          @size = calculate_size
+        end
+
+        # Serialize to binary format
+        def to_binary
+          @size = calculate_size
+          data = [tag, size].pack("vv")
+
+          # Fields are included in the order they're needed
+          # based on which values in the regular header are 0xFFFFFFFF
+          data << [uncompressed_size].pack("Q") if uncompressed_size
+          data << [compressed_size].pack("Q") if compressed_size
+          data << [relative_header_offset].pack("Q") if relative_header_offset
+          data << [disk_start_number].pack("V") if disk_start_number
+
+          data
+        end
+
+        # Parse from binary data
+        # needs_uncompressed, needs_compressed, needs_offset, needs_disk specify
+        # which fields should be present based on the regular header values
+        def self.from_binary(data, needs_uncompressed: false, needs_compressed: false,
+                            needs_offset: false, needs_disk: false)
+          tag, = data.unpack("vv")
+
+          unless tag == ZIP64_EXTRA_FIELD_TAG
+            raise Omnizip::FormatError,
+                  "Invalid ZIP64 extra field tag"
+          end
+
+          offset = 4 # After tag and size
+          uncompressed_size = nil
+          compressed_size = nil
+          relative_header_offset = nil
+          disk_start_number = nil
+
+          # Read fields in order based on what's needed
+          if needs_uncompressed && offset + 8 <= data.bytesize
+            uncompressed_size = data[offset, 8].unpack1("Q")
+            offset += 8
+          end
+
+          if needs_compressed && offset + 8 <= data.bytesize
+            compressed_size = data[offset, 8].unpack1("Q")
+            offset += 8
+          end
+
+          if needs_offset && offset + 8 <= data.bytesize
+            relative_header_offset = data[offset, 8].unpack1("Q")
+            offset += 8
+          end
+
+          if needs_disk && offset + 4 <= data.bytesize
+            disk_start_number = data[offset, 4].unpack1("V")
+          end
+
+          new(
+            tag: tag,
+            uncompressed_size: uncompressed_size,
+            compressed_size: compressed_size,
+            relative_header_offset: relative_header_offset,
+            disk_start_number: disk_start_number,
+          )
+        end
+
+        # Check if this extra field is needed
+        def self.needed?(uncompressed_size: 0, compressed_size: 0, offset: 0)
+          uncompressed_size >= ZIP64_LIMIT ||
+            compressed_size >= ZIP64_LIMIT ||
+            offset >= ZIP64_LIMIT
+        end
+
+        private
+
+        # Calculate the size field value
+        def calculate_size
+          size = 0
+          size += 8 if uncompressed_size
+          size += 8 if compressed_size
+          size += 8 if relative_header_offset
+          size += 4 if disk_start_number
+          size
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/zip.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    # ZIP archive format implementation
+    module Zip
+      # Nested classes - autoloaded
+      autoload :Constants, "omnizip/formats/zip/constants"
+      autoload :LocalFileHeader, "omnizip/formats/zip/local_file_header"
+      autoload :CentralDirectoryHeader,
+               "omnizip/formats/zip/central_directory_header"
+      autoload :EndOfCentralDirectory,
+               "omnizip/formats/zip/end_of_central_directory"
+      autoload :Zip64EndOfCentralDirectory,
+               "omnizip/formats/zip/zip64_end_of_central_directory"
+      autoload :Zip64EndOfCentralDirectoryLocator,
+               "omnizip/formats/zip/zip64_end_of_central_directory_locator"
+      autoload :Zip64ExtraField, "omnizip/formats/zip/zip64_extra_field"
+      autoload :Reader, "omnizip/formats/zip/reader"
+      autoload :Writer, "omnizip/formats/zip/writer"
+      autoload :UnixExtraField, "omnizip/formats/zip/unix_extra_field"
+
+      class << self
+        # Read a ZIP archive
+        def read(file_path)
+          Reader.new(file_path).read
+        end
+
+        # Create a ZIP archive
+        def create(file_path, &block)
+          writer = Writer.new(file_path)
+          yield(writer) if block
+          writer
+        end
+
+        # Extract a ZIP archive
+        def extract(file_path, output_dir)
+          reader = read(file_path)
+          reader.extract_all(output_dir)
+        end
+
+        # List entries in a ZIP archive
+        def list(file_path)
+          reader = read(file_path)
+          reader.list_entries
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    autoload :FormatSpecLoader, "omnizip/formats/format_spec_loader"
+
+    autoload :SevenZip, "omnizip/formats/seven_zip"
+    autoload :Zip, "omnizip/formats/zip"
+    autoload :Rar, "omnizip/formats/rar"
+    autoload :Rar3, "omnizip/formats/rar3"
+    autoload :Rar5, "omnizip/formats/rar5"
+    autoload :Tar, "omnizip/formats/tar"
+    autoload :Gzip, "omnizip/formats/gzip"
+    autoload :Bzip2File, "omnizip/formats/bzip2_file"
+    autoload :Xz, "omnizip/formats/xz"
+
+    autoload :Cpio, "omnizip/formats/cpio"
+    autoload :Rpm, "omnizip/formats/rpm"
+    autoload :Ole, "omnizip/formats/ole"
+    autoload :Msi, "omnizip/formats/msi"
+    autoload :Xar, "omnizip/formats/xar"
+    autoload :Iso, "omnizip/formats/iso"
+    autoload :LzmaAlone, "omnizip/formats/lzma_alone"
+    autoload :Lzip, "omnizip/formats/lzip"
+
+    autoload :XzConst, "omnizip/formats/xz_const"
+    autoload :XzImpl, "omnizip/formats/xz_impl"
+  end
+end

data/lib/omnizip/implementations/base/lzma2_decoder_base.rb

@@ -0,0 +1,75 @@
+# 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 Implementations
+    module Base
+      # Abstract base class for LZMA2 decoders.
+      #
+      # This class defines the common interface and shared functionality
+      # for all LZMA2 decoder implementations (XZ Utils, 7-Zip, etc.).
+      #
+      # Subclasses must implement the {#decode} method.
+      #
+      # @abstract Subclasses must implement {#decode}
+      class LZMA2DecoderBase
+        attr_reader :dict_size
+
+        # Initialize the LZMA2 decoder.
+        #
+        # @param input [IO] Input stream of compressed data
+        # @param options [Hash] Decoding options
+        # @option options [Integer] :dict_size Dictionary size (read from properties)
+        def initialize(input, options = {})
+          @input = input
+          # Dictionary size will be read from LZMA2 property byte by subclasses
+          @dict_size = options.fetch(:dict_size, nil)
+        end
+
+        # Decode LZMA2 compressed data.
+        #
+        # Subclasses must implement this method to provide the specific
+        # decoding logic for their implementation (XZ Utils, 7-Zip, etc.).
+        #
+        # @param output [IO] Output stream for decompressed data
+        # @raise [NotImplementedError] Always raised in base class
+        # @return [void]
+        def decode(output = nil)
+          raise NotImplementedError,
+                "#{self.class} must implement #decode"
+        end
+
+        # Get the implementation identifier.
+        #
+        # Subclasses must implement this to return a symbol identifying
+        # their implementation (e.g., :xz_utils, :seven_zip).
+        #
+        # @raise [NotImplementedError] Always raised in base class
+        # @return [Symbol] Implementation identifier
+        def implementation_name
+          raise NotImplementedError,
+                "#{self.class} must implement #implementation_name"
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/implementations/base/lzma2_encoder_base.rb

@@ -0,0 +1,128 @@
+# 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 Implementations
+    module Base
+      # Abstract base class for LZMA2 encoders.
+      #
+      # This class defines the common interface and shared functionality
+      # for all LZMA2 encoder implementations (XZ Utils, 7-Zip, etc.).
+      #
+      # LZMA2 is an improved version of LZMA that supports:
+      # - Uncompressed chunks for incompressible data
+      # - Dictionary/state resets for better compression
+      # - Simpler chunk format
+      #
+      # Subclasses must implement the {#encode} method.
+      #
+      # @abstract Subclasses must implement {#encode}
+      class LZMA2EncoderBase
+        attr_reader :dict_size, :lc, :lp, :pb
+
+        # Maximum uncompressed size per LZMA2 chunk (2MB)
+        UNCOMPRESSED_MAX = 1 << 21
+        # Maximum compressed size per LZMA2 chunk (64KB)
+        COMPRESSED_MAX = 1 << 16
+
+        # Initialize the LZMA2 encoder.
+        #
+        # @param options [Hash] Encoding options
+        # @option options [Integer] :dict_size Dictionary size (default: 8MB)
+        # @option options [Integer] :lc Literal context bits (default: 3)
+        # @option options [Integer] :lp Literal position bits (default: 0)
+        # @option options [Integer] :pb Position bits (default: 2)
+        # @option options [Boolean] :standalone Write property byte at start (default: true)
+        def initialize(options = {})
+          @dict_size = options.fetch(:dict_size, 8 * 1024 * 1024)
+          @lc = options.fetch(:lc, 3)
+          @lp = options.fetch(:lp, 0)
+          @pb = options.fetch(:pb, 2)
+          @standalone = options.fetch(:standalone, true)
+
+          validate_parameters!
+        end
+
+        # Encode data using LZMA2.
+        #
+        # Subclasses must implement this method to provide the specific
+        # encoding logic for their implementation (XZ Utils, 7-Zip, etc.).
+        #
+        # @param data [String] Input data to compress
+        # @raise [NotImplementedError] Always raised in base class
+        # @return [String] Compressed data
+        def encode(data)
+          raise NotImplementedError,
+                "#{self.class} must implement #encode"
+        end
+
+        # Get the implementation identifier.
+        #
+        # Subclasses must implement this to return a symbol identifying
+        # their implementation (e.g., :xz_utils, :seven_zip).
+        #
+        # @raise [NotImplementedError] Always raised in base class
+        # @return [Symbol] Implementation identifier
+        def implementation_name
+          raise NotImplementedError,
+                "#{self.class} must implement #implementation_name"
+        end
+
+        # Check if standalone mode is enabled.
+        #
+        # @return [Boolean] true if property byte should be written
+        def standalone?
+          @standalone
+        end
+
+        private
+
+        # Validate LZMA2 parameters.
+        #
+        # @raise [ArgumentError] If any parameter is out of valid range
+        # @return [void]
+        def validate_parameters!
+          unless @lc.between?(0, 8)
+            raise ArgumentError, "lc must be between 0 and 8, got #{@lc}"
+          end
+
+          unless @lp.between?(0, 4)
+            raise ArgumentError, "lp must be between 0 and 4, got #{@lp}"
+          end
+
+          unless @pb.between?(0, 4)
+            raise ArgumentError, "pb must be between 0 and 4, got #{@pb}"
+          end
+
+          # LZMA2 dictionary size constraints (from XZ Utils)
+          min_dict = 4096
+          max_dict = 1 << 28
+
+          unless @dict_size.between?(min_dict, max_dict)
+            raise ArgumentError,
+                  "dict_size must be between #{min_dict} and #{max_dict}, got #{@dict_size}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/implementations/base/lzma_decoder_base.rb

@@ -0,0 +1,83 @@
+# 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 Implementations
+    module Base
+      # Abstract base class for LZMA decoders.
+      #
+      # This class defines the common interface and shared functionality
+      # for all LZMA decoder implementations (XZ Utils, 7-Zip SDK, etc.).
+      #
+      # Subclasses must implement the {#decode_stream} method.
+      #
+      # @abstract Subclasses must implement {#decode_stream}
+      class LZMADecoderBase
+        attr_reader :lc, :lp, :pb, :dict_size, :uncompressed_size, :input
+
+        # Initialize the LZMA decoder.
+        #
+        # @param input [IO] Input stream of compressed data
+        # @param options [Hash] Decoding options
+        # @option options [Integer] :lc Literal context bits (read from header)
+        # @option options [Integer] :lp Literal position bits (read from header)
+        # @option options [Integer] :pb Position bits (read from header)
+        # @option options [Integer] :dict_size Dictionary size (read from header)
+        # @option options [Integer] :uncompressed_size Uncompressed size
+        def initialize(input, options = {})
+          @input = input
+          # Parameters will be read from LZMA header by subclasses
+          @lc = options.fetch(:lc, nil)
+          @lp = options.fetch(:lp, nil)
+          @pb = options.fetch(:pb, nil)
+          @dict_size = options.fetch(:dict_size, nil)
+          @uncompressed_size = options.fetch(:uncompressed_size, nil)
+        end
+
+        # Decode a stream of compressed data.
+        #
+        # Subclasses must implement this method to provide the specific
+        # decoding logic for their implementation (XZ Utils, 7-Zip, etc.).
+        #
+        # @param output [IO] Output stream for decompressed data
+        # @raise [NotImplementedError] Always raised in base class
+        # @return [void]
+        def decode_stream(output = nil)
+          raise NotImplementedError,
+                "#{self.class} must implement #decode_stream"
+        end
+
+        # Get the implementation identifier.
+        #
+        # Subclasses must implement this to return a symbol identifying
+        # their implementation (e.g., :xz_utils, :seven_zip).
+        #
+        # @raise [NotImplementedError] Always raised in base class
+        # @return [Symbol] Implementation identifier
+        def implementation_name
+          raise NotImplementedError,
+                "#{self.class} must implement #implementation_name"
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/implementations/base/lzma_encoder_base.rb

@@ -0,0 +1,108 @@
+# 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 Implementations
+    module Base
+      # Abstract base class for LZMA encoders.
+      #
+      # This class defines the common interface and shared functionality
+      # for all LZMA encoder implementations (XZ Utils, 7-Zip SDK, etc.).
+      #
+      # Subclasses must implement the {#encode_stream} method.
+      #
+      # @abstract Subclasses must implement {#encode_stream}
+      class LZMAEncoderBase
+        attr_reader :lc, :lp, :pb, :dict_size, :output
+
+        # Initialize the LZMA encoder.
+        #
+        # @param output [IO] Output stream for compressed data
+        # @param options [Hash] Encoding options
+        # @option options [Integer] :lc Literal context bits (0-8, default: 3)
+        # @option options [Integer] :lp Literal position bits (0-4, default: 0)
+        # @option options [Integer] :pb Position bits (0-4, default: 2)
+        # @option options [Integer] :dict_size Dictionary size (default: 64KB)
+        # @raise [ArgumentError] If parameters are invalid
+        def initialize(output, options = {})
+          @output = output
+          @lc = options.fetch(:lc, 3)
+          @lp = options.fetch(:lp, 0)
+          @pb = options.fetch(:pb, 2)
+          @dict_size = options.fetch(:dict_size, 1 << 16) # 64KB default
+
+          validate_parameters!
+        end
+
+        # Encode a stream of data.
+        #
+        # Subclasses must implement this method to provide the specific
+        # encoding logic for their implementation (XZ Utils, 7-Zip, etc.).
+        #
+        # @param data [String] Input data to compress
+        # @raise [NotImplementedError] Always raised in base class
+        # @return [void]
+        def encode_stream(data)
+          raise NotImplementedError,
+                "#{self.class} must implement #encode_stream"
+        end
+
+        # Get the implementation identifier.
+        #
+        # Subclasses must implement this to return a symbol identifying
+        # their implementation (e.g., :xz_utils, :seven_zip).
+        #
+        # @raise [NotImplementedError] Always raised in base class
+        # @return [Symbol] Implementation identifier
+        def implementation_name
+          raise NotImplementedError,
+                "#{self.class} must implement #implementation_name"
+        end
+
+        private
+
+        # Validate LZMA parameters.
+        #
+        # @raise [ArgumentError] If any parameter is out of valid range
+        # @return [void]
+        def validate_parameters!
+          unless @lc.between?(0, 8)
+            raise ArgumentError, "lc must be between 0 and 8, got #{@lc}"
+          end
+
+          unless @lp.between?(0, 4)
+            raise ArgumentError, "lp must be between 0 and 4, got #{@lp}"
+          end
+
+          unless @pb.between?(0, 4)
+            raise ArgumentError, "pb must be between 0 and 4, got #{@pb}"
+          end
+
+          unless @dict_size.between?(4096, 1 << 28)
+            raise ArgumentError,
+                  "dict_size must be between 4096 and 268435456, got #{@dict_size}"
+          end
+        end
+      end
+    end
+  end
+end