jscalendar 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdf3b15b894e49f349876787d56ce76102b83822e622c079dfc7966804eab2bf
-  data.tar.gz: 23259294ec16d3a2420c1af9ad97ce72aaa0df6502a7328b19d27bb7c427f158
+  metadata.gz: 5c8a6fa3585b6b547bed270e19143ea159f653cfbd1273b3388e57baee9dcc70
+  data.tar.gz: 79ebbf4f3a0a3c3bb7a8f3e8e7f35ce598661f8be8f137d437c1331b752bcc6f
 SHA512:
-  metadata.gz: 5ff2aeaa9fb416f63ede56b7d018f6db8e671bb35c71badec0a76a142bf75c9aac6ac8d9ca4e850b832168105d65e06fa970196a06848da135045994092d5065
-  data.tar.gz: 1cb88675b31c5d4d7fb2609e399dc667e57212d44893d96e6114a5037eca727ccc6d4c418f0803f7bc4d3f681cd0c5e36586a4db44706ebfa5e3d1b10d58e7f2
+  metadata.gz: 2ae20894387d667263708e65ac59345bb581e98113253388ba98fba9cba0a1609fe7779d67967443e71c1ff9ade4164319d3f96025140058948cebd9c9ef1054
+  data.tar.gz: b3fc5875d728e14afae29d00c1a65b2be18f4943a01f846edd2552955c43dfa82350f36d15e6a46ff17fc3f2bca1f026260b8c63c2a1a47c87ce5b8a7a5d0eb4

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.2.0 - 2026-10-12
+
+- Expand Gregorian recurrence rules without the `rrule` dependency.
+- Apply JSCalendar's yearly recurrence defaults and preserve fractional seconds in distant occurrence windows.
+
 ## 0.1.0 - 2026-10-12
 
 Initial release.

data/README.md

@@ -22,7 +22,7 @@ instances.each { |instance| puts [instance.recurrence_id, instance.start_time, i
 instances.truncated?
 ```
 
-Install with `gem install jscalendar`. Ruby 3.3 or newer is required. CI checks maintained CRuby versions, Ruby head, JRuby and TruffleRuby on Linux and macOS, and json 2 and 3. Runtime dependencies are `json`, `tzinfo` and `rrule`. Install `tzinfo-data` on systems without a zoneinfo database, including Windows. No other Gem from this format family is required.
+Install with `gem install jscalendar`. Ruby 3.3 or newer is required. CI checks maintained CRuby versions, Ruby head, JRuby and TruffleRuby on Linux and macOS, and json 2 and 3. Runtime dependencies are `json` and `tzinfo`. Gregorian recurrence generation is implemented by this library. Install `tzinfo-data` on systems without a zoneinfo database, including Windows. No other Gem from this format family is required.
 
 ## Scope
 
@@ -87,9 +87,7 @@ Pass these keyword options to `parse` or model constructors. `occurrences` addit
 bundle install
 bundle exec rake test
 COVERAGE=1 bundle exec rake test
-bundle exec rubocop
 bundle exec rbs -I sig validate
-bundle exec ruby script/interop.rb
 bundle exec ruby script/benchmark.rb
 ```
 
@@ -97,4 +95,6 @@ RFC source documents and 52 generated examples are fetched into ignored `tmp/` w
 
 `script/update_registry.rb` checks property and enum identifiers against pinned IANA registries, CLDR calendar names and CSS Level 3 color names. Downloaded sources remain in ignored `tmp/registry/`; only identifiers needed for validation are present in the authored metadata. Updating a checksum requires reviewing the corresponding metadata differences. Source terms are available from [IANA](https://www.iana.org/help/licensing-terms), [Unicode](https://www.unicode.org/license.txt) and [W3C](https://www.w3.org/copyright/document-license/).
 
-The interoperability job compares all 42 RFC 5545 recurrence examples with Stalwart's `calcard` 0.3.2. It records one exact upstream UTC UNTIL discrepancy and compares dates before 2050, within the shared time-zone transition horizon. RFC 8984's ten examples all round trip. See [specification decisions](docs/specification.md) for errata and extraction corrections.
+Every Ruby test job checks all 42 RFC 5545 recurrence examples against the results printed in the downloaded RFC. Finite examples also check for unexpected extra occurrences; infinite examples are checked through the last printed date. RFC 8984's ten examples all round trip. See [specification decisions](docs/specification.md) for errata and extraction corrections.
+
+Additional dependencies must offer the MIT license, including development and comparison tools. The Ruby runtime and its standard libraries are exceptions to this policy. Reference documents and registry facts are test/specification inputs, not dependency implementations. See [implementation provenance](docs/provenance.md) for the scope and limits of the source audit.

data/SECURITY.md

@@ -7,3 +7,5 @@ Calendar data can include private locations and contact details. Applications co
 Parsing never fetches calendar URIs, executes content, schedules invitations or sends alerts.
 Input size, depth, collection sizes and recurrence work are bounded. Resource limits are hard failures even with `strict: false`.
 Recurrence expansion requires an end time, caps its output and interrupts work after a configurable time budget.
+
+Dependency changes must satisfy the MIT-only additional-dependency policy. The Ruby runtime and standard libraries are excepted. Consult the actual license files as well as package metadata; do not infer implementation provenance from packaging exclusions.

data/lib/jscalendar/recurrence.rb

@@ -13,8 +13,8 @@ module Jscalendar
       errors = Validator.new.validate(rule, type: "RecurrenceRule")
       raise ValidationError, errors unless errors.empty?
       raise UnsupportedError, "only Gregorian recurrence expansion is supported" unless rule.fetch("rscale", "gregorian") == "gregorian"
-      raise UnsupportedError, "rrule supports only skip=omit" unless rule.fetch("skip", "omit") == "omit"
-      raise UnsupportedError, "rrule does not support leap seconds" if rule.fetch("bySecond", []).include?(60)
+      raise UnsupportedError, "recurrence expansion supports only skip=omit" unless rule.fetch("skip", "omit") == "omit"
+      raise UnsupportedError, "recurrence expansion does not support leap seconds" if rule.fetch("bySecond", []).include?(60)
 
       parts = ["FREQ=#{rule.fetch("frequency").upcase}"]
       PARTS.each { |name, keyword| parts << "#{keyword}=#{Array(rule[name]).join(",").upcase}" if rule.key?(name) }
@@ -25,48 +25,200 @@ module Jscalendar
     end
 
     def rule_times(rule, initial, from, to, limit:, include_initial: true)
-      return [] if rule.fetch("count", 1).zero?
+      to_rrule(rule) # Validate before constructing candidates.
+      GregorianRecurrence.new(rule, initial).between(from, to, limit: limit, include_initial: include_initial)
+    end
+  end
+
+  # Authored from the candidate/filter rules in RFC 8984 section 4.3.3.1
+  # and RFC 5545 section 3.3.10. Dates are wall-clock UTC until zone conversion.
+  class GregorianRecurrence
+    DAYS = %w[su mo tu we th fr sa].freeze
+    SECONDS = { "weekly" => 604_800, "daily" => 86_400, "hourly" => 3600, "minutely" => 60, "secondly" => 1 }.freeze
+    CLOCK = [["byHour", 3600, 24], ["byMinute", 60, 60], ["bySecond", 1, 60]].freeze
+
+    def initialize(rule, initial)
+      @rule = Jscalendar.deep_copy(rule)
+      @initial = initial
+      @frequency = @rule.fetch("frequency")
+      @interval = @rule.fetch("interval", 1)
+      @week_start = DAYS.index(@rule.fetch("firstDayOfWeek", "mo"))
+      @until = LocalDateTime.new(@rule["until"]).to_time if @rule["until"]
+      add_defaults
+    end
+
+    def between(from, to, limit:, include_initial:)
+      count = @rule["count"]
+      return [] if count == 0
 
-      rule = Jscalendar.deep_copy(rule)
-      count = rule.delete("count")
-      if rule["frequency"] == "yearly" && rule.key?("byWeekNo") && !(rule.key?("byYearDay") || rule.key?("byMonthDay") || rule.key?("byDay"))
-        # RFC 8984 section 4.3.3 supplies this default; rrule 0.8 does not.
-        rule["byDay"] = [{ "@type" => "NDay", "day" => %w[su mo tu we th fr sa][initial.wday] }]
-      end
-      string = to_rrule(rule)
-      engine = RRule::Rule.new(string, dtstart: initial, tzid: "UTC", max_year: to.year + 1)
       result = []
-      generated = 0
-      if include_initial
-        generated = 1
-        result << initial if initial >= from && initial < to
-        return result if count == 1 || result.size >= limit
-      end
-      # The engine strips fractions. Shift its lower bound before restoring them.
-      engine.each(floor_date: (count ? initial : from) - initial.subsec) do |date|
-        date = date.to_time.getutc + initial.subsec
-        next if include_initial && date == initial
-        break if date >= to
-        break if rule["until"] && date > LocalDateTime.new(rule["until"]).to_time
-        break if count && generated >= count
-        next unless clock_matches?(rule, date)
-
-        generated += 1
-        result << date if date >= from
-        break if result.size >= limit
+      generated = include_initial ? 1 : 0
+      result << @initial if include_initial && @initial >= from && @initial < to
+      return result if (count && generated >= count) || result.size >= limit
+
+      index = count ? 0 : first_period(from)
+      loop do
+        start = period(index)
+        break if start >= to || (@until && start > @until)
+
+        each_candidate(start) do |candidate|
+          next if candidate < @initial || (include_initial && candidate == @initial)
+          return result if candidate >= to || (@until && candidate > @until)
+
+          generated += 1
+          result << candidate if candidate >= from
+          return result if (count && generated >= count) || result.size >= limit
+        end
+        index += 1
       end
       result
     end
 
-    # rrule 0.8 overwrites clock filters for hourly and faster frequencies.
-    def clock_matches?(rule, date)
-      checks = case rule["frequency"]
-               when "hourly" then { "byHour" => date.hour }
-               when "minutely" then { "byHour" => date.hour, "byMinute" => date.min }
-               when "secondly" then { "byHour" => date.hour, "byMinute" => date.min, "bySecond" => date.sec }
-               else {}
-               end
-      checks.all? { |name, number| !rule.key?(name) || rule[name].include?(number) }
+    private
+
+    def add_defaults
+      width = SECONDS.fetch(@frequency, 86_400)
+      CLOCK.each do |name, seconds, _size|
+        @rule[name] ||= [(@initial.hour * 3600 + @initial.min * 60 + @initial.sec) / seconds % (name == "byHour" ? 24 : 60)] if width > seconds
+      end
+      weekday = [{ "day" => DAYS[@initial.wday] }]
+      @rule["byDay"] ||= weekday if @frequency == "weekly"
+      if @frequency == "monthly" && !@rule.key?("byDay")
+        @rule["byMonthDay"] ||= [@initial.day]
+      end
+      return unless @frequency == "yearly" && !@rule.key?("byYearDay")
+
+      if !@rule.key?("byMonth") && !@rule.key?("byWeekNo") && (@rule.key?("byMonthDay") || !@rule.key?("byDay"))
+        @rule["byMonth"] = [@initial.month.to_s]
+      end
+      return if @rule.key?("byMonthDay") || @rule.key?("byDay")
+
+      @rule[@rule.key?("byWeekNo") ? "byDay" : "byMonthDay"] = @rule.key?("byWeekNo") ? weekday : [@initial.day]
+    end
+
+    def date(year, month = 1, day = 1)
+      Date.new(year, month, day, Date::GREGORIAN)
+    end
+
+    def midnight(value)
+      Time.utc(value.year, value.month, value.day)
+    end
+
+    def period(index)
+      steps = index * @interval
+      case @frequency
+      when "yearly" then Time.utc(@initial.year + steps)
+      when "monthly" then midnight(date(@initial.year, @initial.month) >> steps)
+      when "weekly"
+        first = date(@initial.year, @initial.month, @initial.day)
+        midnight(first - ((first.wday - @week_start) % 7)) + steps * 604_800
+      else
+        width = SECONDS.fetch(@frequency)
+        Time.at(@initial.to_i.div(width) * width + steps * width).utc
+      end
+    end
+
+    # Jump whole periods only when COUNT does not require counting earlier matches.
+    def first_period(from)
+      delta = case @frequency
+              when "yearly" then from.year - @initial.year
+              when "monthly" then (from.year - @initial.year) * 12 + from.month - @initial.month
+              else ((from.to_r - period(0).to_r) / SECONDS.fetch(@frequency)).floor
+              end
+      [delta.div(@interval), 0].max
+    end
+
+    def dates_in(start)
+      first = date(start.year, start.month, start.day)
+      last = case @frequency
+             when "yearly" then date(start.year + 1) - 1
+             when "monthly" then (first >> 1) - 1
+             when "weekly" then first + 6
+             else first
+             end
+      (first..last).select { |value| date_matches?(value) }
+    end
+
+    def signed_member?(values, number, length)
+      values.include?(number) || values.include?(number - length - 1)
+    end
+
+    def week_one(year)
+      january_fourth = date(year, 1, 4)
+      january_fourth - ((january_fourth.wday - @week_start) % 7)
+    end
+
+    def week_matches?(value)
+      year = value.year
+      first = week_one(year)
+      if value < first
+        year -= 1
+        first = week_one(year)
+      elsif value >= week_one(year + 1)
+        year += 1
+        first = week_one(year)
+      end
+      number = ((value - first).to_i / 7) + 1
+      signed_member?(@rule["byWeekNo"], number, (week_one(year + 1) - first).to_i / 7)
+    end
+
+    def date_matches?(value)
+      return false if @rule.key?("byMonth") && !@rule["byMonth"].include?(value.month.to_s)
+      return false if @rule.key?("byWeekNo") && !week_matches?(value)
+      return false if @rule.key?("byYearDay") && !signed_member?(@rule["byYearDay"], value.yday, date(value.year, 12, 31).yday)
+      return false if @rule.key?("byMonthDay") && !signed_member?(@rule["byMonthDay"], value.day, date(value.year, value.month, -1).day)
+
+      !@rule.key?("byDay") || @rule["byDay"].any? { |day| day_matches?(value, day) }
+    end
+
+    def day_matches?(value, day)
+      return false unless DAYS[value.wday] == day["day"]
+      return true unless day.key?("nthOfPeriod")
+
+      # RFC 8984 uses the frequency period even when BYMONTH is present.
+      if @frequency == "monthly"
+        first = date(value.year, value.month)
+        last = date(value.year, value.month, -1)
+      elsif @frequency == "yearly"
+        first = date(value.year)
+        last = date(value.year, 12, 31)
+      else
+        return [1, -1].include?(day["nthOfPeriod"])
+      end
+      signed_member?([day["nthOfPeriod"]], (value - first).to_i / 7 + 1,
+                     (value - first).to_i / 7 + 1 + (last - value).to_i / 7)
+    end
+
+    def clock_values(start)
+      width = SECONDS.fetch(@frequency, 86_400)
+      CLOCK.map do |name, seconds, size|
+        values = @rule.fetch(name, (0...size).to_a).uniq.sort
+        values &= [(start.hour * 3600 + start.min * 60 + start.sec) / seconds % size] if width <= seconds
+        values
+      end
+    end
+
+    def each_candidate(start)
+      dates = dates_in(start)
+      hours, minutes, seconds = clock_values(start)
+      per_day = hours.size * minutes.size * seconds.size
+      size = dates.size * per_day
+      return if size.zero?
+
+      # Index the Cartesian product instead of allocating up to 31 million
+      # Time objects for a yearly period with all clock values and BYSETPOS.
+      positions = if @rule.key?("bySetPosition")
+                    @rule["bySetPosition"].map { |n| n.positive? ? n - 1 : size + n }.select { |n| n >= 0 && n < size }.uniq.sort
+                  else
+                    0...size
+                  end
+      positions.each do |position|
+        day_index, remainder = position.divmod(per_day)
+        hour_index, remainder = remainder.divmod(minutes.size * seconds.size)
+        minute_index, second_index = remainder.divmod(seconds.size)
+        value = dates[day_index]
+        yield Time.utc(value.year, value.month, value.day, hours[hour_index], minutes[minute_index], seconds[second_index]) + @initial.subsec
+      end
     end
   end
 

data/lib/jscalendar/temporal.rb

@@ -4,7 +4,7 @@ module Jscalendar
   class UnsupportedError < Error; end
 
   def self.decimal_seconds(number)
-    value = number.is_a?(Float) ? BigDecimal(number.to_s).to_r : number.to_r
+    value = number.is_a?(Float) ? Rational(number.to_s) : number.to_r
     denominator = value.denominator
     powers = [2, 5].map do |factor|
       count = 0

data/lib/jscalendar/version.rb

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

data/lib/jscalendar.rb

@@ -5,11 +5,9 @@ require "yaml"
 require "date"
 require "time"
 require "uri"
-require "bigdecimal"
 require "securerandom"
 require "timeout"
 require "tzinfo"
-require "rrule"
 require_relative "jscalendar/version"
 require_relative "jscalendar/errors"
 require_relative "jscalendar/types"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jscalendar
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Yudai Takada
@@ -29,20 +29,6 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '4'
-- !ruby/object:Gem::Dependency
-  name: rrule
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.8.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.8.0
 - !ruby/object:Gem::Dependency
   name: tzinfo
   requirement: !ruby/object:Gem::Requirement
@@ -111,7 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Read, validate, and expand JSCalendar events and tasks
 test_files: []