feedkit 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74138d59abacb0faf60572624e29afc713f1fdf3e1fed0c553206cc86e357d71
-  data.tar.gz: dd88f9f5876b4e65ea21c92aad49aa351c7359aebd00f41b78ff479fa4710bb6
+  metadata.gz: 4f0ec94f0abe5c6c410bdd27edecee22b20145084f57ae72ea1b5c03c0ca03a4
+  data.tar.gz: 5da833a5d1ebd6ad7ea4c460671b55bc2b2c4ecaddc1bc52fbcda5a9ed46fa79
 SHA512:
-  metadata.gz: a2b97d983d035764a00b2dda527710269644737e5812e2bcdb4c119d3b03c6e7f9c1e1482ed3caa9b0a7a201aa58c292dd29394281b501d3b01a30411ba6145e
-  data.tar.gz: 805e9ed65e6fb34adbd42cdd8a0a36d6b5be2742605b1d76d6950782932f1c79c5538fd88b85e3f55d1cb7a581685a627fb1c71b381b3ac3b53e938e5670c33b
+  metadata.gz: 06225bdd9489fd9047a270af79eb88d9a1243c7787c77fdfcc1cdcc7d33c5888efdcb33511433840603d856efc1d77c028fc45ac1c08239bd39d304aa3dbf884
+  data.tar.gz: 19860c221a55b164880d2d8b28374e99df665ee0ef3ba2eba4f5270a9c6d9af359209ef6b62b9b92a2b39de406e1c135bcd74abc450154bcae69e1bee21814eb

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [0.3.0] - 2026-02-10
+
+### Changed
+
+- **Breaking:** Weekday numbering switched from Ruby `wday` (0=Sunday..6=Saturday) to ISO `cwday` (1=Monday..7=Sunday)
+- Simplified `PeriodStartCalculator`: removed `unit` parameter, unified `window_bounds`, and inlined single-use helpers
+
 ## [0.2.0] - 2026-02-09
 
 ### Added

data/README.md

@@ -253,7 +253,7 @@ Conditions are AND-ed together. All must match for the schedule to fire.
 |-----------|--------|---------|
 | `hour:` | `0..23` | `hour: 6`, `hour: [6, 12, 18]`, `hour: 9..17` |
 | `day:` | `1..31`, `:first`, `:last` | `day: 1`, `day: :last`, `day: 1..15` |
-| `weekday:` | `0..6` (Ruby/Rails `wday`: `0` = Sunday), `:sunday`..`:saturday` | `weekday: :monday`, `weekday: :monday..:friday` |
+| `weekday:` | `1..7` (ISO: Monday = `1`, Sunday = `7`), `:monday`..`:sunday` | `weekday: :monday`, `weekday: :monday..:friday` |
 | `week:` | `:odd`, `:even` (ISO week parity, `Date#cweek`) | `week: :odd` |
 | `month:` | `1..12`, `:january`..`:december` | `month: :january`, `month: :january..:march` |
 

data/lib/feedkit/schedule/constants.rb

@@ -8,20 +8,20 @@ module Feedkit
 
     VALID_HOUR_RANGE = (0..23)
     VALID_DAY_RANGE = (1..31)
-    VALID_WEEKDAY_RANGE = (0..6)
+    VALID_WEEKDAY_RANGE = (1..7)
     VALID_MONTH_RANGE = (1..12)
 
     SYMBOLIC_DAY_VALUES = %i[first last].freeze
     SYMBOLIC_WEEK_VALUES = %i[odd even].freeze
 
     WEEKDAYS = {
-      sunday: 0,
       monday: 1,
       tuesday: 2,
       wednesday: 3,
       thursday: 4,
       friday: 5,
-      saturday: 6
+      saturday: 6,
+      sunday: 7
     }.freeze
 
     MONTHS = {

data/lib/feedkit/schedule/matching.rb

@@ -16,7 +16,7 @@ module Feedkit
         case type
         when :hour    then time.hour
         when :day     then time.day
-        when :weekday then time.wday
+        when :weekday then time.to_date.cwday
         when :week    then time.to_date.cweek
         when :month   then time.month
         end

data/lib/feedkit/schedule/period_start_calculator.rb

@@ -13,12 +13,13 @@ module Feedkit
     class PeriodStartCalculator # rubocop:disable Metrics/ClassLength
       include Feedkit::Schedule::Normalization
 
+      # Safety limit to prevent infinite iteration. 600 weeks ≈ 11.5 years,
+      # far beyond any realistic schedule lookback.
       MAX_WINDOWS = 600
 
-      def initialize(schedule:, time:, unit:)
+      def initialize(schedule:, time:)
         @schedule = schedule
         @time = time
-        @unit = unit
       end
 
       def call
@@ -27,22 +28,24 @@ module Feedkit
         candidate = find_windowed_candidate
         return candidate if candidate
 
-        raise ArgumentError,
-              "No schedule occurrence found for #{schedule.period.inspect} / #{schedule.conditions.inspect}"
+        raise ArgumentError, "No schedule occurrence found for #{unit.inspect} / #{schedule.conditions.inspect}"
       end
 
       private
 
-      attr_reader :schedule, :time, :unit
+      attr_reader :schedule, :time
+
+      def unit
+        schedule.period
+      end
 
       def find_windowed_candidate
         cursor = time
 
         MAX_WINDOWS.times do
           window_start, window_end = window_bounds(cursor)
-          upper_bound = time < window_end ? time : window_end - 1.second
 
-          candidate = latest_candidate_in_window(window_start, window_end, upper_bound)
+          candidate = tick_candidates_for_window(window_start, window_end).reverse_each.find { |t| t <= time }
           return candidate if candidate
 
           cursor = window_start - 1.second
@@ -51,9 +54,11 @@ module Feedkit
         nil
       end
 
-      def latest_candidate_in_window(window_start, window_end, upper_bound)
-        candidates = tick_candidates_for_window(window_start, window_end)
-        candidates.reverse_each.find { |t| t <= upper_bound }
+      def window_bounds(cursor_time)
+        args = unit == :week ? [:monday] : []
+        start_time = cursor_time.public_send(:"beginning_of_#{unit}", *args)
+        end_time = cursor_time.public_send(:"end_of_#{unit}", *args)
+        [start_time, end_time]
       end
 
       def tick_candidates_for_window(window_start, window_end)
@@ -61,53 +66,12 @@ module Feedkit
         dates.flat_map { |date| tick_candidates_for_date(window_start, window_end, date) }.sort
       end
 
-      def tick_candidates_for_date(window_start, window_end, date)
-        candidate_hours.filter_map do |hour|
-          candidate = build_candidate_time(window_start, date, hour)
-          next unless candidate
-          next unless candidate >= window_start && candidate < window_end
-          next unless schedule.due?(candidate)
-
-          candidate
-        end
-      end
-
-      def build_candidate_time(window_start, date, hour)
-        window_start.change(
-          year: date.year,
-          month: date.month,
-          day: date.day,
-          hour:,
-          min: 0,
-          sec: 0
-        )
-      rescue TZInfo::PeriodNotFound, TZInfo::AmbiguousTime
-        # In DST transitions, some local times may not exist or may be ambiguous
-        # depending on the time zone rules. If Rails can't construct a stable
-        # TimeWithZone for the candidate tick, skip this candidate.
-        nil
-      end
-
-      def candidate_hours
-        value = schedule.effective_conditions[:hour]
-        return [0] unless value
-
-        hours = case value
-                when Range then value.to_a
-                when Array then value
-                else [value]
-                end
-
-        hours.map(&:to_i).uniq.sort
-      end
-
       def candidate_dates_for_window(window_start)
         case unit
         when :day   then candidate_day_dates(window_start)
         when :week  then candidate_week_dates(window_start)
         when :month then candidate_month_dates(window_start)
         when :year  then candidate_year_dates(window_start)
-        else raise ArgumentError, "Unknown unit: #{unit.inspect}"
         end
       end
 
@@ -117,95 +81,74 @@ module Feedkit
 
       def candidate_week_dates(window_start)
         week_start = window_start.to_date # Monday (ISO week start)
-        candidate_weekdays.map { |wday| week_start + weekday_offset_from_monday(wday) }.uniq.sort
+        candidate_weekdays.map { |wday| week_start + (wday - 1) }.uniq.sort
       end
 
       def candidate_month_dates(window_start)
-        month_time = window_start
-        candidate_days_in_month(month_time).filter_map do |day|
-          safe_date(month_time.year, month_time.month, day)
+        candidate_days_in_month(window_start).filter_map do |day|
+          safe_date(window_start.year, window_start.month, day)
         end.uniq.sort
       end
 
       def candidate_year_dates(window_start)
-        year = window_start.year
         candidate_months.flat_map do |month|
           month_time = window_start.change(month:, day: 1)
-          candidate_days_in_month(month_time).filter_map { |day| safe_date(year, month, day) }
+          candidate_days_in_month(month_time).filter_map { |day| safe_date(window_start.year, month, day) }
         end.uniq.sort
       end
 
-      def safe_date(year, month, day)
-        Date.new(year, month, day)
-      rescue Date::Error
+      def tick_candidates_for_date(window_start, window_end, date)
+        candidate_hours.filter_map do |hour|
+          candidate = build_candidate_time(window_start, date, hour)
+          next unless candidate
+          next unless candidate.between?(window_start, window_end)
+          next unless schedule.due?(candidate)
+
+          candidate
+        end
+      end
+
+      def build_candidate_time(window_start, date, hour)
+        window_start.change(
+          year: date.year,
+          month: date.month,
+          day: date.day,
+          hour:,
+          min: 0,
+          sec: 0
+        )
+      rescue TZInfo::PeriodNotFound, TZInfo::AmbiguousTime
+        # In DST transitions, some local times may not exist or may be ambiguous
+        # depending on the time zone rules. If Rails can't construct a stable
+        # TimeWithZone for the candidate tick, skip this candidate.
         nil
       end
 
+      def candidate_hours
+        value = schedule.effective_conditions[:hour]
+        Array(value.is_a?(Range) ? value.to_a : value).map(&:to_i).uniq.sort
+      end
+
       def candidate_weekdays
         value = schedule.effective_conditions[:weekday]
-        return [WEEKDAYS.fetch(:monday)] unless value
-
         normalize_weekday_value_list(value).uniq.sort
       end
 
-      def candidate_months
-        value = schedule.effective_conditions[:month]
-        return [MONTHS.fetch(:january)] unless value
-
-        normalize_month_value_list(value).uniq.sort
-      end
-
       def candidate_days_in_month(time)
         value = schedule.effective_conditions[:day]
-        return [1] unless value
-
         normalize_day_value_list(value, time).uniq.sort
       end
 
-      def weekday_offset_from_monday(wday)
-        (wday.to_i - 1) % 7
-      end
-
-      def window_bounds(cursor_time)
-        case unit
-        when :day   then day_window_bounds(cursor_time)
-        when :week  then week_window_bounds(cursor_time)
-        when :month then month_window_bounds(cursor_time)
-        when :year  then year_window_bounds(cursor_time)
-        else raise ArgumentError, "Unknown unit: #{unit.inspect}"
-        end
-      end
-
-      def day_window_bounds(cursor_time)
-        start_time = cursor_time.beginning_of_day
-        [start_time, start_time + 1.day]
-      end
-
-      def week_window_bounds(cursor_time)
-        start_date = iso_week_start_date(cursor_time.to_date)
-        start_time = cursor_time.change(
-          year: start_date.year,
-          month: start_date.month,
-          day: start_date.day,
-          hour: 0,
-          min: 0,
-          sec: 0
-        )
-        [start_time, start_time + 1.week]
-      end
-
-      def month_window_bounds(cursor_time)
-        start_time = cursor_time.beginning_of_month
-        [start_time, start_time + 1.month]
-      end
-
-      def year_window_bounds(cursor_time)
-        start_time = cursor_time.beginning_of_year
-        [start_time, start_time + 1.year]
+      def candidate_months
+        value = schedule.effective_conditions[:month]
+        normalize_month_value_list(value).uniq.sort
       end
 
-      def iso_week_start_date(date)
-        date - (date.cwday - 1)
+      # Returns nil for invalid dates like Feb 30 instead of raising.
+      def safe_date(year, month, day)
+        Date.new(year, month, day)
+      rescue Date::Error
+        nil
       end
     end
   end

data/lib/feedkit/schedule/validation.rb

@@ -70,7 +70,7 @@ module Feedkit
         return if value.is_a?(Integer) && VALID_WEEKDAY_RANGE.cover?(value)
 
         raise ArgumentError,
-              "Invalid weekday value: #{value}. Must be integer 0-6 or symbol (#{WEEKDAYS.keys.join(", ")})"
+              "Invalid weekday value: #{value}. Must be integer 1-7 or symbol (#{WEEKDAYS.keys.join(", ")})"
       end
 
       def validate_week_value!(value)

data/lib/feedkit/schedule.rb

@@ -37,7 +37,7 @@ module Feedkit
     # based on schedule boundaries rather than a sliding window (e.g. `1.day.ago`).
     def period_start_at(time = Time.current)
       time = normalize_time(time)
-      PeriodStartCalculator.new(schedule: self, time:, unit: period).call
+      PeriodStartCalculator.new(schedule: self, time:).call
     end
 
     def effective_conditions

data/lib/feedkit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Feedkit
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: feedkit
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Ali Hamdi Ali Fadel