wheneverd 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9af22418de7ea3db50ee8a05d5614f172154a7d6b1b750017594b6202aa5298
-  data.tar.gz: 77c113c6dc437c94f59ef019cd0c274ecd94c9af2463fcfea712bbd87b109387
+  metadata.gz: 7ef1858fab03a38b36da00bf0093d4025762263ca868d05a78c1876d8aeb6441
+  data.tar.gz: 539fbeec1db7023059767501172d7337da50a966e0727c29879f88cd81770303
 SHA512:
-  metadata.gz: 2f27bd8f52c7d9e111d8b3cdcb1170b1f584f30db2e601c3938b67db29d2d1ca433e419c3020dbe01636e7e62d1798a987173deb7d1d8c3f14be91f5abf0f203
-  data.tar.gz: 6cbacc2cc72b97b1dee8dd196c1bb332c47c8a0da0cd9e01473abf8cb799b96a6a9d2c3484d7294ae5b70fc392a6287c1ba55a6ad364547ce59387d7224c82a1
+  metadata.gz: 2656962166f254b2d48f94d23329db78a16964eda9c164457c5586b4dabfa095077b75372b94da9f9cad38862d5548be15ba7b2567cef5d2fb2cdc3cb94d4984
+  data.tar.gz: a06b649a079b18fd3f321bc818e322d3284c98d96bfbabaf43244b4d604193b395186d31548efdf2296fe12509f47e665f1cdf96f47e2af25512b3eae53ba20d

data/CHANGELOG.md

@@ -5,7 +5,13 @@ On release, entries are moved into `## x.y.z` sections that match the gem versio
 
 ## Unreleased
 
-- No changes yet.
+## 0.2.1
+
+- Removes an unused filtering metadata keyword argument from the schedule DSL.
+
+## 0.2.0
+
+- Adds `wheneverd linger enable|disable|status` for managing systemd user lingering via `loginctl`.
 
 ## 0.1.0
 

data/FEATURE_SUMMARY.md

@@ -12,19 +12,21 @@ It complements [`CHANGELOG.md`](CHANGELOG.md) by staying high-level and focusing
 
 ## Unreleased
 
-- No changes yet.
+## 0.2.1
 
-## 0.1.0
+- Adds `wheneverd linger enable|disable|status` for managing systemd user lingering via `loginctl`.
+- Removes an unused filtering metadata keyword argument from the schedule DSL.
+
+## 0.2.0
 
 - The `wheneverd` CLI is implemented using Clamp (`--help`, usage errors in `ERROR: ...` format, `--verbose` for details).
 - The gem includes a small “whenever-like” domain model (interval parsing, durations, triggers, schedules).
 - The gem can load a Ruby schedule DSL file via `Wheneverd::DSL::Loader.load_file`.
-- Schedule DSL supports `every(period, at: ..., roles: ...) { command("...") }` entries (multiple `command` calls per entry).
+- Schedule DSL supports `every(period, at: ...) { command("...") }` entries (multiple `command` calls per entry).
 - Schedule DSL supports multiple calendar period symbols per `every` block (e.g. `every :tuesday, :wednesday`).
 - Supported `every` periods include interval strings/durations, calendar shortcuts (`:hour`, `:day`, `:month`, `:year`),
   day selectors (`:monday..:sunday`, `:weekday`, `:weekend`), and standard 5-field cron strings.
 - `at:` supports a string or an array of strings (for calendar schedules), like `"4:30 am"` or `"00:15"`.
-- `roles:` is accepted and stored on entries, but is not used for filtering yet.
 - The gem can render systemd `.service` and `.timer` units via `Wheneverd::Systemd::Renderer.render`.
 - Generated unit basenames include a stable ID derived from the job’s trigger + command (reordering schedule blocks won’t rename units).
 - Interval timers include both `OnActiveSec=` and `OnUnitActiveSec=` to ensure a newly started timer has a next run scheduled.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    wheneverd (0.1.0)
+    wheneverd (0.2.0)
       clamp (~> 1.3)
 
 GEM
@@ -122,7 +122,7 @@ CHECKSUMS
   tsort (0.2.0) sha256=9650a793f6859a43b6641671278f79cfead60ac714148aabe4e3f0060480089f
   unicode-display_width (3.2.0) sha256=0cdd96b5681a5949cdbc2c55e7b420facae74c4aaf9a9815eee1087cb1853c42
   unicode-emoji (4.2.0) sha256=519e69150f75652e40bf736106cfbc8f0f73aa3fb6a65afe62fefa7f80b0f80f
-  wheneverd (0.1.0)
+  wheneverd (0.2.0)
   yard (0.9.38) sha256=721fb82afb10532aa49860655f6cc2eaa7130889df291b052e1e6b268283010f
 
 BUNDLED WITH

data/README.md

@@ -2,15 +2,17 @@
 
 Wheneverd is to systemd timers what the [`whenever` gem](https://github.com/javan/whenever) is to cron.
 
-Tagline / repo: `git@github.com:bigcurl/wheneverd.git`
-
 ## Status
 
-Working end-to-end: schedule DSL loading, systemd unit rendering, and safe unit write/list/delete are implemented, along with a CLI for `init`, `show`, `write`, `delete`, `activate`, `deactivate`, `reload`, and `current`.
+Pre-1.0, but working end-to-end for user systemd timers:
 
-Known limitations: `roles:` is accepted but not used for filtering yet.
+- Loads a Ruby schedule DSL file (default: `config/schedule.rb`).
+- Renders systemd `.service`/`.timer` units (interval, calendar, and 5-field cron schedules).
+- Writes, lists, and deletes generated unit files (default: `~/.config/systemd/user`).
+- Enables/starts/stops/disables/restarts timers via `systemctl --user`.
+- Manages lingering via `loginctl` (so timers can run while logged out).
 
-See `FEATURE_SUMMARY.md` for high-level user-visible behavior, and `CHANGELOG.md` for release notes.
+See `FEATURE_SUMMARY.md` for user-visible behavior, and `CHANGELOG.md` for release notes.
 
 ## Installation
 
@@ -38,6 +40,7 @@ wheneverd activate
 wheneverd deactivate
 wheneverd reload
 wheneverd current
+wheneverd linger
 ```
 
 ### Minimal `config/schedule.rb` example
@@ -81,6 +84,35 @@ After changing your schedule, rewrite units and restart the timer(s) to pick up
 wheneverd reload
 ```
 
+### User timers and lingering (`loginctl enable-linger`)
+
+By default, `wheneverd` uses *user* systemd units (`systemctl --user`). On many systems, the per-user systemd instance
+only runs while you are logged in. If you want timers to run after logout (or on boot without an interactive login),
+enable lingering for your user:
+
+```bash
+wheneverd linger enable
+```
+
+This runs `loginctl enable-linger "$USER"` under the hood. If you see “Access denied”, your system may require admin
+privileges (polkit policy); try:
+
+```bash
+sudo loginctl enable-linger "$USER"
+```
+
+Check whether lingering is enabled:
+
+```bash
+wheneverd linger status
+```
+
+To disable it later:
+
+```bash
+wheneverd linger disable
+```
+
 ## Syntax
 
 Schedules are defined in a Ruby file (default: `config/schedule.rb`) and evaluated in a dedicated DSL context.
@@ -90,7 +122,7 @@ Note: schedule files are executed as Ruby. Do not run untrusted schedule code.
 The core shape is:
 
 ```ruby
-every(period, at: nil, roles: nil) do
+every(period, at: nil) do
   command "echo hello"
 end
 ```
@@ -155,10 +187,6 @@ Cron translation supports standard 5-field crontab strings (`minute hour day-of-
 
 Unsupported cron patterns raise an error at render time (e.g. non-5-field strings, `@daily`, `L`, `W`, `#`, `?`).
 
-### `roles:`
-
-`roles:` is accepted and stored on entries, but is ignored in v1 (no role-based filtering yet).
-
 ## CLI
 
 Defaults:
@@ -174,22 +202,28 @@ Notes:
 - Identifiers are sanitized for use in unit file names (non-alphanumeric characters become `-`).
 - Unit basenames include a stable ID derived from the job’s trigger + command (reordering schedule blocks won’t rename units).
 - `wheneverd write` / `wheneverd reload` prune previously generated units for the identifier by default (use `--no-prune` to keep old units around).
+- `--unit-dir` controls where unit files are written/read/deleted; `activate`/`deactivate` use systemd’s unit search path.
 
 Commands:
 
 - `wheneverd init [--schedule PATH] [--force]` writes a template schedule file.
 - `wheneverd show [--schedule PATH] [--identifier NAME]` prints rendered units to stdout.
-- `wheneverd write [--dry-run] [--unit-dir PATH] [--[no-]prune]` writes units to disk (or prints paths in `--dry-run` mode).
-- `wheneverd delete [--dry-run] [--unit-dir PATH]` deletes previously generated units for the identifier.
+- `wheneverd write [--schedule PATH] [--identifier NAME] [--unit-dir PATH] [--dry-run] [--[no-]prune]` writes units to disk (or prints paths in `--dry-run` mode).
+- `wheneverd delete [--identifier NAME] [--unit-dir PATH] [--dry-run]` deletes previously generated units for the identifier.
 - `wheneverd activate [--schedule PATH] [--identifier NAME]` runs `systemctl --user daemon-reload` and enables/starts the timers.
 - `wheneverd deactivate [--schedule PATH] [--identifier NAME]` stops and disables the timers.
 - `wheneverd reload [--schedule PATH] [--identifier NAME] [--unit-dir PATH] [--[no-]prune]` writes units, reloads systemd, and restarts timers.
 - `wheneverd current [--identifier NAME] [--unit-dir PATH]` prints the currently installed unit file contents from disk.
+- `wheneverd linger [--user NAME] [enable|disable|status]` manages lingering via `loginctl` (`status` is the default).
 
 ## Development
 
 ```bash
 bundle install
+
+# Run the CLI from this repo:
+bundle exec exe/wheneverd --help
+
 bundle exec rake test
 bundle exec rake ci
 bundle exec rake yard

data/exe/wheneverd

@@ -1,9 +1,24 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+begin
+  require "bundler/setup"
+rescue LoadError
+  # Allow running without Bundler (e.g., when installed as a gem).
+end
+
 lib = File.expand_path("../lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
-require "wheneverd/cli"
+begin
+  require "wheneverd/cli"
+rescue LoadError => e
+  if e.message.include?("clamp")
+    warn "ERROR: missing gem dependency `clamp`."
+    warn "Run `bundle install` and then `bundle exec exe/wheneverd ...`."
+    exit 1
+  end
+  raise
+end
 
 exit(Wheneverd::CLI.run || 0)

data/lib/wheneverd/cli/linger.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Wheneverd
+  # Implements `wheneverd linger` (manage systemd user lingering via `loginctl`).
+  class CLI::Linger < CLI
+    option "--user", "NAME", "Username to manage (default: $USER)"
+
+    private
+
+    def username_value
+      name = user.to_s.strip
+      name = ENV.fetch("USER", "").strip if name.empty?
+      raise ArgumentError, "Could not determine username; pass --user NAME" if name.empty?
+
+      name
+    end
+  end
+end
+
+module Wheneverd
+  class CLI::Linger::Enable < CLI::Linger
+    def execute
+      name = username_value
+      Wheneverd::Systemd::Loginctl.enable_linger(name)
+      puts "Enabled lingering for #{name}"
+      0
+    rescue StandardError => e
+      handle_error(e)
+    end
+  end
+end
+
+module Wheneverd
+  class CLI::Linger::Disable < CLI::Linger
+    def execute
+      name = username_value
+      Wheneverd::Systemd::Loginctl.disable_linger(name)
+      puts "Disabled lingering for #{name}"
+      0
+    rescue StandardError => e
+      handle_error(e)
+    end
+  end
+end
+
+module Wheneverd
+  class CLI::Linger::Status < CLI::Linger
+    def execute
+      name = username_value
+      stdout, _stderr = Wheneverd::Systemd::Loginctl.show_linger(name)
+      puts stdout.strip unless stdout.to_s.strip.empty?
+      0
+    rescue StandardError => e
+      handle_error(e)
+    end
+  end
+end
+
+module Wheneverd
+  class CLI::Linger
+    self.default_subcommand = "status"
+
+    subcommand "enable", "Enable lingering via loginctl", Wheneverd::CLI::Linger::Enable
+    subcommand "disable", "Disable lingering via loginctl", Wheneverd::CLI::Linger::Disable
+    subcommand "status", "Show lingering status via loginctl", Wheneverd::CLI::Linger::Status
+  end
+end

data/lib/wheneverd/cli.rb

@@ -69,6 +69,7 @@ require_relative "cli/activate"
 require_relative "cli/deactivate"
 require_relative "cli/reload"
 require_relative "cli/current"
+require_relative "cli/linger"
 
 module Wheneverd
   class CLI
@@ -83,5 +84,6 @@ module Wheneverd
     subcommand "deactivate", "Stop and disable timers via systemctl --user", Wheneverd::CLI::Deactivate
     subcommand "reload", "Write units, reload daemon, restart timers", Wheneverd::CLI::Reload
     subcommand "current", "Show installed units from disk", Wheneverd::CLI::Current
+    subcommand "linger", "Manage systemd user lingering via loginctl", Wheneverd::CLI::Linger
   end
 end

data/lib/wheneverd/dsl/context.rb

@@ -25,16 +25,15 @@ module Wheneverd
       #
       # @param periods [Array<String, Symbol, Wheneverd::Duration, Array<Symbol>>]
       # @param at [String, Array<String>, nil]
-      # @param roles [Object] stored but currently not used for filtering
       # @return [Wheneverd::Entry]
-      def every(*periods, at: nil, roles: nil, &block)
+      def every(*periods, at: nil, &block)
         raise InvalidPeriodError.new("every() requires a block", path: path) unless block
 
         raise InvalidPeriodError.new("every() requires a period", path: path) if periods.empty?
 
         period = periods.length == 1 ? periods.first : periods
         trigger = @period_parser.trigger_for(period, at: at)
-        entry = Wheneverd::Entry.new(trigger: trigger, roles: roles)
+        entry = Wheneverd::Entry.new(trigger: trigger)
 
         schedule.add_entry(entry)
 

data/lib/wheneverd/entry.rb

@@ -6,17 +6,15 @@ module Wheneverd
   # An entry ties together a trigger (when to run) and one or more jobs (what to run).
   class Entry
     # @return [Wheneverd::Trigger::Interval, Wheneverd::Trigger::Calendar, Wheneverd::Trigger::Boot]
-    attr_reader :trigger, :jobs, :roles
+    attr_reader :trigger, :jobs
 
     # @param trigger [Object] a trigger object describing when to run
     # @param jobs [Array<Object>] job objects (usually {Wheneverd::Job::Command})
-    # @param roles [Object] stored but currently not used for filtering
-    def initialize(trigger:, jobs: [], roles: nil)
+    def initialize(trigger:, jobs: [])
       raise ArgumentError, "trigger is required" if trigger.nil?
 
       @trigger = trigger
       @jobs = jobs.dup
-      @roles = roles
     end
 
     # Append a job to the entry.

data/lib/wheneverd/systemd/errors.rb

@@ -19,5 +19,8 @@ module Wheneverd
 
     # Raised when a `systemctl` invocation fails.
     class SystemctlError < Error; end
+
+    # Raised when a `loginctl` invocation fails.
+    class LoginctlError < Error; end
   end
 end

data/lib/wheneverd/systemd/loginctl.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Wheneverd
+  module Systemd
+    # Thin wrapper around `loginctl` that raises on non-zero exit status.
+    class Loginctl
+      # Run `loginctl` and return stdout/stderr.
+      #
+      # @param args [Array<String>]
+      # @return [Array(String, String)] stdout and stderr
+      # @raise [Wheneverd::Systemd::LoginctlError]
+      def self.run(*args)
+        cmd = ["loginctl", "--no-pager"]
+        cmd.concat(args.flatten.map(&:to_s))
+
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise LoginctlError, format_error(cmd, status, stdout, stderr) unless status.success?
+
+        [stdout, stderr]
+      end
+
+      # Enable lingering for a user (so their `systemctl --user` instance can run while logged out).
+      #
+      # @param username [String]
+      # @return [Array(String, String)] stdout and stderr
+      def self.enable_linger(username)
+        run("enable-linger", username)
+      end
+
+      # Disable lingering for a user.
+      #
+      # @param username [String]
+      # @return [Array(String, String)] stdout and stderr
+      def self.disable_linger(username)
+        run("disable-linger", username)
+      end
+
+      # Show lingering state for a user (includes a `Linger=` line).
+      #
+      # @param username [String]
+      # @return [Array(String, String)] stdout and stderr
+      def self.show_linger(username)
+        run("show-user", username, "-p", "Linger")
+      end
+
+      def self.format_error(cmd, status, stdout, stderr)
+        details = []
+        details << "command: #{cmd.join(' ')}"
+        details << "status: #{status.exitstatus}"
+        details << "stdout: #{stdout.strip}" unless stdout.to_s.strip.empty?
+        details << "stderr: #{stderr.strip}" unless stderr.to_s.strip.empty?
+        "loginctl failed (#{details.join(', ')})"
+      end
+      private_class_method :format_error
+    end
+  end
+end

data/lib/wheneverd/systemd/renderer.rb

@@ -80,12 +80,10 @@ module Wheneverd
       private_class_method :build_service_unit
 
       def self.build_timer_unit(path_basename, trigger)
-        timer_lines = timer_lines_for(trigger)
-
         Unit.new(
           path_basename: path_basename,
           kind: :timer,
-          contents: timer_contents(path_basename, timer_lines)
+          contents: timer_contents(path_basename, timer_lines_for(trigger))
         )
       end
       private_class_method :build_timer_unit

data/lib/wheneverd/version.rb

@@ -2,5 +2,5 @@
 
 module Wheneverd
   # Gem version.
-  VERSION = "0.1.0"
+  VERSION = "0.2.1"
 end

data/lib/wheneverd.rb

@@ -36,6 +36,7 @@ require_relative "wheneverd/systemd/calendar_spec"
 require_relative "wheneverd/systemd/unit_namer"
 require_relative "wheneverd/systemd/renderer"
 require_relative "wheneverd/systemd/systemctl"
+require_relative "wheneverd/systemd/loginctl"
 require_relative "wheneverd/systemd/unit_writer"
 require_relative "wheneverd/systemd/unit_deleter"
 require_relative "wheneverd/systemd/unit_lister"

data/test/cli_linger_test.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require_relative "support/cli_test_helpers"
+
+class CLILingerEnableTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_exits_zero
+    with_project_dir do
+      status, _out, err, _calls = run_cli_with_capture3_stub(["linger", "enable", "--user", "demo"])
+      assert_cli_success(status, err)
+    end
+  end
+
+  def test_calls_loginctl_enable_linger
+    with_project_dir do
+      status, _out, err, calls = run_cli_with_capture3_stub(["linger", "enable", "--user", "demo"])
+      assert_cli_success(status, err)
+      args, kwargs = calls.fetch(0)
+      assert_equal ["loginctl", "--no-pager", "enable-linger", "demo"], args
+      assert_equal({}, kwargs)
+    end
+  end
+
+  def test_prints_confirmation
+    with_project_dir do
+      status, out, err, _calls = run_cli_with_capture3_stub(["linger", "enable", "--user", "demo"])
+      assert_cli_success(status, err)
+      assert_includes out, "Enabled lingering for demo"
+    end
+  end
+end
+
+class CLILingerDisableTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_calls_loginctl_disable_linger
+    with_project_dir do
+      status, _out, err, calls = run_cli_with_capture3_stub(["linger", "disable", "--user", "demo"])
+      assert_cli_success(status, err)
+      args, _kwargs = calls.fetch(0)
+      assert_equal ["loginctl", "--no-pager", "disable-linger", "demo"], args
+    end
+  end
+end
+
+class CLILingerStatusTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_is_default_subcommand
+    with_project_dir do
+      status, _out, err, calls = run_cli_with_capture3_stub(["linger", "--user", "demo"],
+                                                            stdout: "Linger=yes\n")
+      assert_cli_success(status, err)
+      args, _kwargs = calls.fetch(0)
+      assert_equal ["loginctl", "--no-pager", "show-user", "demo", "-p", "Linger"], args
+    end
+  end
+
+  def test_prints_linger_property_line
+    with_project_dir do
+      status, out, err, _calls = run_cli_with_capture3_stub(
+        ["linger", "status", "--user", "demo"],
+        stdout: "Linger=yes\n"
+      )
+      assert_cli_success(status, err)
+      assert_equal "Linger=yes\n", out
+    end
+  end
+end
+
+class CLILingerFailureTest < Minitest::Test
+  include CLITestHelpers
+
+  def test_exits_one_on_access_denied
+    with_project_dir do
+      status, _out, _err, _calls = run_cli_with_capture3_stub(
+        ["linger", "enable", "--user", "demo"],
+        exitstatus: 1,
+        stderr: "Access denied\n"
+      )
+      assert_equal 1, status
+    end
+  end
+
+  def test_prints_loginctl_failed_message
+    with_project_dir do
+      _status, out, err, _calls = run_cli_with_capture3_stub(
+        ["linger", "enable", "--user", "demo"],
+        exitstatus: 1,
+        stderr: "Access denied\n"
+      )
+      assert_equal "", out
+      assert_includes err, "loginctl failed"
+      assert_includes err, "Access denied"
+    end
+  end
+
+  def test_disable_failure_uses_handle_error
+    with_project_dir do
+      status, out, err, _calls = run_cli_with_capture3_stub(
+        ["linger", "disable", "--user", "demo"],
+        exitstatus: 1,
+        stderr: "Access denied\n"
+      )
+      assert_equal 1, status
+      assert_equal "", out
+      assert_includes err, "loginctl failed"
+    end
+  end
+
+  def test_status_failure_uses_handle_error
+    with_project_dir do
+      status, out, err, _calls = run_cli_with_capture3_stub(
+        ["linger", "status", "--user", "demo"],
+        exitstatus: 1,
+        stderr: "Access denied\n"
+      )
+      assert_equal 1, status
+      assert_equal "", out
+      assert_includes err, "loginctl failed"
+    end
+  end
+end

data/wheneverd.gemspec

@@ -5,8 +5,7 @@ require_relative "lib/wheneverd/version"
 Gem::Specification.new do |spec|
   spec.name = "wheneverd"
   spec.version = Wheneverd::VERSION
-  spec.authors = ["Dr. Samuel Goebert"]
-  spec.email = ["maintainers@example.com"]
+  spec.authors = ["bigcurl"]
 
   spec.summary = "Wheneverd is to systemd timers what whenever is to cron."
   spec.description =

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: wheneverd
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
-- Dr. Samuel Goebert
+- bigcurl
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
@@ -25,8 +25,6 @@ dependencies:
         version: '1.3'
 description: Generates systemd timer/service units from a Ruby DSL, similar in spirit
   to the whenever gem for cron.
-email:
-- maintainers@example.com
 executables:
 - wheneverd
 extensions: []
@@ -54,6 +52,7 @@ files:
 - lib/wheneverd/cli/delete.rb
 - lib/wheneverd/cli/help.rb
 - lib/wheneverd/cli/init.rb
+- lib/wheneverd/cli/linger.rb
 - lib/wheneverd/cli/reload.rb
 - lib/wheneverd/cli/show.rb
 - lib/wheneverd/cli/write.rb
@@ -73,6 +72,7 @@ files:
 - lib/wheneverd/systemd/calendar_spec.rb
 - lib/wheneverd/systemd/cron_parser.rb
 - lib/wheneverd/systemd/errors.rb
+- lib/wheneverd/systemd/loginctl.rb
 - lib/wheneverd/systemd/renderer.rb
 - lib/wheneverd/systemd/systemctl.rb
 - lib/wheneverd/systemd/time_parser.rb
@@ -88,6 +88,7 @@ files:
 - test/cli_current_test.rb
 - test/cli_deactivate_test.rb
 - test/cli_end_to_end_test.rb
+- test/cli_linger_test.rb
 - test/cli_reload_test.rb
 - test/cli_systemctl_integration_test.rb
 - test/cli_systemd_analyze_test.rb