rpdfium-binary 0.1.7811-aarch64-mingw-ucrt

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1d4dbdfe55c151a6e663eb903713ab79d8a4ea48f452f19a4666478736d41e03
+  data.tar.gz: be07a4e449341b6024553c5a3ba4baaa43520c5054fd5c1792fdb89391328112
+SHA512:
+  metadata.gz: 02ece926ef33782f76511abad4a3e62669f0af7ce9bde0591ffb655354289fa8af6dfd93c9a88f8e139d8d207a190e4c770fabb1a69fbc8f794117255e42839a
+  data.tar.gz: 773e95e503ec67a06fb1fcf084b862f4c4969d6cae4029de8eb834ebb22fe2d7220fde20321897596ea603b85aeaf69444502527c86eb67d47570401a924652e

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Changelog
+
+## [0.1.7811] - prima release
+
+Prima release di `rpdfium-binary`. Distribuisce PDFium build chromium/7811
+da [bblanchon/pdfium-binaries](https://github.com/bblanchon/pdfium-binaries).
+
+### Aggiunto
+
+- Gemma generica `rpdfium-binary` (platform=ruby) con fallback download
+  via `Net::HTTP` stdlib alla prima `library_path`.
+- Gemme platform-specific con binario impacchettato in `vendor/lib/`:
+  - `x86_64-linux`, `aarch64-linux`
+  - `x86_64-linux-musl`, `aarch64-linux-musl`
+  - `arm64-darwin`, `x86_64-darwin`
+  - `x64-mingw-ucrt`, `x86-mingw32`, `aarch64-mingw-ucrt`
+- Modulo `Rpdfium::Binary` con:
+  - detection piattaforma (OS + CPU + libc musl/glibc)
+  - locator (`library_path`, `bundled?`)
+  - downloader con redirect HTTP, verifica SHA256, estrazione tarball
+- Rake tasks:
+  - `fetch:<platform>` / `fetch:all` — scarica i tarball upstream
+  - `package:ruby` — builda la gemma generica
+  - `package:<platform>` / `package:all` — builda le gemme platform-specific
+  - `sums` — stampa SHA256 dei .gem
+- Cache directory XDG-compliant (`~/.local/share/rpdfium/binaries/...`)
+  con override via `RPDFIUM_BINARY_CACHE` e `XDG_DATA_HOME`.
+- Test minitest per detection, locator, downloader (URL building,
+  SHA256, estrazione, path traversal).
+
+### Sicurezza
+
+- Path traversal: `extract!` ignora entry tar che contengono `..`.
+- SHA256 obbligatorio quando passato; `ChecksumError` su mismatch.
+- Solo HTTPS verso `github.com` in `Downloader.asset_url`.

data/LICENSE

@@ -0,0 +1,20 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+   Copyright 2026 The rpdfium contributors
+
+   Bundled PDFium binaries are redistributed under their upstream licenses
+   (Apache-2.0 / BSD-3-Clause). See LICENSES.* files alongside the binary.
+
+   Full license text: https://www.apache.org/licenses/LICENSE-2.0.txt

data/README.md

@@ -0,0 +1,103 @@
+# rpdfium-binary
+
+Companion gem for [`rpdfium`](https://github.com/retsef/rpdfium) that
+ships precompiled [PDFium](https://pdfium.googlesource.com/pdfium/)
+binaries for major platforms.
+
+Mirrors [pypdfium2](https://github.com/pypdfium2-team/pypdfium2)'s wheel
+approach: the platform-specific gem includes its native library
+directly, the generic Ruby-platform gem falls back to a runtime
+download from
+[bblanchon/pdfium-binaries](https://github.com/bblanchon/pdfium-binaries).
+
+## Installation
+
+```bash
+gem install rpdfium-binary
+```
+
+RubyGems will pick the right gem for your platform automatically. If
+none of the precompiled gems matches (e.g. FreeBSD, exotic libc), the
+generic Ruby-platform gem is installed instead, and the binary is
+downloaded on first use into the user data directory.
+
+```ruby
+require "rpdfium"        # or just rpdfium-binary
+puts Rpdfium::Binary.library_path
+# => "/.../rpdfium-binary-0.1.7811-x86_64-linux/vendor/lib/libpdfium.so"
+puts Rpdfium::Binary.bundled?
+# => true     (false on the runtime-download path)
+```
+
+## Supported platforms
+
+| Ruby platform tag       | bblanchon asset                  |
+|-------------------------|----------------------------------|
+| `x86_64-linux`          | `pdfium-linux-x64.tgz`           |
+| `aarch64-linux`         | `pdfium-linux-arm64.tgz`         |
+| `x86_64-linux-musl`     | `pdfium-linux-musl-x64.tgz`      |
+| `aarch64-linux-musl`    | `pdfium-linux-musl-arm64.tgz`    |
+| `arm64-darwin`          | `pdfium-mac-arm64.tgz`           |
+| `x86_64-darwin`         | `pdfium-mac-x64.tgz`             |
+| `x64-mingw-ucrt`        | `pdfium-win-x64.tgz`             |
+| `x86-mingw32`           | `pdfium-win-x86.tgz`             |
+| `aarch64-mingw-ucrt`    | `pdfium-win-arm64.tgz`           |
+
+For unsupported platforms, set `PDFIUM_LIBRARY_PATH` to the path of
+your own `libpdfium.{so,dylib,dll}`.
+
+## Configuration
+
+| Env var | Effect |
+|---|---|
+| `PDFIUM_LIBRARY_PATH` | Hard override; rpdfium loads exactly this file. |
+| `RPDFIUM_BINARY_PDFIUM_BUILD` | Override the PDFium build number to fetch (default: bundled gem version). |
+| `RPDFIUM_BINARY_CACHE` | Override the cache directory for runtime-downloaded binaries. |
+| `XDG_DATA_HOME` | Standard XDG override for the cache root. |
+
+## How it works
+
+The gemspec checks `ENV["RPDFIUM_BINARY_PLATFORM"]` at build time. The
+provided Rake tasks build:
+
+- the **generic gem** (`platform=ruby`) without bundled binary, with the
+  runtime-download fallback;
+- one **platform-specific gem** per supported target, each with its own
+  `vendor/lib/libpdfium.<ext>` packaged inside.
+
+```bash
+rake fetch:all                 # downloads all tarballs into vendor/
+rake package:all               # builds *.gem files for each platform
+rake sums                      # prints SHA256 sums for release notes
+```
+
+A maintainer's release flow looks like:
+
+```bash
+PDFIUM_BUILD=7811 rake fetch:all
+rake package:all
+rake sums          # paste into the GitHub release page
+gem push rpdfium-binary-0.1.7811-x86_64-linux.gem
+gem push rpdfium-binary-0.1.7811-arm64-darwin.gem
+# ... etc, plus the generic ruby gem
+gem push rpdfium-binary-0.1.7811.gem
+```
+
+## Memory & threading notes
+
+- The shared library is loaded **once per process** by `rpdfium`. The
+  binary file itself is just data on disk; loading it is the responsibility
+  of the FFI binding.
+- `Rpdfium::Binary.library_path` is memoized; calling it many times is
+  free.
+- Runtime downloads use `Net::HTTP` from the standard library — no
+  external runtime dependencies. SHA256 verification is supported when
+  the gem ships with a checksum DB (release-time embedded).
+
+## License
+
+This gem's Ruby code is Apache-2.0. PDFium itself is dual-licensed
+Apache-2.0 / BSD-3-Clause. Bundled binaries from
+[bblanchon/pdfium-binaries](https://github.com/bblanchon/pdfium-binaries)
+are redistributed under their respective upstream licenses, included in
+the gem under `vendor/`.

data/lib/rpdfium/binary/downloader.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "digest"
+require "zlib"
+require "rubygems/package"
+require "tmpdir"
+require "fileutils"
+
+module Rpdfium
+  module Binary
+    # Scarica e installa un asset di pdfium-binaries.
+    # Usa solo stdlib (net/http, openssl, zlib, rubygems/package).
+    # Supporta redirect HTTP, verifica SHA256 opzionale, atomicità via tmp dir.
+    module Downloader
+      module_function
+
+      RELEASE_BASE = "https://github.com/bblanchon/pdfium-binaries/releases"
+
+      # Costruisce l'URL dell'asset per una data piattaforma e build.
+      # Se build == "latest" usa l'URL "latest/download/...", altrimenti
+      # quello specifico "/download/chromium/<N>/...".
+      def asset_url(platform_key, pdfium_build)
+        asset = "pdfium-#{platform_key}.tgz"
+        if pdfium_build == "latest"
+          "#{RELEASE_BASE}/latest/download/#{asset}"
+        else
+          "#{RELEASE_BASE}/download/chromium/#{pdfium_build}/#{asset}"
+        end
+      end
+
+      # Mappa di SHA256 attesi. La gemma platform-specific include i
+      # propri SHA come parte del package_data (file YAML caricato a
+      # build time). La gemma generica può usare valori inseriti via
+      # ENV o lasciare nil (download senza verifica, sconsigliato).
+      def expected_sha256(platform_key, pdfium_build)
+        return nil unless defined?(SHA256_DB)
+
+        SHA256_DB.dig(pdfium_build, platform_key)
+      end
+
+      # SCARICA l'asset, verifica il checksum, ESTRAE solo i file utili
+      # (libpdfium*, LICENSE) in dest_dir/lib/ e dest_dir/.
+      def fetch!(url:, dest_dir:, library_name:, sha256: nil)
+        FileUtils.mkdir_p(dest_dir)
+        Dir.mktmpdir("rpdfium-binary-") do |tmp|
+          tarball = File.join(tmp, "pdfium.tgz")
+          download(url, tarball)
+          verify_sha256!(tarball, sha256) if sha256
+          extract!(tarball, tmp)
+          install_into!(tmp, dest_dir, library_name)
+        end
+      end
+
+      # ---- HTTP download con redirect ----
+
+      def download(url, dest, redirect_limit: 10)
+        raise DownloadError, "too many redirects" if redirect_limit <= 0
+
+        uri = URI.parse(url)
+        Net::HTTP.start(uri.host, uri.port,
+                        use_ssl: uri.scheme == "https",
+                        read_timeout: 120, open_timeout: 30) do |http|
+          req = Net::HTTP::Get.new(uri.request_uri)
+          req["User-Agent"] = "rpdfium-binary/#{Rpdfium::Binary::VERSION}"
+          http.request(req) do |res|
+            case res
+            when Net::HTTPSuccess
+              File.open(dest, "wb") { |f| res.read_body { |c| f.write(c) } }
+            when Net::HTTPRedirection
+              download(res["location"], dest, redirect_limit: redirect_limit - 1)
+            else
+              raise DownloadError, "HTTP #{res.code} from #{url}"
+            end
+          end
+        end
+      rescue SocketError, Errno::ECONNREFUSED, Net::OpenTimeout => e
+        raise DownloadError, "Cannot reach #{uri.host}: #{e.message}"
+      end
+
+      # ---- Verifica integrità ----
+
+      def verify_sha256!(path, expected)
+        actual = Digest::SHA256.file(path).hexdigest
+        return if actual.casecmp(expected).zero?
+
+        raise ChecksumError, "SHA256 mismatch for #{path}\n" \
+                              "  expected: #{expected}\n" \
+                              "  actual:   #{actual}"
+      end
+
+      # ---- Estrazione tarball gzip ----
+      # I tarball bblanchon hanno layout:
+      #   include/      -> headers (non ci servono)
+      #   lib/libpdfium.so | bin/pdfium.dll
+      #   args.gn, build.txt, ...
+      #   LICENSE, LICENSES.chromium.html  -> includili sempre
+      def extract!(tgz_path, dest)
+        File.open(tgz_path, "rb") do |io|
+          gz = Zlib::GzipReader.new(io)
+          Gem::Package::TarReader.new(gz).each do |entry|
+            next unless entry.file?
+
+            name = entry.full_name
+            # Bypass percorsi sospetti
+            next if name.include?("..")
+
+            # Salviamo solo:
+            #  - il binario nativo (in lib/ o bin/)
+            #  - file di licenza
+            keep = name.match?(%r{(?:^|/)lib/lib(?:pdfium)\.[^/]+$}) ||
+                   name.match?(%r{(?:^|/)bin/pdfium\.dll$}) ||
+                   name.match?(/LICENSE/i)
+            next unless keep
+
+            target = File.join(dest, name)
+            FileUtils.mkdir_p(File.dirname(target))
+            File.open(target, "wb") { |f| f.write(entry.read) }
+            # Conserva permessi eseguibili
+            File.chmod(entry.header.mode & 0o7777, target) rescue nil
+          end
+        end
+      end
+
+      # Sposta i file utili nella destinazione finale.
+      # dest_dir/<library_filename>  ← libpdfium.{so,dylib} | pdfium.dll
+      # dest_dir/LICENSE.pdfium      ← LICENSE
+      # dest_dir/LICENSES_third_party*  ← se presenti
+      def install_into!(staging, dest_dir, library_name)
+        # Cerca il binario in staging (può essere dentro lib/ o bin/)
+        candidates = Dir[File.join(staging, "**", library_name)]
+        if candidates.empty?
+          # Su macOS il file in lib/ può avere nome diverso (es. con
+          # versionamento), prova un fallback più permissivo.
+          candidates = Dir[File.join(staging, "**", "libpdfium*")] +
+                       Dir[File.join(staging, "**", "pdfium.dll")]
+        end
+        raise DownloadError, "no PDFium binary found in tarball" if candidates.empty?
+
+        chosen = candidates.first
+        FileUtils.cp(chosen, File.join(dest_dir, library_name))
+
+        # Salviamo anche le licenze
+        # Dir[File.join(staging, "**", "*LICENSE*")].each do |lic|
+        #   FileUtils.cp(lic, File.join(dest_dir, File.basename(lic)))
+        # end
+      end
+    end
+  end
+end

data/lib/rpdfium/binary/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Rpdfium
+  module Binary
+    # Schema: <gem_major>.<gem_minor>.<pdfium_build>
+    # Es. 0.1.7811 = prima minor di rpdfium-binary, basata su pdfium chromium/7811.
+    # Il PDFium build number è leggibile dal nome della release upstream
+    # (https://github.com/bblanchon/pdfium-binaries/releases).
+    VERSION = "0.1.7811"
+  end
+end

data/lib/rpdfium/binary.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require_relative "binary/version"
+require_relative "binary/downloader"
+
+module Rpdfium
+  # Companion gem distributing prebuilt PDFium binaries.
+  #
+  # In una gemma "platform-specific" (es. rpdfium-binary-0.1.7811-x86_64-linux),
+  # il binario è già impacchettato in `vendor/lib/` ed è disponibile alla
+  # prima require senza I/O di rete.
+  #
+  # La gemma "ruby" generica (platform=ruby) NON include il binario: alla
+  # prima `library_path` lo scarica da pdfium-binaries di bblanchon, lo
+  # verifica via SHA256 (se forniti) e lo cache nella user data dir
+  # (`~/.local/share/rpdfium/binaries/<version>/<platform>/`).
+  #
+  # Il path viene poi esposto a rpdfium via `Rpdfium::Binary.library_path`,
+  # che `rpdfium/raw.rb` interroga prima di tentare il caricamento di sistema.
+  module Binary
+    class Error < StandardError; end
+    class UnsupportedPlatform < Error; end
+    class DownloadError       < Error; end
+    class ChecksumError       < Error; end
+
+    # Versione di PDFium impacchettato. Estratta dal file VERSION o dalla
+    # build info se presente, fallback al numero in VERSION costante.
+    PDFIUM_BUILD = ENV.fetch("RPDFIUM_BINARY_PDFIUM_BUILD",
+                              Rpdfium::Binary::VERSION.split(".").last)
+
+    # ---- Detection piattaforma host ----
+
+    # Restituisce il "platform key" usato internamente, es. "linux-x64",
+    # "mac-arm64", "win-x64". Stesso schema dei file di bblanchon.
+    def self.platform_key
+      @platform_key ||= detect_platform_key
+    end
+
+    def self.detect_platform_key
+      cpu = host_cpu
+      case host_os
+      when :linux
+        musl = libc_is_musl? ? "musl-" : ""
+        "linux-#{musl}#{cpu}"
+      when :darwin then "mac-#{cpu}"
+      when :windows then "win-#{cpu}"
+      else
+        raise UnsupportedPlatform,
+              "Unsupported OS: #{RbConfig::CONFIG['host_os']}"
+      end
+    end
+
+    def self.host_os
+      case RbConfig::CONFIG["host_os"]
+      when /linux/  then :linux
+      when /darwin/ then :darwin
+      when /mingw|mswin|cygwin/ then :windows
+      else :unknown
+      end
+    end
+
+    def self.host_cpu
+      cpu = RbConfig::CONFIG["host_cpu"]
+      case cpu
+      when /x86_64|amd64/ then "x64"
+      when /aarch64|arm64/ then "arm64"
+      when /i[3-6]86/      then "x86"
+      when /^arm/          then "arm"
+      else
+        raise UnsupportedPlatform, "Unsupported CPU: #{cpu}"
+      end
+    end
+
+    # Detection musl libc su Linux. Su glibc questa system call fallisce
+    # silenziosamente, su Alpine restituisce un path che contiene 'musl'.
+    # Fallback: ldd --version (alpine ldd non supporta --version e va
+    # in stderr con "musl libc").
+    def self.libc_is_musl?
+      return false unless host_os == :linux
+
+      # Strategia 1: Look at ldd output
+      out = `ldd --version 2>&1`
+      return true if out.include?("musl")
+
+      # Strategia 2: ispeziona /usr/bin/ldd se è uno script
+      ldd_path = `command -v ldd 2>/dev/null`.strip
+      if !ldd_path.empty? && File.readable?(ldd_path)
+        head = File.read(ldd_path, 1024) rescue ""
+        return true if head.include?("musl")
+      end
+
+      false
+    rescue StandardError
+      false
+    end
+
+    # Nome file libreria nativa per la piattaforma corrente.
+    def self.library_filename
+      case host_os
+      when :darwin  then "libpdfium.dylib"
+      when :windows then "pdfium.dll"
+      else               "libpdfium.so"
+      end
+    end
+
+    # ---- Locator ----
+
+    # Restituisce il path assoluto al .so/.dylib/.dll di PDFium.
+    # In una gemma platform-specific lo trova subito; altrimenti scarica.
+    def self.library_path
+      return @library_path if defined?(@library_path) && @library_path
+
+      @library_path = locate_bundled || download_and_cache
+    end
+
+    # Restituisce true se il binario è già pre-impacchettato (gemma
+    # platform-specific). In quel caso non c'è I/O di rete a runtime.
+    def self.bundled?
+      !locate_bundled.nil?
+    end
+
+    # Reset (utile per test)
+    def self.reset!
+      remove_instance_variable(:@library_path) if defined?(@library_path)
+      remove_instance_variable(:@platform_key) if defined?(@platform_key)
+    end
+
+    # ---- Cerca binario impacchettato nella gemma ----
+
+    def self.locate_bundled
+      candidates = [
+        File.expand_path("../../vendor/lib/#{library_filename}", __dir__),
+        File.expand_path("../../vendor/#{platform_key}/lib/#{library_filename}", __dir__)
+      ]
+      candidates.find { |p| File.file?(p) }
+    rescue UnsupportedPlatform
+      nil
+    end
+
+    # ---- Download fallback ----
+
+    def self.cache_dir
+      base = ENV["RPDFIUM_BINARY_CACHE"] ||
+             ENV["XDG_DATA_HOME"] ||
+             File.expand_path("~/.local/share")
+      File.join(base, "rpdfium", "binaries", PDFIUM_BUILD, platform_key)
+    end
+
+    def self.download_and_cache
+      target_dir = cache_dir
+      target = File.join(target_dir, library_filename)
+      return target if File.file?(target)
+
+      require_relative "binary/downloader"
+      Downloader.fetch!(
+        url:           Downloader.asset_url(platform_key, PDFIUM_BUILD),
+        dest_dir:      target_dir,
+        library_name:  library_filename,
+        sha256:        Downloader.expected_sha256(platform_key, PDFIUM_BUILD)
+      )
+      raise DownloadError, "binary not found at #{target}" unless File.file?(target)
+
+      target
+    end
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: rpdfium-binary
+version: !ruby/object:Gem::Version
+  version: 0.1.7811
+platform: aarch64-mingw-ucrt
+authors:
+- Roberto Scinocca
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.20'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.20'
+description: |
+  Companion gem for `rpdfium` that ships precompiled PDFium shared libraries
+  (Apache-2.0/BSD-3-Clause) from bblanchon/pdfium-binaries. Mirrors the
+  pypdfium2 wheels approach: each platform-specific gem includes its native
+  library directly, while the generic Ruby-platform gem falls back to a
+  runtime download.
+email:
+- roberto.scinocca@hey.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/rpdfium/binary.rb
+- lib/rpdfium/binary/downloader.rb
+- lib/rpdfium/binary/version.rb
+- vendor/lib/pdfium.dll
+homepage: https://github.com/retsef/rpdfium
+licenses:
+- Apache-2.0
+metadata:
+  source_code_uri: https://github.com/retsef/rpdfium
+  changelog_uri: https://github.com/retsef/rpdfium/blob/main/rpdfium-binary/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+  pdfium_build: '7811'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Prebuilt PDFium binaries for the rpdfium gem
+test_files: []