jscalendar 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdf3b15b894e49f349876787d56ce76102b83822e622c079dfc7966804eab2bf
-  data.tar.gz: 23259294ec16d3a2420c1af9ad97ce72aaa0df6502a7328b19d27bb7c427f158
+  metadata.gz: 9d29bdac386dada64770464be1ac5930d27f8ce7775abe993548d9ae102847af
+  data.tar.gz: e4236e4b51a48ad96eae416bcf0cbb707051bee34d73d69d73d27fb0d5e5dbf0
 SHA512:
-  metadata.gz: 5ff2aeaa9fb416f63ede56b7d018f6db8e671bb35c71badec0a76a142bf75c9aac6ac8d9ca4e850b832168105d65e06fa970196a06848da135045994092d5065
-  data.tar.gz: 1cb88675b31c5d4d7fb2609e399dc667e57212d44893d96e6114a5037eca727ccc6d4c418f0803f7bc4d3f681cd0c5e36586a4db44706ebfa5e3d1b10d58e7f2
+  metadata.gz: 70f9259f472edccf51467a34944c35d38b479d97148b070f8ff3dec1424dc8814909bf42976774d7c9bb6a4d6b03a9a6261915b60c1c10fad9da43561b3ab66d
+  data.tar.gz: 96d52c03f2787990e3ac9cdca33ed454926f40f5f7af7fd534f37ec506f2df95eacf01f1f7ac56ae43866223164502f88c3b073f6ff17d25a4fbf2d1f177ee81

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.2.1 - 2026-10-12
+
+- Match localization language tags without case sensitivity.
+
+## 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

@@ -1,7 +1,44 @@
-# JSCalendar
+<h1 align="center">JSCalendar</h1>
+
+<p align="center">JSON calendars with typed models, time zones, and recurrence.</p>
+
+<p align="center">
+  <a href="https://rubygems.org/gems/jscalendar"><img src="https://img.shields.io/gem/v/jscalendar" alt="Gem version"></a>
+  <a href="https://github.com/ydah/jscalendar/actions/workflows/main.yml"><img src="https://github.com/ydah/jscalendar/actions/workflows/main.yml/badge.svg?branch=main" alt="CI"></a>
+  <a href="https://www.ruby-lang.org/"><img src="https://img.shields.io/badge/Ruby-%3E%3D%203.3-CC342D?logo=ruby&amp;logoColor=white" alt="Ruby 3.3 or later"></a>
+  <a href="LICENSE.txt"><img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT License"></a>
+</p>
+
+<p align="center">
+  <a href="#installation">Installation</a> &middot;
+  <a href="#quick-start">Quick start</a> &middot;
+  <a href="#scope">Scope</a> &middot;
+  <a href="#development">Development</a> &middot;
+  <a href="#license">License</a>
+</p>
 
 Read, validate, build and expand calendar events and tasks using [RFC 8984](https://www.rfc-editor.org/rfc/rfc8984).
 
+## Features
+
+- Build typed events, tasks, and groups while preserving extension fields.
+- Expand Gregorian recurrence with time zones, exclusions, and overrides.
+- Apply validated patches and localizations with configurable resource limits.
+
+## Installation
+
+Add the gem to your Gemfile:
+
+```ruby
+gem "jscalendar"
+```
+
+Then run `bundle install`.
+
+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.
+
+## Quick start
+
 ```ruby
 require "jscalendar"
 
@@ -22,8 +59,6 @@ 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.
-
 ## Scope
 
 | Feature | Support |
@@ -55,6 +90,7 @@ patched = patch.apply(calendar.to_h)
 Strict parsing raises `ValidationError` with `errors` and a JSON Pointer in `pointer`. Lenient parsing preserves invalid fields with diagnostics. Serialization always validates. Unknown root types and malformed JSON raise `ParseError`; resource bounds raise `LimitError`, including in lenient mode. Duplicate keys are rejected with both supported json major versions.
 
 Recurrence overrides ignore the protected property prefixes specified by RFC 8984 §4.3.5. An `excluded: true` override can contain no other change. Localizations ignore disallowed paths. Patches never partially modify their target.
+Localization language tags match without case sensitivity.
 
 ## Time and recurrence
 
@@ -81,15 +117,13 @@ Time-zone results follow the installed TZInfo data. Its explicit future transiti
 
 Pass these keyword options to `parse` or model constructors. `occurrences` additionally requires `to`, defaults to `limit: 1000`, and enforces `timeout: 2.0` seconds over the entire expansion. An exclusion set larger than the candidate budget fails instead of returning an incorrect partial subtraction. Impossible recurrence rules also time out. URIs are data and are never fetched.
 
-## Development and references
+## Development
 
 ```sh
 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 +131,14 @@ 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.
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/ydah/jscalendar/issues). See [Development](#development) for the checks to run before submitting a change. Report security vulnerabilities privately as described in [SECURITY.md](SECURITY.md).
+
+## License
+
+Released under the [MIT License](LICENSE.txt).
+
+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/calendar.rb

@@ -21,7 +21,9 @@ module Jscalendar
     end
 
     def localize(language)
-      patch = @data.fetch("localizations", {})[language]
+      localizations = @data.fetch("localizations", {})
+      key = localizations.keys.find { |tag| tag.casecmp?(language) }
+      patch = localizations[key]
       return self.class.new(to_h, time_zones: @time_zones, **@limits) unless patch
 
       data = PatchObject.new(PatchObject.localization(patch), **@limits).apply(to_h, validate: false)

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.1"
 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.1
 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: []