omnizip 0.3.1

data/lib/omnizip/algorithms/sevenzip_lzma2.rb

@@ -0,0 +1,123 @@
+# 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.
+
+require_relative "../algorithm"
+require_relative "../models/algorithm_metadata"
+require_relative "../algorithms/lzma2/encoder"
+require_relative "../algorithms/lzma2/decoder"
+
+module Omnizip
+  module Algorithms
+    # 7-Zip LZMA2 compression algorithm.
+    #
+    # This algorithm uses the 7-Zip SDK-compatible implementation of LZMA2,
+    # which provides compatibility with 7-Zip command-line tools.
+    #
+    # @example Compress data
+    #   algorithm = Omnizip::AlgorithmRegistry.get(:sevenzip_lzma2).new(
+    #     dict_size: 8 * 1024 * 1024
+    #   )
+    #   algorithm.compress(input_io, output_io)
+    #
+    # @example Decompress data
+    #   algorithm = Omnizip::AlgorithmRegistry.get(:sevenzip_lzma2).new
+    #   algorithm.decompress(input_io, output_io)
+    class SevenZipLZMA2 < Algorithm
+      # Get algorithm metadata.
+      #
+      # @return [Models::AlgorithmMetadata] Algorithm information
+      def self.metadata
+        Models::AlgorithmMetadata.new.tap do |meta|
+          meta.name = "sevenzip_lzma2"
+          meta.description = "LZMA2 compression (7-Zip SDK implementation)"
+          meta.version = "1.0.0"
+        end
+      end
+
+      # Compress data using 7-Zip LZMA2.
+      #
+      # @param input [IO, String] Input data
+      # @param output [IO] Output stream
+      # @return [void]
+      def compress(input, output)
+        # Apply filter if set
+        input_data = if input.is_a?(String)
+                       if @filter
+                         @filter.encode(input)
+                       else
+                         input
+                       end
+                     elsif input.respond_to?(:read)
+                       data = input.read
+                       if @filter
+                         @filter.encode(data)
+                       else
+                         data
+                       end
+                     else
+                       raise ArgumentError, "Input must be a String or IO"
+                     end
+
+        # Get encoding 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)
+
+        # Use existing LZMA2Encoder which wraps SimpleLZMA2Encoder
+        encoder = LZMA2::LZMA2Encoder.new(
+          dict_size: dict_size,
+          lc: lc,
+          lp: lp,
+          pb: pb,
+          standalone: false,
+        )
+
+        compressed = encoder.encode(input_data)
+        output.write(compressed)
+      end
+
+      # Decompress data using 7-Zip LZMA2.
+      #
+      # @param input [IO] Input stream
+      # @param output [IO] Output stream
+      # @return [void]
+      def decompress(input, output)
+        dict_size = @options.fetch(:dict_size, 8 * 1024 * 1024)
+
+        # Use existing LZMA2::Decoder
+        decoder = LZMA2::Decoder.new(input, raw_mode: true, dict_size: dict_size)
+        decompressed = decoder.decode_stream
+
+        # Reverse filter if set
+        if @filter
+          decompressed = @filter.decode(decompressed)
+        end
+
+        output.write(decompressed)
+      end
+    end
+  end
+end
+
+# Register the algorithm
+Omnizip::Algorithms::SevenZipLZMA2.register_algorithm

data/lib/omnizip/algorithms/xz_lzma2.rb

@@ -0,0 +1,118 @@
+# 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.
+
+require_relative "../algorithm"
+require_relative "../models/algorithm_metadata"
+require_relative "../implementations/xz_utils/lzma2/encoder"
+require_relative "../implementations/xz_utils/lzma2/decoder"
+
+module Omnizip
+  module Algorithms
+    # XZ Utils LZMA2 compression algorithm.
+    #
+    # This algorithm uses the XZ Utils implementation of LZMA2,
+    # which provides full compatibility with xz command-line tools.
+    #
+    # @example Compress data
+    #   algorithm = Omnizip::AlgorithmRegistry.get(:xz_lzma2).new(
+    #     dict_size: 8 * 1024 * 1024
+    #   )
+    #   algorithm.compress(input_io, output_io)
+    #
+    # @example Decompress data
+    #   algorithm = Omnizip::AlgorithmRegistry.get(:xz_lzma2).new
+    #   algorithm.decompress(input_io, output_io)
+    class XZLZMA2 < Algorithm
+      # Get algorithm metadata.
+      #
+      # @return [Models::AlgorithmMetadata] Algorithm information
+      def self.metadata
+        Models::AlgorithmMetadata.new.tap do |meta|
+          meta.name = "xz_lzma2"
+          meta.description = "LZMA2 compression (XZ Utils implementation)"
+          meta.version = "1.0.0"
+        end
+      end
+
+      # Compress data using XZ Utils LZMA2.
+      #
+      # @param input [IO, String] Input data
+      # @param output [IO] Output stream
+      # @return [void]
+      def compress(input, output)
+        input_data = if input.is_a?(String)
+                       input
+                     elsif input.respond_to?(:read)
+                       input.read
+                     else
+                       raise ArgumentError, "Input must be a String or IO"
+                     end
+
+        # Apply filter if set
+        if @filter
+          input_data = @filter.encode(input_data)
+        end
+
+        # Get encoding 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, false)
+
+        # Create encoder and compress
+        encoder = Implementations::XZUtils::LZMA2::Encoder.new(
+          dict_size: dict_size,
+          lc: lc,
+          lp: lp,
+          pb: pb,
+          standalone: standalone,
+        )
+
+        compressed = encoder.encode(input_data)
+        output.write(compressed)
+      end
+
+      # Decompress data using XZ Utils LZMA2.
+      #
+      # @param input [IO] Input stream
+      # @param output [IO] Output stream
+      # @return [void]
+      def decompress(input, output)
+        dict_size = @options.fetch(:dict_size, 8 * 1024 * 1024)
+
+        decoder = Implementations::XZUtils::LZMA2::Decoder.new(input, raw_mode: true, dict_size: dict_size)
+        decompressed = decoder.decode_stream
+
+        # Reverse filter if set
+        if @filter
+          decompressed = @filter.decode(decompressed)
+        end
+
+        output.write(decompressed)
+      end
+    end
+  end
+end
+
+# Register the algorithm
+Omnizip::Algorithms::XZLZMA2.register_algorithm

data/lib/omnizip/algorithms/zstandard/constants.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Algorithms
+    class Zstandard
+      # Constants for Zstandard algorithm
+      module Constants
+        # Compression levels (Zstd supports 1-22)
+        MIN_LEVEL = 1
+        MAX_LEVEL = 22
+        DEFAULT_LEVEL = 3
+
+        # Fast compression levels
+        FAST_LEVEL = 1
+        BALANCED_LEVEL = 3
+
+        # Maximum compression level
+        ULTRA_LEVEL = 22
+
+        # Buffer size for streaming operations
+        BUFFER_SIZE = 128 * 1024 # 128KB
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/zstandard/decoder.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+begin
+  require "zstd-ruby"
+rescue LoadError
+  # Zstd gem not available - provide helpful error message
+  module Zstd
+    def self.decompress(*)
+      raise LoadError, "Zstandard support requires the 'zstd-ruby' gem. " \
+                       "Install it with: gem install zstd-ruby"
+    end
+  end
+end
+
+module Omnizip
+  module Algorithms
+    class Zstandard
+      # Zstandard decoder using zstd-ruby gem
+      #
+      # This class wraps the zstd-ruby gem to provide Zstandard
+      # decompression following the established Omnizip architecture.
+      class Decoder
+        include Constants
+
+        attr_reader :input_stream
+
+        # Initialize decoder
+        #
+        # @param input_stream [IO] Input stream of compressed data
+        def initialize(input_stream)
+          @input_stream = input_stream
+        end
+
+        # Decode compressed data stream
+        #
+        # @return [String] Decompressed data
+        def decode_stream
+          compressed = @input_stream.read
+          Zstd.decompress(compressed)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+begin
+  require "zstd-ruby"
+rescue LoadError
+  # Zstd gem not available - provide helpful error message
+  module Zstd
+    def self.compress(*)
+      raise LoadError, "Zstandard support requires the 'zstd-ruby' gem. " \
+                       "Install it with: gem install zstd-ruby"
+    end
+  end
+end
+
+module Omnizip
+  module Algorithms
+    class Zstandard
+      # Zstandard encoder using zstd-ruby gem
+      #
+      # This class wraps the zstd-ruby gem to provide Zstandard
+      # compression following the established Omnizip architecture.
+      class Encoder
+        include Constants
+
+        attr_reader :output_stream, :options
+
+        # Initialize encoder
+        #
+        # @param output_stream [IO] Output stream for compressed data
+        # @param options [Hash] Encoder options
+        # @option options [Integer] :level Compression level (1-22)
+        def initialize(output_stream, options = {})
+          @output_stream = output_stream
+          @options = options
+          @level = options[:level] || DEFAULT_LEVEL
+        end
+
+        # Encode data stream
+        #
+        # @param data [String] Data to compress
+        # @return [void]
+        def encode_stream(data)
+          compressed = Zstd.compress(data, @level)
+          @output_stream.write(compressed)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/zstandard.rb

@@ -0,0 +1,138 @@
+# 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.
+
+require_relative "../algorithm"
+require_relative "../models/algorithm_metadata"
+
+module Omnizip
+  module Algorithms
+    # Zstandard compression algorithm
+    #
+    # Zstandard (or Zstd) is a fast lossless compression algorithm developed
+    # by Facebook (now Meta). It provides:
+    # - Excellent compression ratios comparable to zlib/deflate
+    # - Very fast compression and decompression speeds
+    # - Wide range of compression levels (1-22)
+    # - Dictionary support for small data compression
+    # - Streaming and frame modes
+    #
+    # This implementation uses the zstd-ruby gem which provides Ruby bindings
+    # to the official Zstandard C library. This ensures compatibility with
+    # the reference implementation and excellent performance.
+    #
+    # Zstandard is particularly effective for:
+    # - Real-time compression needs
+    # - Network protocol compression
+    # - Database compression
+    # - Log file compression
+    # - General-purpose compression with speed priority
+    class Zstandard < Algorithm
+      # Get algorithm metadata
+      #
+      # @return [AlgorithmMetadata] Algorithm information
+      def self.metadata
+        Models::AlgorithmMetadata.new.tap do |meta|
+          meta.name = "zstandard"
+          meta.description = "Zstandard fast compression with " \
+                             "excellent ratios"
+          meta.version = "1.0.0"
+        end
+      end
+
+      # Compress data using Zstandard algorithm
+      #
+      # @param input_stream [IO] Input stream to compress
+      # @param output_stream [IO] Output stream for compressed data
+      # @param options [Models::CompressionOptions] Compression options
+      # @return [void]
+      def compress(input_stream, output_stream, options = nil)
+        input_data = input_stream.read
+        encoder = Encoder.new(output_stream, build_encoder_options(options))
+        encoder.encode_stream(input_data)
+      end
+
+      # Decompress Zstandard-compressed data
+      #
+      # @param input_stream [IO] Input stream of compressed data
+      # @param output_stream [IO] Output stream for decompressed data
+      # @param options [Models::CompressionOptions] Decompression options
+      # @return [void]
+      def decompress(input_stream, output_stream, _options = nil)
+        if output_stream.respond_to?(:set_encoding)
+          output_stream.set_encoding(Encoding::BINARY)
+        end
+        decoder = Decoder.new(input_stream)
+        decompressed = decoder.decode_stream
+        output_stream.write(decompressed)
+      end
+
+      private
+
+      # Build encoder options from compression options
+      #
+      # @param options [Models::CompressionOptions, nil] Compression opts
+      # @return [Hash] Encoder options
+      def build_encoder_options(options)
+        return {} if options.nil?
+
+        opts = {}
+
+        if options.respond_to?(:level)
+          opts[:level] = map_compression_level(options.level)
+        end
+
+        opts
+      end
+
+      # Map generic compression level (0-9) to Zstd level (1-22)
+      #
+      # @param level [Integer] Compression level (0-9)
+      # @return [Integer] Zstd compression level (1-22)
+      def map_compression_level(level)
+        return 3 if level.nil? # Zstd default
+
+        case level
+        when 0 then 1      # Fastest
+        when 1 then 2
+        when 2 then 3
+        when 3 then 5
+        when 4 then 7
+        when 5 then 10
+        when 6 then 13
+        when 7 then 16
+        when 8 then 19
+        when 9 then 22     # Maximum
+        else level
+        end
+      end
+    end
+  end
+end
+
+# Load nested classes after Zstandard class is defined
+require_relative "zstandard/constants"
+require_relative "zstandard/encoder"
+require_relative "zstandard/decoder"
+
+# Register the Zstandard algorithm
+Omnizip::AlgorithmRegistry.register(:zstandard,
+                                    Omnizip::Algorithms::Zstandard)