vcdeps 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cadbf9c576136cf47846e8c790890fd9225e01aea337edc0a83786b8aa4dfe11
+  data.tar.gz: 7e5a5401c339286ed4c03cf40536446c97ba02c1713525913bdee2e2107d29ab
+SHA512:
+  metadata.gz: a774c5f893e1b28d4e9db594b45d45fc199f8e91543fd18b05c8b23295a7a89b458347d0173adf6fd54efe8e8566a002f065fb3409433f228f044b2ebfe0c70c
+  data.tar.gz: 0ba6b42201244938ac887d4e9755f1c25d398c6d62a50fd6d28f09033565d33f581a6b6b977aa257450d17d83f4328a433c094b37e34e53c7bfc2df34521797f

data/CHANGELOG.md

@@ -0,0 +1,43 @@
+# Changelog
+
+## [0.1.0] - 2026-06-27
+
+Initial release.
+
+- `Vcdeps.tool` / `Vcdeps.tool!` — locate a usable vcpkg, validated
+  (vcpkg.exe + `.vcpkg-root`), in resolution order: explicit `VCPKG_ROOT`, the
+  VS developer-env `VCPKG_ROOT`, the VS-bundled `VC\vcpkg`, a validated
+  `VCPKG_INSTALLATION_ROOT` (GitHub Actions), then a private bootstrap. `tool!`
+  raises `Vcdeps::ToolNotFound` with three actionable remedies.
+- `Vcdeps.bootstrap!` — create a private, registration-free vcpkg under
+  `%LOCALAPPDATA%\vcdeps\vcpkg` (download `vcpkg.exe` over TLS, then
+  `bootstrap-standalone`). Idempotent; never elevates or touches the registry.
+- `Vcdeps.install!` — run `vcpkg install` for `<manifest>\vcpkg.json` into an
+  out-of-tree root keyed on (manifest, triplet, tool version), streaming child
+  output live. A `.vcdeps-complete` marker makes a current install a no-op;
+  `force:` bypasses it. Builds/caches live under `%LOCALAPPDATA%\vcdeps`, never
+  inside the gem (the deep-path port-build trap).
+- `Vcdeps.vendor!` — sync an install's runtime DLLs, per-port `copyright` files,
+  and a generated standalone `Fiddle`-preload shim into a vendor dir. SYNC, not
+  copy: it owns `*.dll`, `licenses\*`, and `preload.rb`, deleting stale owned
+  files so a removed port leaves no orphan DLL.
+- `Vcdeps.baseline!` — add/refresh `builtin-baseline` via
+  `vcpkg x-update-baseline --add-initial-baseline`.
+- `Vcdeps.mkmf!` — the extconf entry point: activate vcvars, install the ports
+  (or bypass via `--with-vcdeps-dir`), PREPEND the include/lib paths so the
+  vcpkg tree wins over Ruby's build-time opt-dir, and vendor the DLLs.
+- `Vcdeps.default_triplet` and `Vcdeps::Triplet.validate!` — derive
+  `<arch>-windows` from `RbConfig`; reject static-CRT triplets and arch
+  mismatches; `VCPKG_DEFAULT_TRIPLET` is deliberately ignored.
+- `vcdeps` CLI — `doctor`, `where`, `install`, `vendor`, `baseline`,
+  `bootstrap`, `version`, `help`.
+- `vcdeps doctor` — diagnoses resolution, manifest baseline, opt-dir shadowing,
+  Ruby-bin DLL collisions, triplet sanity, binary-cache / offline readiness, and
+  `VCDEPS_HOME` hygiene.
+
+Manifest mode only. Telemetry is disabled in every child unless
+`VCDEPS_METRICS=1`. Supported platform: native MSVC (mswin) Ruby, x64.
+arm64-mswin is expected to work (arch-neutral) but is untested and unsupported
+until an arm64-mswin Ruby distribution exists. Windows MSVC (mswin) Ruby only.
+
+[0.1.0]: https://github.com/main-path/vcdeps/releases/tag/v0.1.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ned
+
+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.

data/README.md

@@ -0,0 +1,258 @@
+# vcdeps
+
+**vcpkg-powered native dependencies for Ruby C extensions on Windows — declare ports in a manifest, get correct mkmf flags and loadable runtime DLLs, no global state.**
+
+Building a Ruby C extension against zlib, bzip2, or libxml2 on a native MSVC
+(mswin) Ruby has two classic walls. First the compiler can't find the headers:
+
+```
+fatal error C1083: Cannot open include file: 'zlib.h': No such file or directory
+```
+
+You fix that, link, build a `.so` — and then it still won't load:
+
+```
+LoadError: 126: The specified module could not be found - .../foo.so
+```
+
+because Windows resolves a `.so`'s dependent DLLs through the standard search
+order, which **never** looks in the `.so`'s own directory. vcdeps closes both
+gaps: you declare your native dependencies in a `vcpkg.json` under `ext/`, call
+`Vcdeps.mkmf!` from `extconf.rb`, and vcdeps locates (or bootstraps) vcpkg,
+installs the ports **out of tree** with the dynamic-CRT triplet that matches an
+`-MD` Ruby, prepends the include/lib paths so they win over Ruby's own opt-dir,
+and vendors the runtime DLLs with a generated `Fiddle`-preload shim so the built
+extension actually loads.
+
+It is first of its kind. rake-compiler-dock is author-side MinGW-only
+cross-compilation; rb_sys and ffi-compiler are GCC-oriented; nothing wired vcpkg
+into mkmf before. vcdeps is the companion to [vcvars](https://github.com/main-path/vcvars)
+(which loads the toolchain) the way vcpkg is the companion to MSVC.
+
+## API summary
+
+| What | API |
+|---|---|
+| extconf entry point (install + wire + vendor) | `Vcdeps.mkmf!(vendor:)` |
+| install a manifest's ports out of tree | `Vcdeps.install!(manifest:)` |
+| sync DLLs + licenses + preload shim into a gem | `Vcdeps.vendor!(installed, into:)` |
+| add/refresh `builtin-baseline` | `Vcdeps.baseline!(manifest:)` |
+| locate vcpkg (or raise with remedies) | `Vcdeps.tool` / `Vcdeps.tool!` |
+| bootstrap a private vcpkg | `Vcdeps.bootstrap!` |
+| CLI | `vcdeps doctor / where / install / vendor / baseline / bootstrap` |
+
+## Requirements
+
+- Windows with a native **MSVC (mswin)** Ruby (`RbConfig::CONFIG["target_os"]`
+  matches `/mswin/`). **Not supported on MinGW/UCRT.**
+- Visual Studio 2017+ or Build Tools with the **Desktop development with C++**
+  workload (for `cl.exe` / `nmake`).
+- A vcpkg instance. vcdeps finds one in this order: an explicit `VCPKG_ROOT`,
+  the VS-bundled vcpkg (the **vcpkg package manager** component —
+  `Microsoft.VisualStudio.Component.Vcpkg`, *Recommended* in that workload), a
+  validated `VCPKG_INSTALLATION_ROOT` (GitHub Actions), or a private instance
+  created by `vcdeps bootstrap`.
+- [vcvars](https://github.com/main-path/vcvars) — installed automatically as a
+  runtime dependency.
+
+## Install
+
+```sh
+gem install vcdeps
+```
+
+## Quick start
+
+Four files turn a C extension into a vcpkg-backed gem.
+
+```json
+// ext/foo/vcpkg.json — builtin-baseline is MANDATORY (the VS-bundled and
+// standalone vcpkg are git-registry instances; vcdeps hard-fails without it).
+// Get a SHA with: vcdeps baseline --manifest ext/foo
+{
+  "name": "foo",
+  "version": "0.1.0",
+  "dependencies": ["zlib", "bzip2"],
+  "builtin-baseline": "e5a1490e1409d175932ef6014519e9ae149ddb7c"
+}
+```
+
+```ruby
+# ext/foo/extconf.rb
+# frozen_string_literal: true
+require "mkmf"
+
+unless RbConfig::CONFIG["target_os"] =~ /mswin/
+  abort <<~MSG
+    foo requires a native Windows MSVC (mswin) Ruby — it links vcpkg-built
+    native libraries and is built with cl.exe. Your Ruby is "#{RbConfig::CONFIG['arch']}".
+  MSG
+end
+
+require "vcdeps/mkmf"
+Vcdeps.mkmf!(vendor: File.expand_path("../../lib/foo/vendor", __dir__))
+
+have_header("zlib.h")  or abort "zlib.h not found — run `vcdeps doctor`"
+have_library("zlib")   or abort "zlib.lib not found"   # bare name; LIBARG adds .lib
+have_header("bzlib.h") or abort "bzlib.h not found"
+have_library("bz2")    or abort "bz2.lib not found"    # import-lib name != port name
+create_makefile("foo/foo")
+```
+
+```ruby
+# lib/foo.rb
+# frozen_string_literal: true
+require "foo/version"
+preload = File.expand_path("foo/vendor/preload.rb", __dir__)
+require preload if File.exist?(preload)   # shim absent for static-md / no-DLL builds
+require "foo/foo"                          # the compiled extension
+```
+
+```ruby
+# Rakefile — unchanged suite shape; vcdeps needs no Rake hook (extconf does it all)
+require "vcvars/rake"        # load the MSVC build env so `rake compile` just works
+require "rake/extensiontask"
+require "rake/testtask"
+spec = Gem::Specification.load("foo.gemspec")
+Rake::ExtensionTask.new("foo", spec) { |ext| ext.lib_dir = "lib/foo" }
+Rake::TestTask.new(test: :compile) do |t|
+  t.libs << "test" << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+  t.warning = false
+end
+task default: :test
+```
+
+Then `rake compile && rake test`. End users override at install time with
+standard mkmf semantics:
+
+```sh
+gem install foo -- --with-vcdeps-triplet=x64-windows-static-md  # link static, ship no DLLs
+gem install foo -- --with-vcdeps-dir=C:\prebuilt\foo-deps       # bypass vcpkg entirely
+set VCDEPS_BOOTSTRAP=1 && gem install foo                       # consent to private bootstrap
+```
+
+## How loading works
+
+Beside-the-`.so` **does not work**: Windows resolves an extension's dependent
+DLLs as if loaded by module name only, and the search order never checks the
+`.so`'s own directory. "It worked when I ran it from that folder" is the current
+directory (search step 11) fooling you — move the cwd and it breaks. vcdeps
+generates a `preload.rb` shim that `Fiddle.dlopen`s each vendored DLL by
+**absolute path** before the extension loads, so the loaded-module list (search
+step 4, consulted before PATH) satisfies the imports. The
+`x64-windows-static-md` triplet sidesteps the whole problem by linking the
+libraries statically into the `.so` (no DLLs to vendor). One caveat: Ruby's own
+`bin` ships `zlib1.dll` / `ffi-8.dll` / `yaml.dll`; if one is already loaded
+under that name, it wins process-wide — `vcdeps doctor` and `vendor!` warn on
+base-name collisions.
+
+## Precompiled platform gems
+
+The primary audience is **gem authors and their Windows CI** shipping
+precompiled `x64-mswin64-140` gems so end users never compile. Build on Windows
+CI, run `vcdeps vendor --into lib/<gem>/vendor`, then flip
+`spec.platform = Gem::Platform.local`, drop `spec.extensions`, and include
+`lib/<gem>/vendor/**/*` (the DLLs + `preload.rb` shim) in `spec.files`. The
+source path (`gem install` → extconf → vcdeps → vcpkg) still works — it is the
+author's dev loop and the fallback for exotic setups — but a cold libxml2-class
+build at end-user install time is an accepted-but-discouraged slow path: vcdeps
+streams vcpkg output live and leans on vcpkg's binary cache, so it is slow once,
+never silent.
+
+**License note:** vendored ports' `copyright` files ship in `vendor/licenses/`
+for DLL builds **and** static-md builds (under static-md the port code is
+statically linked into the shipped `.so`, so its copyright files are still
+redistributed alongside it). Mind relink obligations for LGPL ports.
+
+## CI recipe
+
+`windows-latest`, a self-provided mswin Ruby (ruby/setup-ruby's `mswin` build is
+x64 ruby-master; there are no RubyInstaller mswin builds). Invoke vcpkg by
+explicit path, let `vcvars/rake` + vcdeps do the rest, and cache the binary
+archives:
+
+```yaml
+- uses: actions/cache@v4
+  with:
+    path: ~/AppData/Local/vcpkg/archives          # or $VCPKG_DEFAULT_BINARY_CACHE
+    key: vcpkg-${{ hashFiles('ext/**/vcpkg.json') }}-x64-windows-${{ env.VCPKG_TOOL_VERSION }}
+- run: bundle exec rake compile
+```
+
+The default `files` binary-cache provider needs no secrets and is immune to
+provider churn (the `x-gha` provider was removed upstream in June 2025 — vcdeps
+never references it). The NuGet-on-GitHub-Packages alternative is also viable;
+note that Microsoft's own docs currently contradict themselves on whether the
+workflow `GITHUB_TOKEN` (with `packages: write`) suffices or a classic PAT is
+required — try `GITHUB_TOKEN` first and fall back to a PAT if pushes return 401.
+
+## Library API
+
+```ruby
+require "vcdeps"
+
+Vcdeps.default_triplet            # => "x64-windows"  (arm64 -> "arm64-windows")
+Vcdeps.home                       # => "C:\\Users\\me\\AppData\\Local\\vcdeps"
+
+Vcdeps.tool                       # => #<struct Vcdeps::Tool ... source=:devenv> or nil
+Vcdeps.tool!                      # raises Vcdeps::ToolNotFound (with remedies) on a miss
+Vcdeps.bootstrap!                 # private vcpkg under <home>\vcpkg (consent-gated)
+
+inst = Vcdeps.install!(manifest: "ext/foo")
+inst.prefix                       # => "...\\installed\\<key>\\x64-windows"
+inst.ports                        # => [#<struct Vcdeps::Port name="zlib" version="1.3.1" ...>]
+inst.dlls                         # => ["...\\bin\\zlib1.dll", ...] (release only, never debug)
+
+Vcdeps.vendor!(inst, into: "lib/foo/vendor")  # DLLs + licenses + preload.rb (a SYNC)
+Vcdeps.install!(manifest: "ext/foo")          # 2nd call: marker hit, returns in <100 ms
+Vcdeps.baseline!(manifest: "ext/foo")         # => "9f3dca…" (writes builtin-baseline)
+```
+
+## Configuration
+
+| Env var | Effect |
+|---|---|
+| `VCDEPS_HOME` | State root (default `%LOCALAPPDATA%\vcdeps`); keep it short + ASCII. |
+| `VCDEPS_TRIPLET` | Triplet override (between `--with-vcdeps-triplet` and the derived default). |
+| `VCDEPS_BOOTSTRAP` | `=1` consents to a private bootstrap from a non-interactive `gem install`. |
+| `VCDEPS_METRICS` | `=1` re-enables vcpkg telemetry (disabled by default — a `gem install` must not phone home). |
+
+Honored vcpkg vars pass through untouched: `VCPKG_ROOT`,
+`VCPKG_DEFAULT_BINARY_CACHE`, `VCPKG_BINARY_SOURCES`, `VCPKG_DOWNLOADS`.
+**Ignored on purpose:** `VCPKG_DEFAULT_TRIPLET` — a machine-global default for
+unrelated C++ projects must never silently change a Ruby extension's ABI.
+
+## Errors
+
+```
+Vcdeps::Error                 (root; everything vcdeps raises)
+├── Vcdeps::ToolNotFound      (no usable vcpkg anywhere — message lists remedies)
+├── Vcdeps::BootstrapError    (private bootstrap failed: download / bootstrap-standalone)
+├── Vcdeps::ManifestError     (vcpkg.json missing/unparsable/missing builtin-baseline)
+├── Vcdeps::TripletError      (unknown arch, static-CRT triplet, arch mismatch)
+└── Vcdeps::InstallError      (`vcpkg install` exited nonzero; carries #command/#status/#log_tail)
+```
+
+API-misuse uses Ruby's own `ArgumentError`/`TypeError`. No error ever prints a
+multi-screen dump; `InstallError#log_tail` is capped at 4000 chars.
+
+## Limitations
+
+- **Manifest mode only** — the VS-bundled and standalone vcpkg instances have no
+  classic mode; vcdeps cannot offer one.
+- **x64 support.** arm64-mswin is expected to work (the code is arch-neutral and
+  triplets derive from `RbConfig`) but is untested and unsupported until an
+  arm64-mswin Ruby distribution exists.
+- **Cold builds are slow** — libxml2-class ports are tens of minutes the first
+  time; the binary cache amortizes it. The first use of a baseline needs network
+  for the registry git-tree fetch.
+- **DLL base-name collisions** across gems, and against Ruby's own `bin\zlib1.dll`
+  et al.: first-loaded wins. vcdeps warns; it cannot arbitrate.
+- **Ctrl-C during an install** kills `vcpkg.exe` (so its install-root lock is
+  released) but not the helper build processes it spawned (`git`/`cmake`/`ninja`/
+  `cl`); they exit on their own. Wait a moment, then rerun.
+
+## License
+
+[MIT](LICENSE.txt).

data/exe/vcdeps

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "vcdeps/cli"
+
+exit Vcdeps::CLI.start(ARGV)

data/lib/vcdeps/bootstrap.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+require "net/http"
+require "uri"
+require "vcdeps/tool"
+
+module Vcdeps
+  # Creates a private, registration-free vcpkg instance under <home>\vcpkg using
+  # the same mechanism as Microsoft's vcpkg-init (R§2.4): download vcpkg.exe from
+  # the vcpkg-tool GitHub release, then run `vcpkg.exe bootstrap-standalone` with
+  # VCPKG_ROOT=<home>\vcpkg in the child env. Never elevates, never touches the
+  # registry, never writes outside home.
+  module Bootstrap
+    module_function
+
+    OPEN_TIMEOUT = 30
+    READ_TIMEOUT = 30
+    MAX_REDIRECTS = 5
+
+    # Idempotent: an already-valid private root returns immediately. Progress
+    # lines to `out`. Raises Vcdeps::BootstrapError on any failure.
+    def run!(out: $stderr)
+      root = File.join(Vcdeps.home, "vcpkg").tr("/", "\\")
+
+      if (exe = ToolFinder.valid_root(root))
+        return ToolFinder.build_tool(exe, :private)
+      end
+
+      FileUtils.mkdir_p(root)
+      exe_path = File.join(root, "vcpkg.exe")
+
+      out&.puts("[vcdeps] downloading vcpkg.exe (~7 MB) from " \
+                "#{ToolFinder::BOOTSTRAP_URL} ...")
+      download!(ToolFinder::BOOTSTRAP_URL, exe_path)
+
+      out&.puts("[vcdeps] running `vcpkg bootstrap-standalone` in #{root} ...")
+      bootstrap_standalone!(exe_path, root, out)
+
+      resolved = ToolFinder.valid_root(root)
+      unless resolved
+        raise BootstrapError, "vcdeps: bootstrap-standalone completed but " \
+          "#{root} is not a valid vcpkg root (.vcpkg-root missing). Run " \
+          "`vcdeps doctor`."
+      end
+
+      ToolFinder.build_tool(resolved, :private)
+    end
+
+    # Net::HTTP GET to `dest`, following up to MAX_REDIRECTS redirects, with
+    # TLS and bounded timeouts. Writes atomically (temp then rename).
+    def download!(url, dest, redirects_left = MAX_REDIRECTS)
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.open_timeout = OPEN_TIMEOUT
+      http.read_timeout = READ_TIMEOUT
+
+      tmp = "#{dest}.tmp.#{Process.pid}"
+      http.start do |conn|
+        request = Net::HTTP::Get.new(uri)
+        conn.request(request) do |response|
+          case response
+          when Net::HTTPSuccess
+            File.open(tmp, "wb") do |io|
+              response.read_body { |chunk| io.write(chunk) }
+            end
+          when Net::HTTPRedirection
+            raise BootstrapError, "vcdeps: too many redirects fetching " \
+              "#{url}" if redirects_left <= 0
+
+            location = response["location"]
+            next_url = absolutize(location, uri)
+            # The bootstrap artifact is executed, so it MUST arrive over TLS
+            # end-to-end. GitHub release downloads normally redirect (to
+            # objects.githubusercontent.com); honoring a `Location: http://...`
+            # would silently drop TLS and let an on-path attacker substitute the
+            # executable. Refuse any non-HTTPS redirect target.
+            unless URI.parse(next_url).scheme == "https"
+              raise BootstrapError, "vcdeps: refusing non-HTTPS redirect to " \
+                "#{next_url} while fetching vcpkg.exe (TLS downgrade)"
+            end
+            return download!(next_url, dest, redirects_left - 1)
+          else
+            raise BootstrapError, "vcdeps: download of #{url} failed: " \
+              "#{response.code} #{response.message}"
+          end
+        end
+      end
+
+      File.rename(tmp, dest)
+    rescue BootstrapError
+      cleanup_tmp(tmp)
+      raise
+    rescue StandardError => e
+      cleanup_tmp(tmp)
+      raise BootstrapError, "vcdeps: download of #{url} failed: #{e.class}: " \
+        "#{e.message}"
+    end
+
+    def bootstrap_standalone!(exe, root, out)
+      env = { "VCPKG_ROOT" => root }
+      env["VCPKG_DISABLE_METRICS"] = "1" unless ENV["VCDEPS_METRICS"] == "1"
+
+      combined = +""
+      Open3.popen2e(env, exe, "bootstrap-standalone") do |_stdin, oe, wt|
+        pid = wt.pid
+        oe.binmode
+        begin
+          oe.each_line do |raw|
+            line = raw.dup.force_encoding("UTF-8").scrub("�")
+            combined << line
+            out&.print(line)
+          end
+          status = wt.value
+          unless status.success?
+            raise BootstrapError, "vcdeps: `vcpkg bootstrap-standalone` exited " \
+              "#{status.exitstatus}. Output tail: " \
+              "#{combined[-500..] || combined}"
+          end
+        rescue BootstrapError
+          raise
+        rescue Exception # rubocop:disable Lint/RescueException
+          # ANY abnormal unwind (Interrupt, Timeout, a raise from the out block):
+          # kill THIS child before Open3's block teardown runs `wait_thr.join`,
+          # which would otherwise BLOCK until the orphaned bootstrap child (busy
+          # downloading/extracting/cloning) exits on its own. Same discipline as
+          # Runner.run — vcpkg.exe never outlives the call (§3.2).
+          kill_and_close(pid, oe)
+          raise
+        end
+      end
+    end
+
+    # Shared abnormal-unwind teardown for the two child-spawn sites (here and
+    # Runner.run share the same shape so neither can drift): TerminateProcess the
+    # child, then close the pipe so Open3's drain returns at once.
+    def kill_and_close(pid, io)
+      begin
+        Process.kill(:KILL, pid)
+      rescue Errno::ESRCH, RangeError
+        nil
+      end
+      begin
+        io.close
+      rescue IOError
+        nil
+      end
+    end
+
+    def absolutize(location, base)
+      u = URI.parse(location)
+      u.absolute? ? location : (base + location).to_s
+    end
+
+    def cleanup_tmp(tmp)
+      File.unlink(tmp) if tmp && File.exist?(tmp)
+    rescue StandardError
+      nil
+    end
+  end
+end