jiff-magnus 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a6f9c863e107b4351d7c9e56a504aaec9f428a1862174281eb4c5007461f2304
+  data.tar.gz: '039d66e2dc37e5d5aca5795019e186e430f9c006bbec093ba531ac2cce8e5ef1'
+SHA512:
+  metadata.gz: 76209b92a010871e7a910ee4f2fbf1136c668fbbcd7153ba400d039cc2dfb5e181ee2ee97173f5a90fe05eb7ba2dd9541055175917f660a203c9e5cbfbea78f2
+  data.tar.gz: 809ffdabfe974ef1561b3752bba1ef429e5a2d8669dc000575e7187edc9f0db758831c0a2a6535d688797cb484a91c560afb3ac848c9ea3b33d49cfbb83706e4

data/.gitignore

@@ -0,0 +1,8 @@
+/pkg/
+!/tmp/
+/Gemfile.lock
+/Makefile
+/mkmf.log
+/*.so
+/*.bundle
+/*.dll

data/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "jiff-magnus"
+version = "0.0.1"
+edition = "2024"
+rust-version = "1.85"
+description = "Jiff timezone constructors and bundled timezone data for Ruby Time."
+repository = "https://github.com/matsadler/magnus"
+license = "MIT"
+
+[dependencies]
+jiff = { version = "0.2.35", default-features = false, features = ["std", "tzdb-bundle-always"] }
+magnus = { version = "0.10.0", default-features = false, features = ["jiff-zoned", "rb-sys"] }
+rb-sys = { version = "0.9.124", default-features = false, features = ["stable-api-compiled-fallback"] }
+
+[dev-dependencies]
+magnus = { version = "0.10.0", default-features = false, features = ["embed", "jiff-zoned", "rb-sys"] }

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Erick Guan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,182 @@
+# jiff-magnus
+
+A Magnus companion gem that provides Jiff timezones for Ruby `Time`.
+It bundles IANA timezone data.
+
+## Install and use
+
+```sh
+gem install jiff-magnus --version 0.0.1
+```
+
+```ruby
+require "jiff_magnus"
+
+zone = JiffTimezone.find_timezone("America/New_York")
+time = Time.new(2024, 7, 1, 12, 0, 0, in: zone)
+time.utc_offset     # => -14400
+time.dst?           # => true
+time.strftime("%Z") # => "EDT"
+
+# By default, requiring the gem installs Time.find_timezone if absent.
+Time.at(0, in: "Asia/Tokyo")
+
+JiffTimezone.utc
+JiffTimezone.fixed(19_800) # Seconds east of UTC.
+JiffTimezone.posix("EST5EDT,M3.2.0,M11.1.0")
+JiffTimezone.unknown
+```
+
+`find_timezone` returns `nil` for unknown names. Invalid fixed offsets and POSIX
+rules raise `ArgumentError`. Timezone objects are frozen; ordinary `new` and
+`allocate` are disabled. `iana_name` returns `nil` when a zone has no IANA name.
+`inspect` shows the class, timezone label, and portable representation.
+
+Local times in DST gaps and repeated local times raise `ArgumentError`.
+Construct from an instant to select either occurrence of an overlap:
+
+```ruby
+Time.at(Time.utc(2024, 11, 3, 5, 30).to_i, in: "America/New_York") # EDT
+Time.at(Time.utc(2024, 11, 3, 6, 30).to_i, in: "America/New_York") # EST
+```
+
+## Initialization and Marshal
+
+Requiring the gem initializes `JiffTimezone`. By default, it also defines
+`Time.find_timezone` if absent. Existing lookup methods, including private ones,
+are preserved. Repeated `require` calls reuse the loaded extension. An existing
+`JiffTimezone` class is reused when it inherits from the same Magnus copy's
+timezone class; its public methods are neither checked nor replaced.
+
+To skip automatic `Time.find_timezone` registration, set
+`JIFF_MAGNUS_ENABLE_AUTO_TIME_REGISTRATION` to `0` or `false` before requiring
+the gem. `false` is case-insensitive; other values and an unset variable enable
+automatic registration. This setting is read on the first initialization.
+Timezone constructors and Magnus conversions remain available.
+
+```ruby
+ENV["JIFF_MAGNUS_ENABLE_AUTO_TIME_REGISTRATION"] = "0"
+require "jiff_magnus"
+
+zone = JiffTimezone.find_timezone("Asia/Tokyo")
+Time.at(0, in: zone)
+```
+
+To explicitly install or replace name lookup with Jiff, even with automatic
+registration disabled:
+
+```ruby
+JiffTimezone.register
+Time.at(0, in: "Asia/Tokyo")
+```
+
+Rust callers can use `jiff_magnus::register(ruby)` for the same operation.
+Registration makes `Time.find_timezone` public. If replacement fails, the
+previous method and its visibility are restored.
+
+An unrelated class or a class from another Magnus build raises `LoadError`.
+An unrelated `TimeZone` constant does not conflict. Repeated native
+initialization raises `LoadError` if the cached class or a tracked lookup method
+was removed or replaced unexpectedly. Explicit registration updates that cached
+method. Reentrant initialization or registration raises `LoadError`; the outer
+operation can roll back and be retried. A failed initialization removes only
+definitions it added, preserving application definitions created by Ruby hooks.
+Failed resolver replacement also preserves an explicitly disabled inherited
+lookup.
+
+Require the gem before loading marshalled named-zone times. Native fixed-offset
+times need no resolver. POSIX, unknown, and explicitly wrapped fixed-offset
+zones have no restorable IANA name; dumping times with those objects raises
+`TypeError`.
+
+Magnus owns Rust conversions, timezone storage, and native interoperability.
+See its [Jiff timezone documentation](../docs/jiff-timezones.md) for conversion
+behavior, internal objects, and limits when extensions use different builds.
+The companion owns public constructors, lookup, and initialization.
+
+## Build and test from source
+
+Use Ruby 3.2 or later, Rust 1.85 or later, a C compiler, and libclang.
+From this directory, run:
+
+```sh
+bundle install
+bundle exec rake
+bundle exec rake build
+```
+
+The checkout builds against the current Magnus source through `path = ".."`.
+The default task runs Standard and the Ruby tests. Run `bundle exec rake standard`
+to lint separately. A local Standard extension requires parentheses on `assert`
+and `refute` calls in the Ruby tests; `bundle exec rake standard:fix` adds them.
+The test task builds the native extension and exercises
+`require`, timezone behavior, and Marshal across processes. The build task creates
+the source gem under `pkg/`; distributed source gems resolve their declared
+Magnus dependency from crates.io. The workspace uses its root Cargo lockfile.
+Rake keeps build intermediates and temporary packaging files under `tmp/`.
+Run `bundle exec rake clobber` to remove them and the generated packages while
+keeping `tmp/.gitignore`.
+
+After the required Magnus version is published, you can manually check an
+installed source gem from the repository root:
+
+```sh
+ruby docs/examples/jiff_magnus_install.rb jiff-magnus/pkg/jiff-magnus-0.0.1.gem
+```
+
+## Local releases
+
+Bundler's gem tasks provide `build`, `install`, and `release`, as in `ffi-icu`.
+The build task uses our staging step to remove checkout-only Cargo paths from
+the source gem. The version comes from `jiff-magnus/Cargo.toml`.
+
+After the required Magnus version is published, run from this directory on a
+clean Git branch with working push credentials:
+
+```sh
+gem signin
+bundle exec rake release
+```
+
+The release task runs Standard, the Ruby tests, and an installed-source-gem
+check. It then creates a `jiff-magnus-v<version>` tag, pushes the current branch
+and tag to `origin`, and publishes the gem using your local RubyGems credentials.
+The tag prefix keeps companion releases separate from Magnus releases. Use
+`bundle exec rake release:check` to run validation without tagging or publishing.
+
+Bundler's full release task expects an attached Git branch. From a Jujutsu
+checkout with detached Git HEAD, manage the bookmark and release tag separately,
+then publish the committed revision with:
+
+```sh
+bundle exec rake release:rubygem_push
+```
+
+This task runs the same validation and clean-working-copy check, then publishes
+without changing Git references. Local publishing needs no GitHub API-key secret.
+
+## GitHub Actions
+
+The [lint workflow](../.github/workflows/jiff-magnus-lint.yml) checks Standard,
+Rust formatting, and workflow YAML. The
+[test workflow](../.github/workflows/jiff-magnus-test.yml) runs the Ruby suite
+and builds the source gem on Ruby 3.2 through 4.0 and Ruby head on Linux, plus
+Ruby 3.4 and 4.0 on macOS and Ruby 4.0 on Windows. Magnus's existing Test workflow
+runs the Rust workspace tests.
+
+Run the [release workflow](../.github/workflows/jiff-magnus-release.yml) manually
+from the branch or tag you want to publish. It uses the version in
+`jiff-magnus/Cargo.toml`, lints and tests the extension, builds the source gem,
+checks installation against published Rust dependencies, and publishes it to
+RubyGems with the `RUBYGEMS_API_KEY` repository secret.
+
+Before the first release, create a RubyGems API key with the
+[Push rubygems scope](https://guides.rubygems.org/api-key-scopes/) and save it as
+the repository's `RUBYGEMS_API_KEY` Actions secret. The workflow supplies it to
+`gem push` through `GEM_HOST_API_KEY`, which RubyGems supports for CI publishing.
+Choose key settings that allow unattended pushes; a key that requires an OTP
+will still require that code. Trusted publishing is an optional later change.
+
+The required Magnus crate with `jiff-zoned` must be available on crates.io
+before the installation check can pass. This workflow publishes the Ruby gem;
+release the required Rust crates separately.

data/extconf.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("jiff_magnus/jiff_magnus") do |config|
+  config.extra_cargo_args << "--crate-type=cdylib"
+end

data/lib/jiff_magnus.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "jiff_magnus/jiff_magnus"

data/src/lib.rs

@@ -0,0 +1,276 @@
+//! Ruby constructors for Jiff timezones, using Magnus's native backing type.
+//!
+//! `require "jiff_magnus"` calls [`init`] and bundles IANA timezone data.
+//! The gem subclasses Magnus's [`JiffTimeZone`] to reuse its timezone methods.
+//! Core [`jiff::Zoned`] conversions work before this gem is initialized.
+
+use std::sync::{Mutex, OnceLock};
+
+use jiff::tz::TimeZone;
+use magnus::{
+    Error, RArray, RClass, Ruby, TypedData, Value, prelude::*, rb_sys::AsRawValue,
+    time::JiffTimeZone, typed_data::Obj, value::Opaque,
+};
+
+const CLASS_NAME: &str = "JiffTimezone";
+const AUTO_TIME_REGISTRATION_ENV: &str = "JIFF_MAGNUS_ENABLE_AUTO_TIME_REGISTRATION";
+
+struct Initialization {
+    class: Opaque<RClass>,
+    resolver: Opaque<RArray>,
+}
+
+impl Initialization {
+    fn validate_class(&self, ruby: &Ruby) -> Result<(), Error> {
+        let object = ruby.class_object();
+        if !object.funcall::<_, _, bool>("const_defined?", (CLASS_NAME, false))? {
+            return Err(conflict(ruby, "JiffTimezone initialization was removed"));
+        }
+        let class: Value = object.const_get(CLASS_NAME)?;
+        if class.as_raw() != ruby.get_inner(self.class).as_raw() {
+            return Err(conflict(ruby, "JiffTimezone initialization was replaced"));
+        }
+        Ok(())
+    }
+}
+
+static INITIALIZATION: OnceLock<Initialization> = OnceLock::new();
+// Ruby definition hooks can reenter either public entry point while it publishes
+// or restores definitions. Reject those calls before they can commit the cache.
+static INITIALIZATION_LOCK: Mutex<()> = Mutex::new(());
+
+/// Initializes `JiffTimezone` with optional automatic `Time.find_timezone` lookup.
+///
+/// When an existing `JiffTimezone` inherits from this Magnus copy's timezone
+/// class, this function reuses it and leaves its public methods untouched. It
+/// preserves an existing `Time.find_timezone`, even if the method is private.
+/// Otherwise, it adds lookup unless you set
+/// `JIFF_MAGNUS_ENABLE_AUTO_TIME_REGISTRATION` to `0` or `false`
+/// (case-insensitive) before initialization. Constructors remain available
+/// without automatic lookup. Use [`register`] to explicitly install or replace
+/// the method regardless of this setting.
+///
+/// # Errors
+///
+/// We return Ruby `LoadError` in these cases:
+///
+/// - An existing `Object::JiffTimezone` belongs to a different native
+///   implementation.
+/// - Ruby code removed or replaced `JiffTimezone` or a tracked
+///   `Time.find_timezone` method after initialization.
+/// - Initialization or registration is already in progress.
+///
+/// Ruby allocation and method errors propagate. If publishing the class or
+/// resolver fails, this function rolls back only definitions it added.
+#[cfg_attr(not(test), magnus::init(name = "jiff_magnus"))]
+pub fn init(ruby: &Ruby) -> Result<(), Error> {
+    let _guard = INITIALIZATION_LOCK.try_lock().map_err(|_| {
+        conflict(
+            ruby,
+            "timezone initialization or registration is already in progress",
+        )
+    })?;
+    if let Some(existing) = INITIALIZATION.get() {
+        existing.validate_class(ruby)?;
+        let expected: Option<Value> = ruby.get_inner(existing.resolver).entry(0)?;
+        if let Some(expected) = expected {
+            let time = ruby.class_time();
+            if !time.respond_to("find_timezone", true)? {
+                return Err(conflict(ruby, "Time.find_timezone was removed"));
+            }
+            let method: Value = time.funcall("method", ("find_timezone",))?;
+            if !method.funcall::<_, _, bool>("==", (expected,))? {
+                return Err(conflict(ruby, "Time.find_timezone was replaced"));
+            }
+        }
+        return Ok(());
+    }
+    let object = ruby.class_object();
+    let env: Value = object.const_get("ENV")?;
+    let setting: Option<String> = env.funcall("[]", (AUTO_TIME_REGISTRATION_ENV,))?;
+    let auto_register = !setting
+        .as_deref()
+        .is_some_and(|value| value == "0" || value.eq_ignore_ascii_case("false"));
+    let existing_class = if object.funcall::<_, _, bool>("const_defined?", (CLASS_NAME, false))? {
+        let value: Value = object.const_get(CLASS_NAME)?;
+        let class = RClass::from_value(value)
+            .filter(|class| class.is_inherited(JiffTimeZone::class(ruby)))
+            .ok_or_else(|| {
+                conflict(
+                    ruby,
+                    "JiffTimezone is already defined by an incompatible native implementation",
+                )
+            })?;
+        Some(class)
+    } else {
+        None
+    };
+    let time = ruby.class_time();
+
+    // Configure a new class before publishing it; never modify a reused class.
+    let class = if let Some(class) = existing_class {
+        class
+    } else {
+        // Reuse Magnus's TypedData instead of introducing a second native payload.
+        let class = RClass::new(JiffTimeZone::class(ruby))?;
+        class.undef_default_alloc_func();
+        class.define_singleton_method("find_timezone", magnus::function!(find_timezone, 1))?;
+        class.define_singleton_method("utc", magnus::function!(utc, 0))?;
+        class.define_singleton_method("unknown", magnus::function!(unknown, 0))?;
+        class.define_singleton_method("fixed", magnus::function!(fixed, 1))?;
+        class.define_singleton_method("posix", magnus::function!(posix, 1))?;
+        class.define_singleton_method("register", magnus::function!(register, 0))?;
+        class.freeze();
+        class
+    };
+    let resolver = (|| -> Result<Value, Error> {
+        if existing_class.is_none() {
+            object.const_set(CLASS_NAME, class)?;
+        }
+        if !auto_register {
+            Ok(ruby.qnil().as_value())
+        } else if time.respond_to("find_timezone", true)? {
+            time.funcall("method", ("find_timezone",))
+        } else {
+            install_resolver(ruby)
+        }
+    })();
+    let resolver = match resolver {
+        Ok(resolver) => resolver,
+        Err(error) => {
+            // The resolver installer rolls back its own changes. A class hook
+            // may instead have installed application definitions before raising.
+            if existing_class.is_none() {
+                let _ = (|| -> Result<(), Error> {
+                    if object.funcall::<_, _, bool>("const_defined?", (CLASS_NAME, false))? {
+                        let current: Value = object.const_get(CLASS_NAME)?;
+                        if current.as_raw() == class.as_raw() {
+                            object.funcall::<_, _, Value>("remove_const", (CLASS_NAME,))?;
+                        }
+                    }
+                    Ok(())
+                })();
+            }
+            return Err(error);
+        }
+    };
+    // A Ruby holder keeps the current method alive without retaining every
+    // method replaced by explicit registration.
+    let resolver = ruby.ary_new_from_values(&[resolver]);
+    ruby.gc_register_mark_object(class);
+    ruby.gc_register_mark_object(resolver);
+    INITIALIZATION
+        .set(Initialization {
+            class: class.into(),
+            resolver: resolver.into(),
+        })
+        .map_err(|_| conflict(ruby, "timezone initialization is already in progress"))?;
+    Ok(())
+}
+
+/// Replaces `Time.find_timezone` with this companion's Jiff name lookup.
+///
+/// Unlike [`init`], this explicitly overrides an existing method, including a
+/// private one, regardless of `JIFF_MAGNUS_ENABLE_AUTO_TIME_REGISTRATION`.
+/// Ruby callers use `JiffTimezone.register`. Calling this before initialization
+/// first initializes the companion.
+///
+/// # Errors
+///
+/// Returns `LoadError` if Ruby code removed or replaced the initialized class,
+/// or if initialization or registration is already in progress.
+/// Ruby errors propagate; a failed replacement restores the previous method.
+pub fn register(ruby: &Ruby) -> Result<(), Error> {
+    if INITIALIZATION.get().is_none() {
+        init(ruby)?;
+    }
+    let _guard = INITIALIZATION_LOCK.try_lock().map_err(|_| {
+        conflict(
+            ruby,
+            "timezone initialization or registration is already in progress",
+        )
+    })?;
+    let initialization = INITIALIZATION.get().expect("companion was initialized");
+    initialization.validate_class(ruby)?;
+    let method = install_resolver(ruby)?;
+    ruby.get_inner(initialization.resolver).store(0, method)
+}
+
+fn install_resolver(ruby: &Ruby) -> Result<Value, Error> {
+    let time = ruby.class_time();
+    let singleton = time.singleton_class()?;
+    let previous: Option<Value> = if time.respond_to("find_timezone", true)? {
+        Some(time.funcall("method", ("find_timezone",))?)
+    } else {
+        None
+    };
+    let mut visibility = None;
+    for (query, access) in [
+        ("public_method_defined?", "public"),
+        ("protected_method_defined?", "protected"),
+        ("private_method_defined?", "private"),
+    ] {
+        if singleton.funcall::<_, _, bool>(query, ("find_timezone", false))? {
+            visibility = Some(access);
+            break;
+        }
+    }
+    let result = (|| {
+        time.define_singleton_method("find_timezone", magnus::function!(find_timezone, 1))?;
+        time.funcall("method", ("find_timezone",))
+    })();
+    if result.is_err() {
+        let _ = singleton.funcall::<_, _, Value>("remove_method", ("find_timezone",));
+        // Removing a replacement can expose an ancestor hidden by undef_method.
+        if previous.is_none() && time.respond_to("find_timezone", true).unwrap_or(false) {
+            let _ = singleton.funcall::<_, _, Value>("undef_method", ("find_timezone",));
+        }
+        if let (Some(method), Some(access)) = (previous, visibility) {
+            // A method-added hook can raise after the old body is restored.
+            let _ = singleton.funcall::<_, _, Value>("define_method", ("find_timezone", method));
+            let _ = singleton.funcall::<_, _, Value>(access, ("find_timezone",));
+        }
+    }
+    result
+}
+
+fn conflict(ruby: &Ruby, message: &str) -> Error {
+    Error::new(ruby.exception_load_error(), message.to_owned())
+}
+
+fn wrap(ruby: &Ruby, zone: TimeZone) -> Result<Obj<JiffTimeZone>, Error> {
+    let class = INITIALIZATION
+        .get()
+        .map(|initialization| ruby.get_inner(initialization.class))
+        .ok_or_else(|| conflict(ruby, "call jiff_magnus::init before using constructors"))?;
+    let object = ruby.obj_wrap_as(JiffTimeZone::new(zone), class);
+    object.freeze();
+    Ok(object)
+}
+
+fn find_timezone(ruby: &Ruby, name: String) -> Result<Option<Obj<JiffTimeZone>>, Error> {
+    TimeZone::get(&name)
+        .ok()
+        .map(|zone| wrap(ruby, zone))
+        .transpose()
+}
+
+fn utc(ruby: &Ruby) -> Result<Obj<JiffTimeZone>, Error> {
+    wrap(ruby, TimeZone::UTC)
+}
+
+fn unknown(ruby: &Ruby) -> Result<Obj<JiffTimeZone>, Error> {
+    wrap(ruby, TimeZone::unknown())
+}
+
+fn fixed(ruby: &Ruby, seconds: i32) -> Result<Obj<JiffTimeZone>, Error> {
+    let offset = jiff::tz::Offset::from_seconds(seconds)
+        .map_err(|err| Error::new(ruby.exception_arg_error(), err.to_string()))?;
+    wrap(ruby, TimeZone::fixed(offset))
+}
+
+fn posix(ruby: &Ruby, rule: String) -> Result<Obj<JiffTimeZone>, Error> {
+    let zone = TimeZone::posix(&rule)
+        .map_err(|err| Error::new(ruby.exception_arg_error(), err.to_string()))?;
+    wrap(ruby, zone)
+}

data/tmp/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: jiff-magnus
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Erick Guan
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.130
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.130
+description: A Magnus companion providing JiffTimezone constructors and bundled IANA
+  timezone data for Ruby Time.
+executables: []
+extensions:
+- extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Cargo.toml
+- LICENSE
+- README.md
+- extconf.rb
+- lib/jiff_magnus.rb
+- src/lib.rs
+- tmp/.gitignore
+homepage: https://github.com/matsadler/magnus
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/matsadler/magnus/tree/main/jiff-magnus
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Jiff timezone rules and bundled timezone data for Ruby Time.
+test_files: []