wheneverd 0.3.0 → 0.4.0

data/lib/wheneverd/systemd/unit_namer.rb

@@ -37,26 +37,18 @@ module Wheneverd
       private_class_method :signature
 
       def self.trigger_signature(trigger)
-        case trigger
-        when Wheneverd::Trigger::Interval
-          "interval:#{trigger.seconds}"
-        when Wheneverd::Trigger::Boot
-          "boot:#{trigger.seconds}"
-        when Wheneverd::Trigger::Calendar
-          "calendar:#{trigger.on_calendar.sort.join('|')}"
-        else
+        unless trigger.respond_to?(:signature)
           raise ArgumentError, "Unsupported trigger type: #{trigger.class}"
         end
+
+        trigger.signature
       end
       private_class_method :trigger_signature
 
       def self.job_signature(job)
-        case job
-        when Wheneverd::Job::Command
-          job.signature
-        else
-          raise ArgumentError, "Unsupported job type: #{job.class}"
-        end
+        raise ArgumentError, "Unsupported job type: #{job.class}" unless job.respond_to?(:signature)
+
+        job.signature
       end
       private_class_method :job_signature
 

data/lib/wheneverd/systemd/unit_path_utils.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Wheneverd
+  module Systemd
+    # Shared utilities for unit file path operations.
+    #
+    # These methods are used by {UnitWriter}, {UnitDeleter}, {UnitLister}, and {Renderer}
+    # to ensure consistent identifier sanitization, path pattern matching, and marker detection.
+    module UnitPathUtils
+      # Sanitizes an identifier for use in unit file names.
+      #
+      # Invalid characters are replaced with `-`, and consecutive/leading/trailing dashes
+      # are collapsed or removed.
+      #
+      # @param identifier [String]
+      # @return [String]
+      # @raise [InvalidIdentifierError] if the identifier is empty or contains no alphanumeric chars
+      def self.sanitize_identifier(identifier)
+        raw = identifier.to_s.strip
+        raise InvalidIdentifierError, "identifier must not be empty" if raw.empty?
+
+        sanitized = raw.gsub(/[^A-Za-z0-9_-]/, "-").gsub(/-+/, "-").gsub(/\A-|-+\z/, "")
+        if sanitized.empty?
+          raise InvalidIdentifierError,
+                "identifier must include at least one alphanumeric character"
+        end
+
+        sanitized
+      end
+
+      # Returns a regex pattern matching unit basenames for the given identifier.
+      #
+      # Matches both new-style (SHA-based) and legacy (eN-jN) unit names.
+      #
+      # @param identifier [String]
+      # @return [Regexp]
+      def self.basename_pattern(identifier)
+        id = sanitize_identifier(identifier)
+        /\Awheneverd-#{Regexp.escape(id)}-(?:[0-9a-f]{12}(?:-\d+)?|e\d+-j\d+)\.(service|timer)\z/
+      end
+
+      # Checks if a unit file was generated by wheneverd.
+      #
+      # Reads the first line of the file and checks for the marker prefix.
+      #
+      # @param path [String] path to the unit file
+      # @return [Boolean]
+      def self.generated_marker?(path)
+        first_line = File.open(path, "r") { |f| f.gets.to_s }
+        first_line.start_with?(Wheneverd::Systemd::Renderer::MARKER_PREFIX)
+      end
+    end
+  end
+end

data/lib/wheneverd/systemd/unit_writer.rb

@@ -67,7 +67,7 @@ module Wheneverd
       private_class_method :prune_stale_units
 
       def self.stale_unit_paths(dest_dir, identifier:, keep:)
-        pattern = basename_pattern(identifier)
+        pattern = UnitPathUtils.basename_pattern(identifier)
         Dir.children(dest_dir).filter_map do |basename|
           next if keep.key?(basename)
 
@@ -83,36 +83,10 @@ module Wheneverd
         return false unless pattern.match?(basename)
         return false unless File.file?(path)
 
-        generated_marker?(path)
+        UnitPathUtils.generated_marker?(path)
       end
       private_class_method :stale_unit_path?
 
-      def self.basename_pattern(identifier)
-        id = sanitize_identifier(identifier)
-        /\Awheneverd-#{Regexp.escape(id)}-(?:[0-9a-f]{12}(?:-\d+)?|e\d+-j\d+)\.(service|timer)\z/
-      end
-      private_class_method :basename_pattern
-
-      def self.generated_marker?(path)
-        first_line = File.open(path, "r") { |f| f.gets.to_s }
-        first_line.start_with?(Wheneverd::Systemd::Renderer::MARKER_PREFIX)
-      end
-      private_class_method :generated_marker?
-
-      def self.sanitize_identifier(identifier)
-        raw = identifier.to_s.strip
-        raise InvalidIdentifierError, "identifier must not be empty" if raw.empty?
-
-        sanitized = raw.gsub(/[^A-Za-z0-9_-]/, "-").gsub(/-+/, "-").gsub(/\A-|-+\z/, "")
-        if sanitized.empty?
-          raise InvalidIdentifierError,
-                "identifier must include at least one alphanumeric character"
-        end
-
-        sanitized
-      end
-      private_class_method :sanitize_identifier
-
       def self.atomic_write(dest_path, contents, dir:)
         basename = File.basename(dest_path)
         tmp = Tempfile.new([".#{basename}.", ".tmp"], dir)

data/lib/wheneverd/trigger/base.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Wheneverd
+  module Trigger
+    # Base module for trigger types.
+    #
+    # All trigger types must implement:
+    # - `#systemd_timer_lines` - returns Array<String> of systemd [Timer] lines
+    # - `#signature` - returns a String signature for stable unit naming
+    module Base
+      # @return [Array<String>] systemd `[Timer]` lines for this trigger
+      def systemd_timer_lines
+        raise NotImplementedError, "#{self.class} must implement #systemd_timer_lines"
+      end
+
+      # @return [String] stable signature for unit naming
+      def signature
+        raise NotImplementedError, "#{self.class} must implement #signature"
+      end
+    end
+  end
+end

data/lib/wheneverd/trigger/boot.rb

@@ -4,23 +4,25 @@ module Wheneverd
   module Trigger
     # A boot trigger, rendered as `OnBootSec=`.
     class Boot
+      include Base
+
       # @return [Integer]
       attr_reader :seconds
 
       # @param seconds [Integer] seconds after boot (must be positive)
       def initialize(seconds:)
-        unless seconds.is_a?(Integer)
-          raise ArgumentError, "Boot seconds must be an Integer (got #{seconds.class})"
-        end
-        raise ArgumentError, "Boot seconds must be positive (got #{seconds})" if seconds <= 0
-
-        @seconds = seconds
+        @seconds = Validation.positive_integer(seconds, name: "Boot seconds")
       end
 
       # @return [Array<String>] systemd `[Timer]` lines for this trigger
       def systemd_timer_lines
         ["OnBootSec=#{seconds}"]
       end
+
+      # @return [String] stable signature for unit naming
+      def signature
+        "boot:#{seconds}"
+      end
     end
   end
 end

data/lib/wheneverd/trigger/calendar.rb

@@ -4,6 +4,8 @@ module Wheneverd
   module Trigger
     # A calendar trigger, rendered as one or more `OnCalendar=` lines.
     class Calendar
+      include Base
+
       # @return [Array<String>] calendar specs (already in `systemd` OnCalendar format)
       attr_reader :on_calendar
 
@@ -21,6 +23,11 @@ module Wheneverd
       def systemd_timer_lines
         on_calendar.map { |spec| "OnCalendar=#{spec}" }
       end
+
+      # @return [String] stable signature for unit naming
+      def signature
+        "calendar:#{on_calendar.sort.join('|')}"
+      end
     end
   end
 end

data/lib/wheneverd/trigger/interval.rb

@@ -8,23 +8,25 @@ module Wheneverd
     # - `OnActiveSec=` to schedule the first run relative to timer activation.
     # - `OnUnitActiveSec=` to schedule subsequent runs relative to the last run.
     class Interval
+      include Base
+
       # @return [Integer]
       attr_reader :seconds
 
       # @param seconds [Integer] seconds between runs (must be positive)
       def initialize(seconds:)
-        unless seconds.is_a?(Integer)
-          raise ArgumentError, "Interval seconds must be an Integer (got #{seconds.class})"
-        end
-        raise ArgumentError, "Interval seconds must be positive (got #{seconds})" if seconds <= 0
-
-        @seconds = seconds
+        @seconds = Validation.positive_integer(seconds, name: "Interval seconds")
       end
 
       # @return [Array<String>] systemd `[Timer]` lines for this trigger
       def systemd_timer_lines
         ["OnActiveSec=#{seconds}", "OnUnitActiveSec=#{seconds}"]
       end
+
+      # @return [String] stable signature for unit naming
+      def signature
+        "interval:#{seconds}"
+      end
     end
   end
 end

data/lib/wheneverd/validation.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Wheneverd
+  # Common validation utilities for consistent error handling across the codebase.
+  #
+  # These validators follow a consistent pattern:
+  # - Return the validated value if valid
+  # - Raise an appropriate error with a descriptive message if invalid
+  #
+  # @example Type validation
+  #   Validation.type(value, Integer, name: "seconds")
+  #   # => value or raises ArgumentError
+  #
+  # @example Positive integer validation
+  #   Validation.positive_integer(value, name: "seconds")
+  #   # => value or raises ArgumentError
+  module Validation
+    # Validate that a value is of the expected type.
+    #
+    # @param value [Object] the value to validate
+    # @param expected_type [Class, Module] the expected type
+    # @param name [String] the parameter name for error messages
+    # @return [Object] the validated value
+    # @raise [ArgumentError] if the value is not of the expected type
+    def self.type(value, expected_type, name:)
+      return value if value.is_a?(expected_type)
+
+      raise ArgumentError,
+            "#{name} must be #{expected_type_name(expected_type)} (got #{value.class})"
+    end
+
+    # Validate that a value is a positive integer.
+    #
+    # @param value [Object] the value to validate
+    # @param name [String] the parameter name for error messages
+    # @return [Integer] the validated value
+    # @raise [ArgumentError] if the value is not a positive integer
+    def self.positive_integer(value, name:)
+      type(value, Integer, name: name)
+      return value if value.positive?
+
+      raise ArgumentError, "#{name} must be positive (got #{value})"
+    end
+
+    # Validate that a string is non-empty after stripping whitespace.
+    #
+    # @param value [String] the value to validate
+    # @param name [String] the parameter name for error messages
+    # @return [String] the stripped value
+    # @raise [ArgumentError] if the value is empty after stripping
+    def self.non_empty_string(value, name:)
+      stripped = value.to_s.strip
+      return stripped unless stripped.empty?
+
+      raise ArgumentError, "#{name} must not be empty"
+    end
+
+    # Validate that an array is non-empty.
+    #
+    # @param value [Array] the value to validate
+    # @param name [String] the parameter name for error messages
+    # @return [Array] the validated value
+    # @raise [ArgumentError] if the array is empty
+    def self.non_empty_array(value, name:)
+      type(value, Array, name: name)
+      return value unless value.empty?
+
+      raise ArgumentError, "#{name} must not be empty"
+    end
+
+    # Validate that a value is within a range.
+    #
+    # @param value [Comparable] the value to validate
+    # @param range [Range] the valid range
+    # @param name [String] the parameter name for error messages
+    # @return [Comparable] the validated value
+    # @raise [ArgumentError] if the value is outside the range
+    def self.in_range(value, range, name:)
+      return value if range.cover?(value)
+
+      raise ArgumentError, "#{name} must be in #{range} (got #{value})"
+    end
+
+    def self.expected_type_name(expected_type)
+      "a #{expected_type}"
+    end
+    private_class_method :expected_type_name
+  end
+end

data/lib/wheneverd/version.rb

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

data/lib/wheneverd.rb

@@ -11,14 +11,15 @@ module Wheneverd
   # - {Wheneverd::DSL::Loader} for evaluating `config/schedule.rb`
   # - {Wheneverd::Systemd::Renderer} for generating unit contents
   # - {Wheneverd::CLI} for the command-line interface
-  class Error < StandardError; end
 end
 
 require_relative "wheneverd/errors"
+require_relative "wheneverd/validation"
 require_relative "wheneverd/duration"
 require_relative "wheneverd/interval"
 require_relative "wheneverd/core_ext/numeric_duration"
 require_relative "wheneverd/job/command"
+require_relative "wheneverd/trigger/base"
 require_relative "wheneverd/trigger/interval"
 require_relative "wheneverd/trigger/calendar"
 require_relative "wheneverd/trigger/boot"
@@ -30,10 +31,12 @@ require_relative "wheneverd/dsl/period_parser"
 require_relative "wheneverd/dsl/context"
 require_relative "wheneverd/dsl/loader"
 require_relative "wheneverd/systemd/errors"
+require_relative "wheneverd/systemd/unit_path_utils"
 require_relative "wheneverd/systemd/time_parser"
 require_relative "wheneverd/systemd/cron_parser"
 require_relative "wheneverd/systemd/calendar_spec"
 require_relative "wheneverd/systemd/unit_namer"
+require_relative "wheneverd/systemd/unit_content_builder"
 require_relative "wheneverd/systemd/renderer"
 require_relative "wheneverd/systemd/analyze"
 require_relative "wheneverd/systemd/systemctl"

data/test/domain_model_test.rb

@@ -105,4 +105,109 @@ class DomainModelTest < Minitest::Test
   def test_entry_requires_a_trigger
     assert_raises(ArgumentError) { Wheneverd::Entry.new(trigger: nil) }
   end
+
+  def test_trigger_base_module_raises_not_implemented
+    # Create a class that includes Base but doesn't implement the methods
+    test_trigger_class = Class.new do
+      include Wheneverd::Trigger::Base
+    end
+    trigger = test_trigger_class.new
+
+    error = assert_raises(NotImplementedError) { trigger.systemd_timer_lines }
+    assert_includes error.message, "must implement #systemd_timer_lines"
+
+    error = assert_raises(NotImplementedError) { trigger.signature }
+    assert_includes error.message, "must implement #signature"
+  end
+
+  def test_trigger_signatures
+    interval = Wheneverd::Trigger::Interval.new(seconds: 60)
+    assert_equal "interval:60", interval.signature
+
+    boot = Wheneverd::Trigger::Boot.new(seconds: 5)
+    assert_equal "boot:5", boot.signature
+
+    calendar = Wheneverd::Trigger::Calendar.new(on_calendar: %w[daily hourly])
+    assert_equal "calendar:daily|hourly", calendar.signature
+  end
+
+  def test_period_strategy_base_raises_not_implemented
+    # Create a class that inherits from Base but doesn't implement the methods
+    test_strategy_class = Class.new(Wheneverd::DSL::PeriodStrategy::Base)
+    strategy = test_strategy_class.new(path: "test")
+
+    error = assert_raises(NotImplementedError) { strategy.handles?(:anything) }
+    assert_includes error.message, "must implement #handles?"
+
+    error = assert_raises(NotImplementedError) { strategy.parse(:anything, at_times: []) }
+    assert_includes error.message, "must implement #parse"
+  end
+
+  def test_validation_type
+    # Valid type
+    assert_equal 42, Wheneverd::Validation.type(42, Integer, name: "value")
+
+    # Invalid type
+    error = assert_raises(ArgumentError) do
+      Wheneverd::Validation.type("string", Integer, name: "value")
+    end
+    assert_includes error.message, "value must be a Integer"
+  end
+
+  def test_validation_positive_integer
+    # Valid positive integer
+    assert_equal 5, Wheneverd::Validation.positive_integer(5, name: "count")
+
+    # Non-positive
+    error = assert_raises(ArgumentError) do
+      Wheneverd::Validation.positive_integer(0, name: "count")
+    end
+    assert_includes error.message, "must be positive"
+
+    # Non-integer
+    error = assert_raises(ArgumentError) do
+      Wheneverd::Validation.positive_integer("5", name: "count")
+    end
+    assert_includes error.message, "must be a Integer"
+  end
+
+  def test_validation_non_empty_string
+    # Valid non-empty string
+    assert_equal "hello", Wheneverd::Validation.non_empty_string("  hello  ", name: "text")
+
+    # Empty string
+    error = assert_raises(ArgumentError) do
+      Wheneverd::Validation.non_empty_string("  ", name: "text")
+    end
+    assert_includes error.message, "must not be empty"
+  end
+
+  def test_validation_non_empty_array
+    # Valid non-empty array
+    arr = [1, 2, 3]
+    assert_equal arr, Wheneverd::Validation.non_empty_array(arr, name: "items")
+
+    # Empty array
+    error = assert_raises(ArgumentError) do
+      Wheneverd::Validation.non_empty_array([], name: "items")
+    end
+    assert_includes error.message, "must not be empty"
+
+    # Non-array
+    error = assert_raises(ArgumentError) do
+      Wheneverd::Validation.non_empty_array("not an array", name: "items")
+    end
+    assert_includes error.message, "must be a Array"
+  end
+
+  def test_validation_in_range
+    # Valid in range
+    assert_equal 5, Wheneverd::Validation.in_range(5, 1..10, name: "value")
+
+    # Out of range
+    error = assert_raises(ArgumentError) do
+      Wheneverd::Validation.in_range(15, 1..10, name: "value")
+    end
+    assert_includes error.message, "must be in 1..10"
+  end
 end

data/test/systemd_cron_parser_test.rb

@@ -38,28 +38,51 @@ class SystemdCronParserTest < Minitest::Test
     end
   end
 
-  def test_private_helpers_reject_empty_numeric_field
-    assert_private_unsupported(
-      :parse_mapped_numeric_expression,
-      "",
-      0..59,
-      field: "minute",
-      input: "x",
-      names: {}
-    )
+  def test_field_parser_rejects_empty_numeric_field
+    assert_raises(Wheneverd::Systemd::UnsupportedCronError) do
+      Wheneverd::Systemd::CronParser::FieldParser.parse_mapped(
+        "",
+        0..59,
+        field: "minute",
+        input: "x",
+        names: {}
+      )
+    end
   end
 
-  def test_private_helpers_reject_invalid_numeric_tokens
-    common = { field: "minute", input: "x", names: {} }
-    assert_private_unsupported(:parse_mapped_value, " ", 0..59, **common)
-    assert_private_unsupported(:parse_positive_int, "x", field: "minute", input: "x", label: "step")
+  def test_field_parser_rejects_invalid_numeric_tokens
+    # Empty token (just whitespace)
+    assert_raises(Wheneverd::Systemd::UnsupportedCronError) do
+      Wheneverd::Systemd::CronParser::FieldParser.parse_mapped(
+        " ",
+        0..59,
+        field: "minute",
+        input: "x",
+        names: {}
+      )
+    end
   end
 
-  def test_private_helpers_reject_empty_dow_and_invalid_tokens
-    assert_private_unsupported(:parse_dow_set, "", input: "x")
-    assert_private_unsupported(:apply_dow_part, Array.new(7, false), "", input: "x")
-    assert_private_unsupported(:parse_dow_value, "", input: "x")
-    assert_private_unsupported(:parse_dow_value, "8", input: "x")
+  def test_dow_parser_rejects_empty_and_invalid_tokens
+    # Empty day-of-week field
+    assert_raises(Wheneverd::Systemd::UnsupportedCronError) do
+      Wheneverd::Systemd::CronParser::DowParser.parse("", input: "x")
+    end
+
+    # Out of range day-of-week value (8)
+    assert_raises(Wheneverd::Systemd::UnsupportedCronError) do
+      Wheneverd::Systemd::CronParser::DowParser.parse("8", input: "x")
+    end
+
+    # Invalid step (non-numeric)
+    assert_raises(Wheneverd::Systemd::UnsupportedCronError) do
+      Wheneverd::Systemd::CronParser::DowParser.parse("*/x", input: "x")
+    end
+
+    # Invalid step (zero)
+    assert_raises(Wheneverd::Systemd::UnsupportedCronError) do
+      Wheneverd::Systemd::CronParser::DowParser.parse("*/0", input: "x")
+    end
   end
 
   def test_rejects_unsupported_cron_patterns
@@ -97,13 +120,6 @@ class SystemdCronParserTest < Minitest::Test
     assert_equal expected, Wheneverd::Systemd::CronParser.to_on_calendar_values(cron)
   end
 
-  def assert_private_unsupported(method, *args, **kwargs)
-    parser = Wheneverd::Systemd::CronParser
-    assert_raises(Wheneverd::Systemd::UnsupportedCronError) do
-      parser.send(method, *args, **kwargs)
-    end
-  end
-
   def assert_unsupported(*crons)
     crons.each do |cron|
       assert_raises(Wheneverd::Systemd::UnsupportedCronError) do

data/test/systemd_renderer_errors_test.rb

@@ -44,7 +44,7 @@ class SystemdRendererErrorsTest < Minitest::Test
 
   def test_timer_lines_for_rejects_unknown_trigger
     assert_raises(ArgumentError) do
-      Wheneverd::Systemd::Renderer.send(:timer_lines_for, Object.new)
+      Wheneverd::Systemd::UnitContentBuilder.timer_lines_for(Object.new)
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wheneverd
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - bigcurl
@@ -66,6 +66,12 @@ files:
 - lib/wheneverd/dsl/errors.rb
 - lib/wheneverd/dsl/loader.rb
 - lib/wheneverd/dsl/period_parser.rb
+- lib/wheneverd/dsl/period_strategy.rb
+- lib/wheneverd/dsl/period_strategy/array_strategy.rb
+- lib/wheneverd/dsl/period_strategy/base.rb
+- lib/wheneverd/dsl/period_strategy/duration_strategy.rb
+- lib/wheneverd/dsl/period_strategy/string_strategy.rb
+- lib/wheneverd/dsl/period_strategy/symbol_strategy.rb
 - lib/wheneverd/duration.rb
 - lib/wheneverd/entry.rb
 - lib/wheneverd/errors.rb
@@ -75,18 +81,24 @@ files:
 - lib/wheneverd/systemd/analyze.rb
 - lib/wheneverd/systemd/calendar_spec.rb
 - lib/wheneverd/systemd/cron_parser.rb
+- lib/wheneverd/systemd/cron_parser/dow_parser.rb
+- lib/wheneverd/systemd/cron_parser/field_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
+- lib/wheneverd/systemd/unit_content_builder.rb
 - lib/wheneverd/systemd/unit_deleter.rb
 - lib/wheneverd/systemd/unit_lister.rb
 - lib/wheneverd/systemd/unit_namer.rb
+- lib/wheneverd/systemd/unit_path_utils.rb
 - lib/wheneverd/systemd/unit_writer.rb
+- lib/wheneverd/trigger/base.rb
 - lib/wheneverd/trigger/boot.rb
 - lib/wheneverd/trigger/calendar.rb
 - lib/wheneverd/trigger/interval.rb
+- lib/wheneverd/validation.rb
 - lib/wheneverd/version.rb
 - test/cli_activate_test.rb
 - test/cli_current_test.rb