hotpatchR is a runtime hotfix utility for locked R package namespaces. It is built for legacy container workflows where a package version is sealed in place and cannot be rebuilt or redeployed.
The core problem
When R loads a package, it builds a locked namespace. Internal package functions call each other inside that namespace, and the namespace acts as a protective bubble.
That means:
- a broken internal function like
broken_fun()is only visible inside the package namespace - a package function like
caller_fun()resolves internal calls from that same locked namespace - sourcing a fixed
broken_fun()into the global environment does not update the package’s internal pointer
In practice, this forces a painful current workflow:
- identify the broken function
- find every package child function that depends on it
- copy the broken function plus all dependent callers into a hotfix script
- source the hotfix script into the global environment
- run tests while fighting CI and namespace isolation
This is manual, brittle, and scales badly for large legacy packages.
What hotpatchR solves
hotpatchR changes the problem from “global environment hacking” to “namespace surgery.” Instead of copying dependencies into the global environment, it overwrites the function inside the package namespace itself.
Benefits:
- surgical patching of exactly the broken functions
- internal callers automatically see the fix
- no need to copy parent callers or entire dependency chains
- easier validation in live test workflows
Test-hotfix use case
hotpatchR is built for the common legacy scenario where a package version is fixed in place and you want to validate a runtime correction using existing package tests. With inject_patch(), you can replace a broken internal function.
A typical test-hotfix flow looks like this:
library(hotpatchR)
baseline <- dummy_parent_func("test")
print(baseline)
#> "Parent output -> I am the BROKEN child. Input: test"
inject_patch(
pkg = "hotpatchR",
patch_list = list(dummy_child_func = function(x) {
paste("I am the FIXED child! Input:", x)
})
)
patched_result <- dummy_parent_func("test")
print(patched_result)
#> "Parent output -> I am the FIXED child! Input: test"
#Eventually, you can reverse the patch to restore the original behavior if needed:
undo_patch(pkg = "hotpatchR", names = "dummy_child_func")
restored_result <- dummy_parent_func("test")
print(restored_result)
#> "Parent output -> I am the BROKEN child. Input: test"Core API
-
inject_patch(pkg, patch_list): overwrite functions inside a package namespace or environment -
undo_patch(pkg, names = NULL): restore backed-up originals for patched bindings -
test_patched_dir(pkg, test_path): runtestthattests against the modified namespace -
apply_hotfix_file(file, pkg = NULL): load a hotfix script and inject the included patch list
How it works
inject_patch() unlocks the binding inside the target namespace, assigns the replacement function, and then re-locks the binding. This keeps the change local to the package namespace and preserves normal internal function resolution.