DependencyControl

DependencyControl is a package manager for automation scripts. Scripts that use it name the modules they need, and DependencyControl downloads those modules, checks for newer versions and installs them. It reads what is available from feeds: JSON files that script authors publish, often on GitHub.

HikariSub comes with DependencyControl 0.9.1 and its DependencyControl Toolbox 0.9.0, the macros you use to manage scripts. You don't install either. The libraries its scripts use most, such as ASSFoundation, Functional and Aegisub-Motion's modules, come with HikariSub too.

DependencyControl's own messages say "Aegisub"; in HikariSub they mean HikariSub.

The Toolbox macrosCopy Anchor Link

The Toolbox is an autoload script, so its macros are always in the Automation menu. They are in its DependencyControl submenu:

They run like any macro: the progress card shows what they log, and each run is in the Automation panel's Runs. See Running scripts.

Installing a scriptCopy Anchor Link

1. Choose Automation › DependencyControl › Install Script.

2. DependencyControl fetches every feed it knows, and the card says "Scanning 21 available feeds..." or how many there are. This needs the internet and can take a minute or more.

3. A dialog lists what you can install: Automation Scripts: and Modules:, each as name and version, such as Abacus v1.1.0. A version that isn't on the feed's default channel shows its channel in brackets. Scripts you already have are not listed.

4. Pick a script, a module or one of each, and press OK.

   DependencyControl downloads the files, then the modules the script needs, and their own. The log names each one, ending with "Installation of automation script 'Abacus' (v1.1.0) complete." and "Please rescan your autoload directory for the changes to take effect."

5. Choose Automation › Refresh autoload scripts. The new macros appear in the menu.

If the only feed with the package is one DependencyControl doesn't trust, it asks first: "The installation of module '…' can only be satisfied from a feed DependencyControl doesn't trust", with the feed's address. Trust this time installs from it once, Always trust this feed remembers it, Never (block this feed) blocks it, and Cancel stops.

If a package names its own feed but only another feed has it, DependencyControl asks "… can only be satisfied from a feed other than the one it names", naming both feeds. Install from this feed goes ahead; Cancel stops.

Updating scriptsCopy Anchor Link

DependencyControl updates scripts by itself. When HikariSub starts, the Toolbox checks every module it knows, and each script that uses DependencyControl checks itself when you run one of its macros. A script is checked at most once every three and a half days (Check interval (s) in Global Configuration). While the start-up check runs, the Toolbox reads Loading in the Automation panel.

To update now, choose Automation › DependencyControl › Update Script, pick the script or module, and press OK. The log ends with "Update of module '…' (v…) complete.", or "The module '…' is up-to-date (v…)." Then choose Automation › Refresh autoload scripts, or reload the script in the Automation panel.

DependencyControl can update every script, the ones that come with HikariSub too, on every copy of HikariSub. HikariSub copies its scripts and modules into your user folder, and an update replaces the copy there. When a later HikariSub brings its own new version of a file DependencyControl updated, the updated file is kept and the Log says so. See Bundled scripts and dictionaries.

An installed package updates only from its own feed, or from the feed its copy came from. Use Package Source Configuration to change where the next update comes from.

To remove a script or module, choose DependencyControl › Uninstall Script and pick it. DependencyControl itself and the modules it needs are not offered. Choose Automation › Refresh autoload scripts afterwards.

Where its files areCopy Anchor Link

DependencyControl keeps everything in your user folder, which Help › Open user folder opens.

These are the same autoload and include folders that hold the bundled scripts and your own.

Network and certificatesCopy Anchor Link

DependencyControl downloads only over http and https.

• On Windows it uses the system's internet settings, with their proxy and certificates.
• On Linux it uses the system's libcurl, which reads the system's certificates. A proxy is set with the https_proxy and http_proxy environment variables.

Some scripts download through the DM.DownloadManager module, which comes with HikariSub. On Linux it uses the certificate file named by SSL_CERT_FILE, or else the first of these that exists:

• /etc/ssl/certs/ca-certificates.crt (Debian, Ubuntu, Arch)
• /etc/pki/tls/certs/ca-bundle.crt (Fedora, RHEL)
• /etc/ssl/ca-bundle.pem (openSUSE)
• /etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem
• /etc/ssl/cert.pem

If your system keeps its certificates elsewhere, start HikariSub with SSL_CERT_FILE set to that file.

Block private hosts, on at first, refuses downloads from your own machine and local network. Turn it off in Global Configuration to use a feed served from there.

When something goes wrongCopy Anchor Link

The run's log on the progress card, or in Runs, says what happened. Some messages:

For more detail, read the newest files in the log folder. They keep every line, including the trace lines the card leaves out.

Scripts that use DependencyControlCopy Anchor Link

A script declares itself and the modules it needs with a DependencyControl record. DependencyControl takes the script's name, version and author from its globals, and knows it by script_namespace:

script_name = "Add edgeblur"
script_description = "Adds \\be1 to the selected lines"
script_version = "1.0.0"
script_author = "you"
script_namespace = "you.AddEdgeblur"

local DependencyControl = require("l0.DependencyControl")
local depctrl = DependencyControl{
  feed = "https://example.com/you/DependencyControl.json",
  {
    "aegisub.util",
    {"a-mo.LineCollection", version = "1.3.0",
      feed = "https://raw.githubusercontent.com/TypesettingTools/Aegisub-Motion/DepCtrl/DependencyControl.json"},
  },
}
local util, LineCollection = depctrl:requireModules()

depctrl:registerMacro(function(subs, sel)
  -- ...
end)

• A required module is a name, or a table with its name, the lowest version it accepts, and the feed to fetch it from. optional = true lets the script load without it.
• requireModules returns the modules in the same order. A missing or too-old one is installed or updated first, from its feed or the script's.
• registerMacro registers the macro with the script's name and description, and checks for updates before each run.

The namespace has at least two parts joined by dots, of letters, digits, - and _. The script's version is a version number such as 1.0.0. For modules, require and the rest of the API, see Writing scripts.

Scripts written for DependencyControl 0.6 keep working. One difference: on a new profile, a script that adds an example preset only when it finds no config of its own, such as lyger's FbfTransform and GradientEverything, starts without that preset.

SettingsCopy Anchor Link

DependencyControl › Global Configuration has four groups. A field left at its default keeps following the default. Restore Defaults puts them all back, after asking; your feed lists are kept.

Each field's hint, in the strip above the buttons, says what it does.

Macro Configuration sets two things per script. Menu Group puts the script's macros in a submenu of that name in the Automation menu. Custom Update Feed makes the script update only from that feed.