omnizip 0.4.7-arm-linux

data/lib/omnizip.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+module Omnizip
+  autoload :VERSION, "omnizip/version"
+  autoload :Backends, "omnizip/backends"
+
+  autoload :Error, "omnizip/error"
+  autoload :CompressionError, "omnizip/error"
+  autoload :DecompressionError, "omnizip/error"
+  autoload :AlgorithmNotFoundError, "omnizip/error"
+  autoload :UnknownAlgorithmError, "omnizip/error"
+  autoload :UnknownChecksumError, "omnizip/error"
+  autoload :UnknownFilterError, "omnizip/error"
+  autoload :UnknownEncryptionStrategyError, "omnizip/error"
+  autoload :ConversionNotSupportedError, "omnizip/error"
+  autoload :UnsupportedFormatError, "omnizip/error"
+  autoload :FormatError, "omnizip/error"
+  autoload :InvalidArchiveError, "omnizip/error"
+  autoload :IOOperationError, "omnizip/error"
+  autoload :IOError, "omnizip/error"
+  autoload :ChecksumError, "omnizip/error"
+  autoload :OptimizationNotFoundError, "omnizip/error"
+  autoload :ProgressError, "omnizip/error"
+  autoload :ETAError, "omnizip/error"
+  autoload :NotLicensedError, "omnizip/error"
+  autoload :RarNotAvailableError, "omnizip/error"
+
+  autoload :Registry, "omnizip/registry"
+  autoload :Algorithm, "omnizip/algorithm"
+  autoload :AlgorithmRegistry, "omnizip/algorithm_registry"
+  autoload :OptimizationRegistry, "omnizip/optimization_registry"
+  autoload :ChecksumRegistry, "omnizip/checksum_registry"
+  autoload :FilterRegistry, "omnizip/filter_registry"
+
+  autoload :Filter, "omnizip/filter"
+  autoload :FilterPipeline, "omnizip/filter_pipeline"
+
+  autoload :Buffer, "omnizip/buffer"
+  autoload :Pipe, "omnizip/pipe"
+  autoload :Chunked, "omnizip/chunked"
+  autoload :Temp, "omnizip/temp"
+  autoload :FileType, "omnizip/file_type"
+  autoload :Profile, "omnizip/profile"
+  autoload :ETA, "omnizip/eta"
+  autoload :Progress, "omnizip/progress"
+  autoload :Metadata, "omnizip/metadata"
+  autoload :Entry, "omnizip/entry"
+  autoload :Converter, "omnizip/converter"
+  autoload :LinkHandler, "omnizip/link_handler"
+  autoload :Parity, "omnizip/parity"
+  autoload :Platform, "omnizip/platform"
+  autoload :Profiler, "omnizip/profiler"
+  autoload :Commands, "omnizip/commands"
+  autoload :CliOutputFormatter, "omnizip/cli/output_formatter"
+  autoload :Cli, "omnizip/cli"
+
+  # Implementation namespaces. Each namespace file declares autoloads
+  # for its concrete classes. The classes self-register with their
+  # registry on load (see lib/omnizip/algorithms/lzma.rb etc.).
+  autoload :Algorithms, "omnizip/algorithms"
+  autoload :Filters, "omnizip/filters"
+  autoload :Checksums, "omnizip/checksums"
+  autoload :IO, "omnizip/io"
+  autoload :Crypto, "omnizip/crypto"
+  autoload :Formats, "omnizip/formats"
+  autoload :Zip, "omnizip/zip"
+  autoload :Extraction, "omnizip/extraction"
+  autoload :Implementations, "omnizip/implementations"
+  autoload :ArchiveHandler, "omnizip/archive_handler"
+  autoload :ArchiveHandlers, "omnizip/archive_handlers"
+  autoload :Archive, "omnizip/archive"
+  autoload :Password, "omnizip/password"
+  # The class lives at the top level of omnizip/password.rb; without
+  # this entry, referencing it does not trigger the Password autoload
+  autoload :PasswordError, "omnizip/password"
+  autoload :Convenience, "omnizip/convenience"
+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"
+    autoload :OptimizationSuggestion, "omnizip/models/optimization_suggestion"
+    autoload :ProgressOptions, "omnizip/models/progress_options"
+    autoload :ETAResult, "omnizip/models/eta_result"
+    autoload :FilterConfig, "omnizip/models/filter_config"
+    autoload :FilterChain, "omnizip/models/filter_chain"
+    autoload :ParallelOptions, "omnizip/models/parallel_options"
+    autoload :SplitOptions, "omnizip/models/split_options"
+    autoload :ConversionOptions, "omnizip/models/conversion_options"
+    autoload :ConversionResult, "omnizip/models/conversion_result"
+    autoload :ExtractionRule, "omnizip/models/extraction_rule"
+    autoload :MatchResult, "omnizip/models/match_result"
+  end
+end
+
+module Omnizip
+  module Platform
+    autoload :NtfsStreams, "omnizip/platform/ntfs_streams"
+  end
+
+  module Implementations
+    autoload :SevenZip, "omnizip/implementations/seven_zip"
+    autoload :XZUtils, "omnizip/implementations/xz_utils"
+    autoload :Rust, "omnizip/implementations/rust"
+
+    module SevenZip
+      module LZMA
+        autoload :StateMachine,
+                 "omnizip/implementations/seven_zip/lzma/state_machine"
+        autoload :MatchFinder,
+                 "omnizip/implementations/seven_zip/lzma/match_finder"
+        autoload :Encoder, "omnizip/implementations/seven_zip/lzma/encoder"
+        autoload :Decoder, "omnizip/implementations/seven_zip/lzma/decoder"
+        autoload :RangeEncoder,
+                 "omnizip/implementations/seven_zip/lzma/range_encoder"
+        autoload :RangeDecoder,
+                 "omnizip/implementations/seven_zip/lzma/range_decoder"
+      end
+
+      module LZMA2
+        autoload :Encoder, "omnizip/implementations/seven_zip/lzma2/encoder"
+      end
+    end
+
+    module XZUtils
+      module LZMA2
+        autoload :Encoder, "omnizip/implementations/xz_utils/lzma2/encoder"
+      end
+    end
+  end
+end
+
+# Trigger autoload of Convenience so its methods are available on the
+# Omnizip module (it calls `extend Convenience` at the bottom of the
+# file). Without this, Omnizip.compress_file and friends would not be
+# defined until the first manual reference.
+Omnizip::Convenience

data/lib/tasks/msi_test_files.rake

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open-uri"
+require "digest/sha2"
+
+namespace :test_files do
+  desc "Download Adobe font pack MSI for testing (60MB)"
+  task :adobe_msi do
+    url = "https://web.archive.org/web/20200816153035/http://ardownload.adobe.com/pub/adobe/reader/win/AcrobatDC/misc/FontPack1902120058_XtdAlf_Lang_DC.msi"
+    output_dir = "spec/fixtures/adobe"
+    output_path = "#{output_dir}/FontPack1902120058_XtdAlf_Lang_DC.msi"
+    expected_sha256 = "b5b9e15791a177715fa5e93ea458f8627cada7ac3218531461cfd35cecef6c24"
+
+    FileUtils.mkdir_p(output_dir)
+
+    if File.exist?(output_path)
+      # Verify existing file
+      actual_sha256 = Digest::SHA256.file(output_path).hexdigest
+      if actual_sha256 == expected_sha256
+        puts "Adobe font pack MSI already exists and verified: #{output_path}"
+        return
+      else
+        puts "Existing file has wrong SHA256, re-downloading..."
+        File.delete(output_path)
+      end
+    end
+
+    puts "Downloading Adobe font pack MSI (60MB)..."
+    puts "URL: #{url}"
+
+    begin
+      URI.open(url, "rb") do |remote|
+        File.binwrite(output_path, remote.read)
+      end
+    rescue OpenURI::HTTPError, Net::OpenTimeout, Errno::ECONNREFUSED => e
+      puts "Failed to download: #{e.message}"
+      puts "You may need to download manually from:"
+      puts "  #{url}"
+      puts "And place it at: #{output_path}"
+      exit 1
+    end
+
+    # Verify SHA256
+    actual_sha256 = Digest::SHA256.file(output_path).hexdigest
+    if actual_sha256 == expected_sha256
+      puts "Downloaded and verified: #{output_path}"
+      puts "SHA256: #{actual_sha256}"
+    else
+      File.delete(output_path)
+      puts "SHA256 mismatch!"
+      puts "Expected: #{expected_sha256}"
+      puts "Got:      #{actual_sha256}"
+      exit 1
+    end
+  end
+
+  desc "Clean up downloaded test files"
+  task :clean do
+    adobe_dir = "spec/fixtures/adobe"
+    if File.directory?(adobe_dir)
+      FileUtils.rm_rf(adobe_dir)
+      puts "Removed: #{adobe_dir}"
+    end
+  end
+end

data/lib/tasks/platform_gems.rake

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+# Build per-platform gems that vendor a prebuilt omnizip-ffi cdylib,
+# so `gem install omnizip` gives Rust acceleration with zero
+# compilation (parsanol distribution model, adopted 2026-09-21).
+#
+#   # after downloading the release-binary artifacts:
+#   gh release download omnizip-ffi-v0.21.108 -R omnizip/omnizip-rs \
+#     -p 'libomnizip_ffi-*.tar.gz' -D artifacts
+#   bundle exec rake platform_gems:build DIR=artifacts
+#
+# Each target tarball maps to one rubygems platform; the built gems
+# land in pkg/. The plain `ruby` platform gem keeps shipping without
+# a binary (pure-Ruby core; OMNIZIP_NO_RUST=1 disables the tier).
+
+# rust target → rubygems platform (keep in sync with
+# omnizip-rs .github/workflows/release-binary.yml)
+PLATFORM_GEM_TARGETS = {
+  "x86_64-unknown-linux-gnu" => "x86_64-linux",
+  "aarch64-unknown-linux-gnu" => "aarch64-linux",
+  "arm-unknown-linux-gnueabihf" => "arm-linux",
+  "x86_64-unknown-linux-musl" => "x86_64-linux-musl",
+  "aarch64-unknown-linux-musl" => "aarch64-linux-musl",
+  "arm-unknown-linux-musleabihf" => "arm-linux-musl",
+  "aarch64-apple-darwin" => "arm64-darwin",
+  "x86_64-apple-darwin" => "x86_64-darwin",
+  "x86_64-pc-windows-msvc" => "x64-mingw-ucrt",
+  "aarch64-pc-windows-msvc" => "aarch64-mingw-ucrt",
+  "x86_64-pc-windows-gnu" => "x64-mingw32",
+}.freeze
+
+namespace :platform_gems do
+  desc "Build one platform gem: TARGET=<rust target> DYLIB=<cdylib path>"
+  task :one do
+    target = ENV.fetch("TARGET") { abort "TARGET=<rust target> required" }
+    dylib = ENV.fetch("DYLIB") { abort "DYLIB=<cdylib path> required" }
+    platform = PLATFORM_GEM_TARGETS[target] or abort "unknown target #{target} (see lib/tasks/platform_gems.rake)"
+    out = build_platform_gem(platform, dylib)
+    puts "built: #{out}"
+  end
+
+  desc "Build platform gems for every tarball in DIR=libomnizip_ffi-<target>.tar.gz"
+  task :build do
+    dir = ENV.fetch("DIR") { abort "DIR=<artifacts dir> required" }
+    # Snapshot the pristine file list once. Gem::Specification.load
+    # caches by path and returns the SAME object on every call, so a
+    # per-call load + files += would leak the previous platform's
+    # cdylib into the next gem.
+    gem_root = File.expand_path("../..", __dir__)
+    base_spec = Gem::Specification.load(File.join(gem_root, "omnizip.gemspec"))
+    abort "omnizip.gemspec failed to load" unless base_spec
+    base_files = base_spec.files.select { |rel| File.file?(File.join(gem_root, rel)) }.freeze
+
+    Dir.glob(File.join(dir, "libomnizip_ffi-*.tar.gz")).each do |tarball|
+      target = File.basename(tarball, ".tar.gz").delete_prefix("libomnizip_ffi-")
+      platform = PLATFORM_GEM_TARGETS[target] or abort "no rubygems platform mapping for #{target}"
+      require "tmpdir"
+      Dir.mktmpdir do |tmp|
+        binary = extract_binary(tarball, tmp)
+        out = build_platform_gem(platform, binary, base_files)
+        puts "built: #{out} (#{File.size(out)} bytes)"
+      end
+    end
+  end
+
+  desc "Push every already-built platform gem under pkg/ to rubygems (idempotent)"
+  task :release do
+    require "rake"
+    require "rubygems/package"
+    gem_root = File.expand_path("../..", __dir__)
+    pkg = File.join(gem_root, "pkg")
+    gems = Dir.glob(File.join(pkg, "omnizip-*.gem"))
+    abort "no platform gems under #{pkg} — run platform_gems:build first" if gems.empty?
+
+    # Pushes only what's already built in pkg/. Invoked by the
+    # platform-gem push job, which dispatches the trusted
+    # release.yml with next_version=skip + release_command override
+    # so the cimas reusable workflow authenticates via the
+    # already-trusted OIDC configuration and runs this task verbatim.
+    #
+    # Idempotent against re-push of an already-published version
+    # (cimas reusable handles "already been pushed" via the
+    # gem-idempotent-push-guard action).
+    gems.each do |path|
+      puts "pushing #{File.basename(path)}"
+      run_gem_push(path)
+    end
+  end
+
+  def extract_binary(tarball, tmp)
+    system("tar", "-xzf", tarball, "-C", tmp) or abort "tar failed for #{tarball}"
+    Dir.glob(File.join(tmp, "*")).first or abort "empty tarball #{tarball}"
+  end
+
+  def run_gem_push(path)
+    require "rubygems/command/push_command"
+    cmd = Gem::Command::PushCommand.new
+    cmd.invoke("push", path)
+  rescue StandardError => e
+    raise if !/already been pushed|Repushing of gem versions is not allowed/i.match?(e.message)
+
+    warn "skip (already published): #{File.basename(path)}"
+  end
+
+  # Stage the tracked gem files plus the vendored cdylib, flip the
+  # gemspec platform, and build. `base_files` is the pristine
+  # gemspec file list (frozen); we ASSIGN a fresh list every call
+  # rather than mutating via +=, because Gem::Specification.load
+  # hands back a cached object.
+  def build_platform_gem(platform, dylib, base_files = nil)
+    require "fileutils"
+    require "rubygems/package"
+    require "tmpdir"
+
+    gem_root = File.expand_path("../..", __dir__)
+    spec = Gem::Specification.load(File.join(gem_root, "omnizip.gemspec"))
+    abort "omnizip.gemspec failed to load" unless spec
+    base_files ||= spec.files.select { |rel| File.file?(File.join(gem_root, rel)) }
+
+    Dir.mktmpdir do |tmp|
+      stage = File.join(tmp, "stage")
+      base_files.each do |rel|
+        dst = File.join(stage, rel)
+        FileUtils.mkdir_p(File.dirname(dst))
+        FileUtils.cp(File.join(gem_root, rel), dst)
+      end
+
+      vendored = "vendor/libomnizip_ffi#{File.extname(dylib)}"
+      FileUtils.mkdir_p(File.join(stage, "vendor"))
+      FileUtils.cp(dylib, File.join(stage, vendored))
+      abort "staged cdylib missing: #{vendored}" unless File.file?(File.join(stage, vendored))
+
+      spec.platform = Gem::Platform.new(platform)
+      spec.files = base_files + [vendored]
+      spec.test_files = []
+
+      Dir.chdir(stage) do
+        Gem::Package.build(spec)
+      end
+      built = Dir.glob(File.join(stage, "omnizip-*.gem")).first or
+        abort "gem build produced nothing for #{platform}"
+      FileUtils.mkdir_p(File.join(gem_root, "pkg"))
+      FileUtils.mv(built, File.join(gem_root, "pkg", File.basename(built)))
+      File.join(gem_root, "pkg", File.basename(built))
+    end
+  end
+end

data/lib/tasks/rust_backend.rake

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# One command to build the Rust-accelerated backend's cdylib into
+# the gem's vendor dir (TODO.ref-parity/62 — the distribution
+# story). Requires git + a Rust toolchain; the gem stays fully
+# functional (pure Ruby) without ever running this.
+#
+#   bundle exec rake rust:build
+#   bundle exec rake rust:build REPO=/path/to/omnizip-rs
+desc "Build the omnizip-ffi cdylib into vendor/ for the Rust tier"
+task "rust:build" do
+  repo = ENV.fetch("REPO", nil)
+  gem_root = File.expand_path("../..", __dir__)
+  build = File.join(gem_root, "build", "rust")
+
+  require "fileutils"
+  FileUtils.mkdir_p(build)
+  src = if repo
+          File.expand_path(repo)
+        else
+          target = File.join(build, "omnizip-rs")
+          if File.directory?(File.join(target, ".git"))
+            system("git", "-C", target, "fetch", "--quiet", "origin") or abort "git fetch failed in #{target}"
+            system("git", "-C", target, "reset", "--quiet", "--hard", "origin/main") or abort "git reset failed"
+          else
+            system("git", "clone", "--quiet", "--depth", "1",
+                   "https://github.com/omnizip/omnizip-rs.git", target) or abort "clone failed"
+          end
+          target
+        end
+
+  abort "#{src} has no omnizip-ffi crate" unless File.directory?(File.join(src, "omnizip-ffi"))
+
+  system("cargo", "build", "--release", "-p", "omnizip-ffi", chdir: src) or abort "cargo build failed"
+
+  vendor = File.join(gem_root, "vendor")
+  FileUtils.mkdir_p(vendor)
+  %w[dylib so dll].each do |ext|
+    candidate = File.join(src, "target", "release", "libomnizip_ffi.#{ext}")
+    next unless File.file?(candidate)
+
+    FileUtils.cp(candidate, vendor)
+    puts "vendored: #{File.join(vendor, "libomnizip_ffi.#{ext}")}"
+    puts "tier: OMNIZIP_BACKEND=auto now uses the Rust decoders"
+    exit 0
+  end
+  abort "cdylib not found under #{src}/target/release"
+end