in_time_scope 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: eee76cde212cee461aa7b915b048c5479bc1adc82faa1a57fc4d10e136806eb6
+  data.tar.gz: b6de2422411c951e2e1cf3029498755b77c9de73731ed9e24d3d20c0df612d79
+SHA512:
+  metadata.gz: 9d9daa7dc0815efde3c0d6a0d6231da6799526fa17be1c96bc22cb76f460ce7e4c84f40ae449760a5e24e86177632b174c94ecf13ec0d3240cae9c4a39ad5721
+  data.tar.gz: 337490e629eca19edec0fe0615ee895f67e475258281a173c61e10cf8014a4f185ae72c48fbc07065d7ae29c0b6e9016b547827b83556a4d8c6be3c79c95ec04

data/.rubocop.yml

@@ -0,0 +1,43 @@
+AllCops:
+  TargetRubyVersion: 3.1
+  NewCops: enable
+  SuggestExtensions: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/Lambda:
+  EnforcedStyle: literal
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 35
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Metrics/BlockLength:
+  Max: 30
+  Exclude:
+    - "spec/**/*"
+    - "*.gemspec"
+
+Layout/LineLength:
+  Max: 140
+
+Style/Documentation:
+  Enabled: false
+
+Gemspec/DevelopmentDependencies:
+  EnforcedStyle: gemspec

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-01-24
+
+- Initial release

data/CLAUDE.md

@@ -0,0 +1,71 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+InTimeScope is a Ruby gem that adds time-window scopes to ActiveRecord models. It provides a convenient way to query records that fall within specific time periods (between `start_at` and `end_at` timestamps), with support for nullable columns, custom column names, and multiple scopes per model.
+
+## Commands
+
+```bash
+# Install dependencies
+bin/setup
+
+# Run all checks (linting + tests)
+bundle exec rake
+
+# Run tests only
+bundle exec rspec
+
+# Run a single test file
+bundle exec rspec spec/in_time_scope_spec.rb
+
+# Run a specific test by line number
+bundle exec rspec spec/in_time_scope_spec.rb:10
+
+# Run linting only
+bundle exec rubocop
+
+# Auto-fix linting issues
+bundle exec rubocop -a
+
+# Interactive console with gem loaded
+bin/console
+
+# Install gem locally
+bundle exec rake install
+```
+
+## Code Style
+
+- Ruby 3.1+ required
+- Use double-quoted strings (enforced by RuboCop)
+- All files must have `# frozen_string_literal: true` header
+
+## Architecture
+
+Entry point is `lib/in_time_scope.rb` which defines the `InTimeScope` module. When included in an ActiveRecord model, it provides the `in_time_scope` class method that generates:
+
+- Class scope methods: `Model.in_time`, `Model.in_time(timestamp)`
+- Instance methods: `instance.in_time?`, `instance.in_time?(timestamp)`
+
+The gem auto-detects column nullability from the database schema to generate optimized SQL queries (simpler queries for NOT NULL columns, NULL-aware queries otherwise).
+
+Key configuration options for `in_time_scope`:
+- First argument: scope name (default: `:in_time`)
+- `start_at: { column: Symbol|nil, null: Boolean }` - start column config
+- `end_at: { column: Symbol|nil, null: Boolean }` - end column config
+
+Setting `column: nil` disables that boundary, enabling start-only (history) or end-only (expiration) patterns.
+
+## Test Structure
+
+Tests use RSpec with SQLite3 in-memory database. Test models are defined in `spec/support/create_test_database.rb`:
+
+- `Event` - basic nullable time window
+- `Campaign` - non-nullable time window
+- `Promotion` - custom column names
+- `Article` - multiple scopes
+- `History` - start-only pattern
+- `Coupon` - end-only pattern

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 kyohah
+
+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,269 @@
+# InTimeScope
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/in_time_scope`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add in_time_scope
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install in_time_scope
+```
+
+## Usage
+
+### Basic: Nullable Time Window
+Use the defaults (`start_at` / `end_at`) even when the columns allow `NULL`.
+
+```ruby
+create_table :events do |t|
+  t.datetime :start_at, null: true
+  t.datetime :end_at, null: true
+
+  t.timestamps
+end
+
+class Event < ActiveRecord::Base
+  include InTimeScope
+
+  # Uses start_at / end_at by default
+  in_time_scope
+end
+
+Event.in_time
+# => SELECT "events".* FROM "events" WHERE ("events"."start_at" IS NULL OR "events"."start_at" <= '2026-01-24 19:50:05.738232') AND ("events"."end_at" IS NULL OR "events"."end_at" > '2026-01-24 19:50:05.738232') /* loading for pp */ LIMIT $1  [["LIMIT", 11]]
+
+# Check at a specific time
+Event.in_time(Time.parse("2024-06-01 12:00:00"))
+# => SELECT "events".* FROM "events" WHERE ("events"."start_at" IS NULL OR "events"."start_at" <= '2024-06-01 12:00:00.000000') AND ("events"."end_at" IS NULL OR "events"."end_at" > '2024-06-01 12:00:00.000000') /* loading for pp */ LIMIT $1  [["LIMIT", 11]]
+
+# Is the current time within the window?
+event = Event.first
+event.in_time?
+#=> true or false
+
+# Check any arbitrary timestamp
+event.in_time?(Time.parse("2024-06-01 12:00:00"))
+#=> true or false
+```
+
+### Basic: Non-Nullable Time Window
+When both timestamps are required (no `NULL`s), the generated query is simpler and faster.
+
+```ruby
+create_table :events do |t|
+  t.datetime :start_at, null: false
+  t.datetime :end_at, null: false
+
+  t.timestamps
+end
+
+# Column metadata is read when Rails boots; SQL is optimized for NOT NULL columns.
+Event.in_time
+# => SELECT "events".* FROM "events" WHERE ("events"."start_at" <= '2026-01-24 19:50:05.738232') AND ("events"."end_at" > '2026-01-24 19:50:05.738232') /* loading for pp */ LIMIT $1  [["LIMIT", 11]]
+
+# Check at a specific time
+Event.in_time(Time.parse("2024-06-01 12:00:00"))
+# => SELECT "events".* FROM "events" WHERE ("events"."start_at" <= '2024-06-01 12:00:00.000000') AND ("events"."end_at" > '2024-06-01 12:00:00.000000') /* loading for pp */ LIMIT $1  [["LIMIT", 11]]
+
+class Event < ActiveRecord::Base
+  include InTimeScope
+
+  # Explicitly mark columns as NOT NULL (even if the DB allows NULL)
+  in_time_scope start_at: { null: false }, end_at: { null: false }
+end
+```
+
+### Options Reference
+Use these options in `in_time_scope` to customize column behavior.
+
+| Option | Applies to | Type | Default | Description | Example |
+| --- | --- | --- | --- | --- | --- |
+| `:scope_name` (1st arg) | in_time | `Symbol` | `:in_time` | Creates a named scope like `published_in_time` | `in_time_scope :published` |
+| `start_at: { column: ... }` | start_at | `Symbol` / `nil` | `:start_at` (or `:"<scope>_start_at"` when `:scope_name` is set) | Use a custom column name; set `nil` to disable `start_at` | `start_at: { column: :available_at }` |
+| `end_at: { column: ... }` | end_at | `Symbol` / `nil` | `:end_at` (or `:"<scope>_end_at"` when `:scope_name` is set) | Use a custom column name; set `nil` to disable `end_at` | `end_at: { column: nil }` |
+| `start_at: { null: ... }` | start_at | `true/false` | auto (schema) | Force NULL-aware vs NOT NULL behavior | `start_at: { null: false }` |
+| `end_at: { null: ... }` | end_at | `true/false` | auto (schema) | Force NULL-aware vs NOT NULL behavior | `end_at: { null: true }` |
+
+### Alternative: Start-Only History (No `end_at`)
+Use this when periods never overlap and you want exactly one "current" row.
+
+Assumptions:
+- `start_at` is always present
+- periods never overlap (validated)
+- the latest row is the current one
+
+If your table still has an `end_at` column but you want to ignore it, disable it via options:
+
+```ruby
+class Event < ActiveRecord::Base
+  include InTimeScope
+
+  # Ignore end_at even if the column exists
+  in_time_scope start_at: { null: false }, end_at: { column: nil }
+end
+
+Event.in_time(Time.parse("2024-06-01 12:00:00"))
+# => SELECT "events".* FROM "events" WHERE "events"."start_at" <= '2024-06-01 12:00:00.000000' ORDER BY "events"."start_at" DESC
+
+# Use .first to get the most recent single record
+Event.in_time.first
+# => SELECT "events".* FROM "events" WHERE "events"."start_at" <= '...' ORDER BY "events"."start_at" DESC LIMIT 1
+```
+
+With no `end_at`, each row implicitly ends at the next row's `start_at`.
+The scope returns all matching records ordered by `start_at DESC`, so:
+- Use `.first` for a single record
+- Use with `has_one` associations for per-parent record selection
+
+Boundary behavior is stable:
+- `start_at <= NOW()` picks the newest row whose start has passed
+
+Recommended index:
+
+```sql
+CREATE INDEX index_events_on_start_at ON events (start_at);
+```
+
+### Alternative: End-Only Expiration (No `start_at`)
+Use this when a record is active immediately and expires at `end_at`.
+
+Assumptions:
+- `start_at` is not used (implicit "always active")
+- `end_at` can be `NULL` for "never expires"
+
+If your table still has a `start_at` column but you want to ignore it, disable it via options:
+
+```ruby
+class Event < ActiveRecord::Base
+  include InTimeScope
+
+  # Ignore start_at and only use end_at
+  in_time_scope start_at: { column: nil }, end_at: { null: true }
+end
+
+Event.in_time(Time.parse("2024-06-01 12:00:00"))
+# => SELECT "events".* FROM "events" WHERE ("events"."end_at" IS NULL OR "events"."end_at" > '2024-06-01 12:00:00.000000') /* loading for pp */ LIMIT $1  [["LIMIT", 11]]
+```
+
+To fetch active rows:
+
+```sql
+SELECT *
+FROM events
+WHERE end_at IS NULL OR end_at > NOW();
+```
+
+Recommended index:
+
+```sql
+CREATE INDEX index_events_on_end_at ON events (end_at);
+```
+
+### Advanced: Custom Columns and Multiple Scopes
+Customize which columns are used and define more than one time window per model.
+
+```ruby
+create_table :events do |t|
+  t.datetime :available_at, null: true
+  t.datetime :expired_at, null: true
+  t.datetime :publish_start_at, null: false
+  t.datetime :publish_end_at, null: false
+
+  t.timestamps
+end
+
+class Event < ActiveRecord::Base
+  include InTimeScope
+
+  # Use different column names
+  in_time_scope start_at: { column: :available_at }, end_at: { column: :expired_at }
+
+  # Define an additional scope
+  in_time_scope :published, start_at: { column: :publish_start_at, null: false }, end_at: { column: :publish_end_at, null: false }
+end
+
+Event.in_time
+# => uses available_at / expired_at
+
+Event.published_in_time
+# => uses publish_start_at / publish_end_at
+```
+
+### Using with `has_one` Associations
+
+The start-only pattern provides two scopes for `has_one` associations:
+
+#### Simple approach: `in_time` + `order`
+
+`in_time` provides WHERE only. Add `order` externally:
+
+```ruby
+class Price < ActiveRecord::Base
+  include InTimeScope
+  belongs_to :user
+
+  in_time_scope start_at: { null: false }, end_at: { column: nil }
+end
+
+class User < ActiveRecord::Base
+  has_many :prices
+
+  # in_time is WHERE only, add order externally
+  has_one :current_price,
+          -> { in_time.order(start_at: :desc) },
+          class_name: "Price"
+end
+```
+
+This works but loads all matching records into memory when using `includes`.
+
+#### Efficient approach: `latest_in_time` (NOT EXISTS) - Recommended
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :prices
+
+  # Uses NOT EXISTS subquery - only loads the latest record per user
+  has_one :current_price,
+          -> { latest_in_time(:user_id) },
+          class_name: "Price"
+end
+
+# Direct access
+user.current_price
+# => Returns the most recent price where start_at <= Time.current
+
+# Efficient with includes (only fetches latest record per user from DB)
+User.includes(:current_price).each do |user|
+  puts user.current_price&.amount
+end
+```
+
+The `latest_in_time(:foreign_key)` scope uses a `NOT EXISTS` subquery to filter at the database level, avoiding loading unnecessary records into memory.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kyohah/in_time_scope. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/kyohah/in_time_scope/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the InTimeScope project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/kyohah/in_time_scope/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+require "rspec/core/rake_task"
+
+RuboCop::RakeTask.new
+RSpec::Core::RakeTask.new(:spec)
+
+task default: %i[rubocop spec]

data/lib/in_time_scope/version.rb

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

data/lib/in_time_scope.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "active_record"
+require_relative "in_time_scope/version"
+
+module InTimeScope
+  class Error < StandardError; end
+
+  def self.included(model)
+    model.extend ClassMethods
+  end
+
+  module ClassMethods
+    def in_time_scope(scope_name = nil, start_at: {}, end_at: {})
+      scope_name ||= :in_time
+      scope_suffix = scope_name == :in_time ? "" : "_#{scope_name}"
+
+      start_config = normalize_config(start_at, :"start_at#{scope_suffix}", :start_at)
+      end_config = normalize_config(end_at, :"end_at#{scope_suffix}", :end_at)
+
+      define_scope_methods(scope_name, start_config, end_config)
+    end
+
+    private
+
+    def normalize_config(config, default_column, fallback_column)
+      return { column: nil, null: true } if config[:column].nil? && config.key?(:column)
+
+      column = config[:column] || default_column
+      column = fallback_column unless column_names.include?(column.to_s)
+      column = nil unless column_names.include?(column.to_s)
+
+      null = config.key?(:null) ? config[:null] : column_nullable?(column)
+
+      { column: column, null: null }
+    end
+
+    def column_nullable?(column_name)
+      return true if column_name.nil?
+
+      col = columns_hash[column_name.to_s]
+      col ? col.null : true
+    end
+
+    def define_scope_methods(scope_name, start_config, end_config)
+      method_name = scope_name == :in_time ? :in_time : :"#{scope_name}_in_time"
+      instance_method_name = :"#{method_name}?"
+
+      start_column = start_config[:column]
+      start_null = start_config[:null]
+      end_column = end_config[:column]
+      end_null = end_config[:null]
+
+      # Define class-level scope
+      if start_column.nil? && end_column.nil?
+        # Both disabled - return all
+        scope method_name, ->(_time = Time.current) { all }
+      elsif end_column.nil?
+        # Start-only pattern (history tracking)
+        define_start_only_scope(method_name, start_column, start_null)
+      elsif start_column.nil?
+        # End-only pattern (expiration)
+        define_end_only_scope(method_name, end_column, end_null)
+      else
+        # Both start and end
+        define_full_scope(method_name, start_column, start_null, end_column, end_null)
+      end
+
+      # Define instance method
+      define_instance_method(instance_method_name, start_column, start_null, end_column, end_null)
+    end
+
+    def define_start_only_scope(method_name, start_column, start_null)
+      # Simple scope - WHERE only, no ORDER BY
+      # Users can add .order(start_at: :desc) externally if needed
+      if start_null
+        scope method_name, ->(time = Time.current) {
+          where(arel_table[start_column].eq(nil).or(arel_table[start_column].lteq(time)))
+        }
+      else
+        scope method_name, ->(time = Time.current) {
+          where(arel_table[start_column].lteq(time))
+        }
+      end
+
+      # Efficient scope for has_one + includes using NOT EXISTS subquery
+      # Usage: has_one :current_price, -> { latest_in_time(:user_id) }, class_name: 'Price'
+      define_latest_scope(method_name, start_column, start_null)
+    end
+
+    def define_latest_scope(method_name, start_column, start_null)
+      latest_method_name = method_name == :in_time ? :latest_in_time : :"latest_#{method_name}_in_time"
+      tbl = table_name
+      col = start_column
+
+      # NOT EXISTS approach: select records where no later record exists for the same foreign key
+      # SELECT * FROM prices p1 WHERE start_at <= ? AND NOT EXISTS (
+      #   SELECT 1 FROM prices p2 WHERE p2.user_id = p1.user_id
+      #   AND p2.start_at <= ? AND p2.start_at > p1.start_at
+      # )
+      scope latest_method_name, ->(foreign_key, time = Time.current) {
+        fk = foreign_key
+
+        not_exists_sql = if start_null
+                           <<~SQL.squish
+                             NOT EXISTS (
+                               SELECT 1 FROM #{tbl} p2
+                               WHERE p2.#{fk} = #{tbl}.#{fk}
+                               AND (p2.#{col} IS NULL OR p2.#{col} <= ?)
+                               AND (p2.#{col} IS NULL OR p2.#{col} > #{tbl}.#{col} OR #{tbl}.#{col} IS NULL)
+                               AND p2.id != #{tbl}.id
+                             )
+                           SQL
+                         else
+                           <<~SQL.squish
+                             NOT EXISTS (
+                               SELECT 1 FROM #{tbl} p2
+                               WHERE p2.#{fk} = #{tbl}.#{fk}
+                               AND p2.#{col} <= ?
+                               AND p2.#{col} > #{tbl}.#{col}
+                             )
+                           SQL
+                         end
+
+        base_condition = if start_null
+                           where(arel_table[col].eq(nil).or(arel_table[col].lteq(time)))
+                         else
+                           where(arel_table[col].lteq(time))
+                         end
+
+        base_condition.where(not_exists_sql, time)
+      }
+    end
+
+    def define_end_only_scope(method_name, end_column, end_null)
+      if end_null
+        scope method_name, ->(time = Time.current) {
+          where(arel_table[end_column].eq(nil).or(arel_table[end_column].gt(time)))
+        }
+      else
+        scope method_name, ->(time = Time.current) {
+          where(arel_table[end_column].gt(time))
+        }
+      end
+    end
+
+    def define_full_scope(method_name, start_column, start_null, end_column, end_null)
+      scope method_name, ->(time = Time.current) {
+        start_condition = if start_null
+                            arel_table[start_column].eq(nil).or(arel_table[start_column].lteq(time))
+                          else
+                            arel_table[start_column].lteq(time)
+                          end
+
+        end_condition = if end_null
+                          arel_table[end_column].eq(nil).or(arel_table[end_column].gt(time))
+                        else
+                          arel_table[end_column].gt(time)
+                        end
+
+        where(start_condition).where(end_condition)
+      }
+    end
+
+    def define_instance_method(method_name, start_column, start_null, end_column, end_null)
+      define_method(method_name) do |time = Time.current|
+        start_ok = if start_column.nil?
+                     true
+                   elsif start_null
+                     send(start_column).nil? || send(start_column) <= time
+                   else
+                     send(start_column) <= time
+                   end
+
+        end_ok = if end_column.nil?
+                   true
+                 elsif end_null
+                   send(end_column).nil? || send(end_column) > time
+                 else
+                   send(end_column) > time
+                 end
+
+        start_ok && end_ok
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  include InTimeScope
+end

data/sig/in_time_scope.rbs

@@ -0,0 +1,4 @@
+module InTimeScope
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: in_time_scope
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- kyohah
+bindir: exe
+cert_chain: []
+date: 2026-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: InTimeScope provides time-window scopes for ActiveRecord models.
+email:
+- 3257272+kyohah@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- CLAUDE.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/in_time_scope.rb
+- lib/in_time_scope/version.rb
+- sig/in_time_scope.rbs
+homepage: https://github.com/kyohah/in_time_scope
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/kyohah/in_time_scope
+  source_code_uri: https://github.com/kyohah/in_time_scope
+  changelog_uri: https://github.com/kyohah/in_time_scope/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Add time-window scopes to ActiveRecord models
+test_files: []