wheneverd 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ef1858fab03a38b36da00bf0093d4025762263ca868d05a78c1876d8aeb6441
-  data.tar.gz: 539fbeec1db7023059767501172d7337da50a966e0727c29879f88cd81770303
+  metadata.gz: ff946dbc0ba39d3e90ecf3cbed4c9ea81c1818fcd1d206f00cf6763dfe05ebe1
+  data.tar.gz: cd42856421c97365ff63547252ea4e8ba8a5f17dc822eea8af67b45ce8861b8f
 SHA512:
-  metadata.gz: 2656962166f254b2d48f94d23329db78a16964eda9c164457c5586b4dabfa095077b75372b94da9f9cad38862d5548be15ba7b2567cef5d2fb2cdc3cb94d4984
-  data.tar.gz: a06b649a079b18fd3f321bc818e322d3284c98d96bfbabaf43244b4d604193b395186d31548efdf2296fe12509f47e665f1cdf96f47e2af25512b3eae53ba20d
+  metadata.gz: a4d31fc560c96e1b10b7b42cb0c32e4aa222823e64bde6a17cacb891246d67caefb9e42b5f71ce23a26b14392c33eb819f42fc3e199a0b2f10a0f040bb5e5193
+  data.tar.gz: fc2e7a43ed41af1b7b00cb4cc8a228054071cec67ca53bb81829134ab884f8a6b5730796a699bdd6066262d3fee18ff0234f535d2fe967b5d26543d2d7b2097e

data/CHANGELOG.md

@@ -5,6 +5,22 @@ On release, entries are moved into `## x.y.z` sections that match the gem versio
 
 ## Unreleased
 
+## 0.4.0
+
+- Docs: adds a copy/paste "deploy a simple schedule" example and refines README status section.
+- Refactor: extracts `UnitPathUtils` module for shared identifier/path utilities across `UnitWriter`, `UnitDeleter`, `UnitLister`, and `Renderer`.
+- Refactor: adds polymorphic `Trigger::Base` interface with `#systemd_timer_lines` and `#signature` methods for all trigger types.
+- Refactor: splits `CronParser` into focused `FieldParser` and `DowParser` submodules for maintainability.
+- Refactor: implements strategy pattern for `PeriodParser` with dedicated strategies for Duration, String, Symbol, and Array inputs.
+- Refactor: extracts `UnitContentBuilder` from `Renderer` for cleaner separation of unit content generation.
+- Refactor: adds `Validation` module with composable validators (`type`, `positive_integer`, `non_empty_string`, `non_empty_array`, `in_range`).
+
+## 0.3.0
+
+- Schedule DSL: `command` accepts argv arrays, adds a `shell` helper for `/bin/bash -lc`, and `wheneverd init` includes examples.
+- Adds `wheneverd status` (show `systemctl --user list-timers` + `systemctl --user status` for installed timers) and `wheneverd diff` (diff rendered units vs files on disk).
+- Adds `wheneverd validate` to validate rendered `OnCalendar=` values via `systemd-analyze calendar` (and with `--verify`, runs `systemd-analyze --user verify` on temporary unit files).
+
 ## 0.2.1
 
 - Removes an unused filtering metadata keyword argument from the schedule DSL.

data/FEATURE_SUMMARY.md

@@ -12,13 +12,22 @@ It complements [`CHANGELOG.md`](CHANGELOG.md) by staying high-level and focusing
 
 ## Unreleased
 
+## 0.3.0
+
+- Schedule DSL: `command` accepts argv arrays, adds a `shell` helper for `/bin/bash -lc`, and `wheneverd init` includes examples.
+- Adds `wheneverd status` (show `systemctl --user list-timers` + `systemctl --user status` for installed timers) and `wheneverd diff` (diff rendered units vs files on disk).
+- Adds `wheneverd validate` to validate rendered `OnCalendar=` values via `systemd-analyze calendar` (and with `--verify`, runs `systemd-analyze --user verify` on temporary unit files).
+
 ## 0.2.1
 
-- 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
 
+- Adds `wheneverd linger enable|disable|status` for managing systemd user lingering via `loginctl`.
+
+## 0.1.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`.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    wheneverd (0.2.0)
+    wheneverd (0.3.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.2.0)
+  wheneverd (0.3.0)
   yard (0.9.38) sha256=721fb82afb10532aa49860655f6cc2eaa7130889df291b052e1e6b268283010f
 
 BUNDLED WITH

data/README.md

@@ -4,14 +4,23 @@ Wheneverd is to systemd timers what the [`whenever` gem](https://github.com/java
 
 ## Status
 
-Pre-1.0, but working end-to-end for user systemd timers:
+Pre-1.0, but working end-to-end for systemd user timers on Linux:
 
 - 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`).
+- Writes, diffs, shows, and deletes generated unit files (default: `~/.config/systemd/user`).
 - Enables/starts/stops/disables/restarts timers via `systemctl --user`.
+- Validates `OnCalendar=` values with `systemd-analyze` (optional unit verification).
 - Manages lingering via `loginctl` (so timers can run while logged out).
 
+Non-goals / not yet implemented:
+
+- System-level units (`/etc/systemd/system`) / `systemctl` without `--user`.
+- Non-systemd schedulers (cron, launchd, etc).
+- Non-Linux platforms (no Windows/macOS support).
+
+Expect the CLI and generated unit details to change until 1.0.
+
 See `FEATURE_SUMMARY.md` for user-visible behavior, and `CHANGELOG.md` for release notes.
 
 ## Installation
@@ -34,6 +43,9 @@ bundle install
 wheneverd --help
 wheneverd init
 wheneverd show
+wheneverd status
+wheneverd diff
+wheneverd validate
 wheneverd write
 wheneverd delete
 wheneverd activate
@@ -43,6 +55,8 @@ wheneverd current
 wheneverd linger
 ```
 
+Use `wheneverd init` to create a starter `config/schedule.rb` template (including examples for `command` and `shell`).
+
 ### Minimal `config/schedule.rb` example
 
 ```ruby
@@ -57,6 +71,40 @@ every 1.day, at: "4:30 am" do
 end
 ```
 
+### Deploy a simple schedule (copy/paste)
+
+From your project root (the default identifier is the current directory name):
+
+```bash
+# Install (skip if already in your Gemfile)
+bundle add wheneverd
+bundle install
+
+# Write a schedule that appends a timestamp to ~/.cache/wheneverd-demo.log every minute
+mkdir -p config
+cat > config/schedule.rb <<'RUBY'
+# frozen_string_literal: true
+
+every "1m" do
+  shell "mkdir -p ~/.cache && date >> ~/.cache/wheneverd-demo.log"
+end
+RUBY
+
+# Preview, write units, and enable/start the timer(s)
+bundle exec wheneverd show
+bundle exec wheneverd validate
+bundle exec wheneverd write
+bundle exec wheneverd activate
+
+# Verify it’s installed and running
+bundle exec wheneverd status
+tail -n 5 ~/.cache/wheneverd-demo.log
+
+# Stop/disable timers and remove generated unit files
+bundle exec wheneverd deactivate
+bundle exec wheneverd delete
+```
+
 Preview the generated units:
 
 ```bash
@@ -137,13 +185,26 @@ end
 
 ### `command`
 
-`command("...")` appends a oneshot `ExecStart=` job. Commands must be non-empty strings.
+`command(...)` appends a oneshot `ExecStart=` job.
+
+Accepted forms:
 
-The command string is inserted into `ExecStart=` as-is (no shell wrapping). If you need shell features
-(pipes, redirects, globbing, env var expansion), wrap it yourself, for example:
+- `command("...")` (String): inserted into `ExecStart=` as-is (after stripping surrounding whitespace).
+- `command(["bin", "arg1", "arg2"])` (argv Array): formatted/escaped into a systemd-compatible `ExecStart=` string.
+
+If you need shell features (pipes, redirects, globbing, env var expansion), either wrap it yourself, or use `shell`:
 
 ```ruby
 command "/bin/bash -lc 'echo hello | sed -e s/hello/hi/'"
+command ["/bin/bash", "-lc", "echo hello | sed -e s/hello/hi/"]
+```
+
+### `shell`
+
+`shell("...")` is a convenience helper for the common `/bin/bash -lc` pattern:
+
+```ruby
+shell "echo hello | sed -e s/hello/hi/"
 ```
 
 ### `every` periods
@@ -203,11 +264,15 @@ Notes:
 - 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.
+- `wheneverd diff` returns exit status `0` when no differences are found, and `1` when differences are found.
 
 Commands:
 
 - `wheneverd init [--schedule PATH] [--force]` writes a template schedule file.
 - `wheneverd show [--schedule PATH] [--identifier NAME]` prints rendered units to stdout.
+- `wheneverd status [--identifier NAME] [--unit-dir PATH]` prints `systemctl --user list-timers` and `systemctl --user status` for installed timers.
+- `wheneverd diff [--schedule PATH] [--identifier NAME] [--unit-dir PATH]` diffs rendered units vs unit files on disk.
+- `wheneverd validate [--schedule PATH] [--identifier NAME] [--verify]` validates rendered `OnCalendar=` values via `systemd-analyze calendar` (and with `--verify`, runs `systemd-analyze --user verify` on temporary unit files).
 - `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.

data/lib/wheneverd/cli/diff.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Wheneverd
+  # Implements `wheneverd diff` (rendered output vs files on disk).
+  #
+  # Exit statuses follow `diff` semantics:
+  # - 0: no differences
+  # - 1: differences found
+  # - 2: error
+  class CLI::Diff < CLI
+    def execute
+      diffs = unit_diffs
+      return 0 if diffs.empty?
+
+      diffs.each_with_index do |diff, idx|
+        puts "" if idx.positive?
+        puts diff
+      end
+      1
+    rescue StandardError => e
+      handle_error(e)
+      2
+    end
+
+    private
+
+    def unit_diffs
+      rendered = rendered_units_by_basename
+      installed = installed_units_by_basename
+
+      diffs = rendered.map do |basename, contents|
+        diff_for_rendered_unit(basename, contents, installed[basename])
+      end
+      diffs.concat(stale_unit_diffs(rendered: rendered, installed: installed))
+      diffs.compact
+    end
+
+    def stale_unit_diffs(rendered:, installed:)
+      (installed.keys - rendered.keys).sort.map do |basename|
+        diff_for_removed_unit(basename, installed.fetch(basename))
+      end
+    end
+
+    def rendered_units_by_basename
+      render_units.to_h { |unit| [unit.path_basename, unit.contents.to_s] }
+    end
+
+    def installed_units_by_basename
+      paths = Wheneverd::Systemd::UnitLister.list(identifier: identifier_value, unit_dir: unit_dir)
+      paths.to_h { |path| [File.basename(path), path] }
+    end
+
+    def diff_for_rendered_unit(basename, rendered_contents, installed_path)
+      return diff_for_added_unit(basename, rendered_contents) if installed_path.nil?
+
+      installed_contents = File.read(installed_path)
+      return nil if installed_contents == rendered_contents
+
+      diff_for_changed_unit(basename, installed_path, installed_contents, rendered_contents)
+    end
+
+    def diff_for_added_unit(basename, rendered_contents)
+      dest_path = File.join(File.expand_path(unit_dir.to_s), basename)
+      header = ["diff --wheneverd #{basename}", "--- /dev/null", "+++ #{dest_path}"]
+      (header + line_diff("", rendered_contents)).join("\n")
+    end
+
+    def diff_for_removed_unit(basename, installed_path)
+      header = ["diff --wheneverd #{basename}", "--- #{installed_path}", "+++ /dev/null"]
+      (header + line_diff(File.read(installed_path), "")).join("\n")
+    end
+
+    def diff_for_changed_unit(basename, installed_path, installed_contents, rendered_contents)
+      header = ["diff --wheneverd #{basename}", "--- #{installed_path}",
+                "+++ #{basename} (rendered)"]
+      (header + line_diff(installed_contents, rendered_contents)).join("\n")
+    end
+
+    def line_diff(old_contents, new_contents)
+      old_lines = old_contents.to_s.lines.map(&:chomp)
+      new_lines = new_contents.to_s.lines.map(&:chomp)
+      max = [old_lines.length, new_lines.length].max
+
+      (0...max).flat_map do |idx|
+        diff_lines_for(old_lines[idx], new_lines[idx])
+      end
+    end
+
+    def diff_lines_for(old_line, new_line)
+      return [] if old_line.nil? && new_line.nil?
+      return [" #{old_line}"] if old_line == new_line
+      return ["-#{old_line}", "+#{new_line}"] if old_line && new_line
+      return ["-#{old_line}"] if old_line
+
+      ["+#{new_line}"]
+    end
+  end
+end

data/lib/wheneverd/cli/init.rb

@@ -32,7 +32,7 @@ module Wheneverd
       end
 
       every :hour do
-        command "echo hourly"
+        command ["echo", "hello world"]
       end
 
       every :sunday, at: "12pm" do
@@ -43,6 +43,10 @@ module Wheneverd
         command "echo midweek"
       end
 
+      every :day, at: "12:15" do
+        shell "echo hello | sed -e s/hello/hi/"
+      end
+
       every "0 0 27-31 * *" do
         command "echo raw_cron"
       end

data/lib/wheneverd/cli/status.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Wheneverd
+  # Implements `wheneverd status` (show installed timer status via `systemctl --user`).
+  class CLI::Status < CLI
+    def execute
+      timer_units = installed_timer_unit_basenames
+      return 0 if timer_units.empty?
+
+      print_list_timers(timer_units)
+      print_status(timer_units)
+      0
+    rescue StandardError => e
+      handle_error(e)
+    end
+
+    private
+
+    # @return [Array<String>]
+    def installed_timer_unit_basenames
+      paths = Wheneverd::Systemd::UnitLister.list(identifier: identifier_value, unit_dir: unit_dir)
+      paths.map { |path| File.basename(path) }.grep(/\.timer\z/).uniq
+    end
+
+    def print_list_timers(timer_units)
+      stdout, = Wheneverd::Systemd::Systemctl.run("list-timers", "--all", *timer_units)
+      print stdout
+    end
+
+    def print_status(timer_units)
+      timer_units.each do |unit|
+        stdout, = Wheneverd::Systemd::Systemctl.run("status", unit)
+        print stdout
+      end
+    end
+  end
+end

data/lib/wheneverd/cli/validate.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Wheneverd
+  # Implements `wheneverd validate` (validate rendered OnCalendar values and unit files).
+  class CLI::Validate < CLI
+    option "--verify", :flag,
+           "Also run systemd-analyze --user verify (writes units to a temporary directory)"
+
+    def execute
+      units = render_units
+      validate_on_calendar(units)
+      validate_units(units) if verify?
+      0
+    rescue StandardError => e
+      handle_error(e)
+    end
+
+    private
+
+    def validate_on_calendar(units)
+      values = on_calendar_values(units)
+      if values.empty?
+        puts "No OnCalendar= values found" if verbose?
+        return
+      end
+
+      values.each do |value|
+        Wheneverd::Systemd::Analyze.calendar(value)
+        puts "OK OnCalendar=#{value}" if verbose?
+      end
+    end
+
+    def on_calendar_values(units)
+      units.select { |unit| unit.kind == :timer }
+           .flat_map { |timer| timer.contents.to_s.lines.grep(/\AOnCalendar=/) }
+           .map { |line| line.delete_prefix("OnCalendar=").strip }
+           .uniq
+    end
+
+    def validate_units(units)
+      Dir.mktmpdir("wheneverd-validate-") do |dir|
+        paths = Wheneverd::Systemd::UnitWriter.write(units, unit_dir: dir, prune: false)
+        Wheneverd::Systemd::Analyze.verify(paths, user: true)
+        puts "OK systemd-analyze --user verify" if verbose?
+      end
+    end
+  end
+end

data/lib/wheneverd/cli.rb

@@ -63,6 +63,9 @@ end
 require_relative "cli/help"
 require_relative "cli/init"
 require_relative "cli/show"
+require_relative "cli/status"
+require_relative "cli/diff"
+require_relative "cli/validate"
 require_relative "cli/write"
 require_relative "cli/delete"
 require_relative "cli/activate"
@@ -78,6 +81,9 @@ module Wheneverd
     subcommand "help", "Show help", Wheneverd::CLI::Help
     subcommand "init", "Create a schedule template", Wheneverd::CLI::Init
     subcommand "show", "Render units to stdout", Wheneverd::CLI::Show
+    subcommand "status", "Show systemctl list-timers + status for this identifier", Wheneverd::CLI::Status
+    subcommand "diff", "Diff rendered units vs files on disk", Wheneverd::CLI::Diff
+    subcommand "validate", "Validate schedule via systemd-analyze", Wheneverd::CLI::Validate
     subcommand "write", "Write units to disk", Wheneverd::CLI::Write
     subcommand "delete", "Delete units from disk", Wheneverd::CLI::Delete
     subcommand "activate", "Enable and start timers via systemctl --user", Wheneverd::CLI::Activate

data/lib/wheneverd/dsl/context.rb

@@ -5,7 +5,7 @@ module Wheneverd
     # The evaluation context used for schedule files.
     #
     # The schedule file is evaluated via `instance_eval`, so methods defined here become available
-    # as the schedule DSL (`every`, `command`).
+    # as the schedule DSL (`every`, `command`, `shell`).
     class Context
       # @return [String] absolute schedule path
       attr_reader :path
@@ -44,21 +44,64 @@ module Wheneverd
 
       # Add a oneshot command job to the current `every` entry.
       #
-      # @param command_str [String]
+      # @example String command
+      #   command "echo hello"
+      #
+      # @example argv command
+      #   command ["echo", "hello world"]
+      #
+      # @param command_value [String, Array<String>]
       # @return [void]
-      def command(command_str)
-        unless @current_entry
-          raise LoadError.new("command() must be called inside every() block",
-                              path: path)
-        end
+      def command(command_value)
+        ensure_in_every_block!("command")
 
-        @current_entry.add_job(Wheneverd::Job::Command.new(command: command_str))
+        @current_entry.add_job(Wheneverd::Job::Command.new(command: command_value))
       rescue Wheneverd::InvalidCommandError => e
         raise LoadError.new(e.message, path: path)
       end
 
+      # Add a oneshot command job that runs via `/bin/bash -lc`.
+      #
+      # @example
+      #   shell "echo hello | sed -e s/hello/hi/"
+      #
+      # @param script [String] non-empty script to pass as `bash -lc <script>`
+      # @param shell [String] shell executable (default: "/bin/bash")
+      # @return [void]
+      def shell(script, shell: "/bin/bash")
+        ensure_in_every_block!("shell")
+        script_stripped = normalize_shell_script(script)
+        shell_executable = normalize_shell_executable(shell)
+        command([shell_executable, "-lc", script_stripped])
+      end
+
       private
 
+      def ensure_in_every_block!(name)
+        return if @current_entry
+
+        raise LoadError.new("#{name}() must be called inside every() block", path: path)
+      end
+
+      def normalize_shell_script(script)
+        unless script.is_a?(String)
+          raise LoadError.new("shell() script must be a String (got #{script.class})",
+                              path: path)
+        end
+
+        stripped = script.strip
+        raise LoadError.new("shell() script must not be empty", path: path) if stripped.empty?
+
+        stripped
+      end
+
+      def normalize_shell_executable(shell)
+        stripped = shell.to_s.strip
+        raise LoadError.new("shell() shell must not be empty", path: path) if stripped.empty?
+
+        stripped
+      end
+
       def with_current_entry(entry)
         previous_entry = @current_entry
         @current_entry = entry

data/lib/wheneverd/dsl/period_parser.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "calendar_symbol_period_list"
+require_relative "period_strategy"
 
 module Wheneverd
   module DSL
@@ -8,24 +8,12 @@ module Wheneverd
     #
     # Supported period forms are described in the README.
     #
-    # Notes:
-    #
-    # - Interval strings and {Wheneverd::Duration} values produce monotonic triggers
-    #   ({Wheneverd::Trigger::Interval}).
-    # - Calendar symbol periods and cron strings produce calendar triggers
-    #   ({Wheneverd::Trigger::Calendar}).
-    # - The `at:` option is only valid for calendar triggers, with a convenience exception for
-    #   `every 1.day, at: ...` which is treated as a daily calendar trigger.
+    # Uses a strategy pattern to delegate parsing to specialized strategy classes:
+    # - {PeriodStrategy::DurationStrategy} for Duration values
+    # - {PeriodStrategy::StringStrategy} for interval strings and cron expressions
+    # - {PeriodStrategy::SymbolStrategy} for calendar symbols
+    # - {PeriodStrategy::ArrayStrategy} for arrays of calendar symbols
     class PeriodParser
-      DAY_SECONDS = 60 * 60 * 24
-      REBOOT_NOT_SUPPORTED_MESSAGE =
-        "The :reboot period is not supported; use an interval or calendar period instead"
-
-      CALENDAR_SYMBOLS = %i[
-        hour day month year weekday weekend
-        monday tuesday wednesday thursday friday saturday sunday
-      ].freeze
-
       attr_reader :path
 
       # @param path [String] schedule path for error reporting
@@ -38,98 +26,11 @@ module Wheneverd
       # @return [Wheneverd::Trigger::Interval, Wheneverd::Trigger::Calendar]
       def trigger_for(period, at:)
         at_times = AtNormalizer.normalize(at, path: path)
-        trigger_for_period(period, at_times: at_times)
+        strategy = PeriodStrategy.for(period, path: path)
+        strategy.parse(period, at_times: at_times)
       rescue Wheneverd::InvalidIntervalError => e
         raise InvalidPeriodError.new(e.message, path: path)
       end
-
-      private
-
-      def trigger_for_period(period, at_times:)
-        return duration_trigger_for(period, at_times: at_times) if period.is_a?(Wheneverd::Duration)
-        return array_trigger_for(period, at_times: at_times) if period.is_a?(Array)
-        return string_trigger_for(period, at_times: at_times) if period.is_a?(String)
-        return symbol_trigger_for(period, at_times: at_times) if period.is_a?(Symbol)
-
-        raise InvalidPeriodError.new("Unsupported period type: #{period.class}", path: path)
-      end
-
-      def duration_trigger_for(duration, at_times:)
-        if at_times.any?
-          return daily_calendar_trigger(at_times) if duration.to_i == DAY_SECONDS
-
-          raise InvalidPeriodError.new("at: is only supported with calendar periods", path: path)
-        end
-
-        Wheneverd::Trigger::Interval.new(seconds: duration.to_i)
-      end
-
-      def daily_calendar_trigger(at_times)
-        Wheneverd::Trigger::Calendar.new(on_calendar: build_calendar_specs("day", at_times))
-      end
-
-      def string_trigger_for(str, at_times:)
-        period_str = str.strip
-
-        return interval_trigger(period_str, at_times: at_times) if interval_string?(period_str)
-
-        return cron_trigger(period_str, at_times: at_times) if cron_string?(period_str)
-
-        raise InvalidPeriodError.new("Unrecognized period #{period_str.inspect}", path: path)
-      end
-
-      def interval_trigger(period_str, at_times:)
-        if at_times.any?
-          raise InvalidPeriodError.new("at: is not supported for interval periods", path: path)
-        end
-
-        seconds = Wheneverd::Interval.parse(period_str)
-        Wheneverd::Trigger::Interval.new(seconds: seconds)
-      end
-
-      def cron_trigger(period_str, at_times:)
-        if at_times.any?
-          raise InvalidPeriodError.new("at: is not supported for cron periods", path: path)
-        end
-
-        Wheneverd::Trigger::Calendar.new(on_calendar: ["cron:#{period_str}"])
-      end
-
-      def symbol_trigger_for(sym, at_times:)
-        raise InvalidPeriodError.new(REBOOT_NOT_SUPPORTED_MESSAGE, path: path) if sym == :reboot
-
-        if CALENDAR_SYMBOLS.include?(sym)
-          return Wheneverd::Trigger::Calendar.new(
-            on_calendar: build_calendar_specs(sym.to_s, at_times)
-          )
-        end
-
-        raise InvalidPeriodError.new("Unknown period symbol: #{sym.inspect}", path: path)
-      end
-
-      def array_trigger_for(periods, at_times:)
-        bases = CalendarSymbolPeriodList.validate(
-          periods,
-          allowed_symbols: CALENDAR_SYMBOLS,
-          path: path
-        ).map(&:to_s)
-        specs = bases.flat_map { |base| build_calendar_specs(base, at_times) }.uniq
-        Wheneverd::Trigger::Calendar.new(on_calendar: specs)
-      end
-
-      def build_calendar_specs(base, at_times)
-        return [base] if at_times.empty?
-
-        at_times.map { |t| "#{base}@#{t}" }
-      end
-
-      def interval_string?(str)
-        /\A-?\d+[smhdw]\z/.match?(str)
-      end
-
-      def cron_string?(str)
-        str.split(/\s+/).length == 5
-      end
     end
   end
 end