active_record_in_time_scope 0.1.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b8fa7d1397cbad1a682309ad55bee699deabf406ea542ee48182e7880c87aa48
+  data.tar.gz: 8459cdc187fb8c7eb3d8a158e0d16ae2209a3664ba64d6a70c08c3e3908856b3
+SHA512:
+  metadata.gz: ba9ca47a5b010da08753bb84ea270f82b8d1b0fb056d71962530370240c88b803b2739db51f844a75efa9d70b6b4bc938f3a0898116c006ea240b76d3fd34401
+  data.tar.gz: b9917fc20bc4d32e41d1e7466f56d4c766c86e10edde9d0a08f6563954120ebc63cf4d797448b27434b1812975e253aa03f44ba9bc9ce7fedab442770e64fd38

data/.rubocop.yml

@@ -0,0 +1,47 @@
+AllCops:
+  TargetRubyVersion: 4.0
+  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: 40
+
+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
+
+Style/OneClassPerFile:
+  Exclude:
+    - "spec/support/create_test_database.rb"
+
+Gemspec/DevelopmentDependencies:
+  EnforcedStyle: gemspec

data/.rulesync/commands/translate-readme.md

@@ -0,0 +1,46 @@
+---
+targets:
+  - claudecode
+description: Translate README.md and sync docs for all languages (ja, zh, fr, de)
+---
+
+# Translate Documentation
+
+Translate and sync documentation for multiple languages.
+
+## Instructions
+
+### 1. Sync English Documentation
+
+1. Read the current `README.md`
+2. Copy content to `docs/src/index.md`:
+   - Remove the language links line (`[English](README.md) | [日本語]...`)
+   - Keep everything else
+
+### 2. Translate to Other Languages
+
+For each language directory (`docs/ja/`, `docs/zh/`, `docs/fr/`, `docs/de/`):
+
+1. Translate `docs/src/index.md` to `docs/{lang}/index.md`
+2. Translate `docs/src/point-system.md` to `docs/{lang}/point-system.md`
+3. Translate `docs/src/user-name-history.md` to `docs/{lang}/user-name-history.md`
+4. Update `docs/{lang}/SUMMARY.md` with translated titles
+
+### 3. Translation Guidelines
+
+For each translation:
+- Keep all code blocks unchanged
+- Translate all text content naturally (not literal translation)
+- Keep the same markdown structure
+- Keep URLs and links unchanged
+- Do NOT include language links in docs files
+- Translate headings and navigation text in SUMMARY.md
+
+### 4. Language Codes
+
+- `ja` - Japanese (日本語)
+- `zh` - Chinese (中文)
+- `fr` - French (Français)
+- `de` - German (Deutsch)
+
+$ARGUMENTS

data/.rulesync/rules/project.md

@@ -0,0 +1,87 @@
+---
+targets:
+  - claudecode
+root: true
+---
+
+# 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.0+ 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:
+
+**Primary scopes (records in time window):**
+- `Model.in_time`, `Model.in_time(timestamp)` - class scope
+- `instance.in_time?`, `instance.in_time?(timestamp)` - instance method
+
+**Inverse scopes (records outside time window):**
+- `Model.before_in_time` - records not yet started (`start_at > time`)
+- `Model.after_in_time` - records already ended (`end_at <= time`)
+- `Model.out_of_time` - records outside window (before OR after)
+- Corresponding instance methods: `before_in_time?`, `after_in_time?`, `out_of_time?`
+
+**Additional scopes for start-only/end-only patterns:**
+- `Model.latest_in_time(:foreign_key)` - latest record per FK (for `has_one`)
+- `Model.earliest_in_time(:foreign_key)` - earliest record per FK
+
+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.
+
+Named scopes generate all methods with the scope name:
+- `in_time_scope :published` → `in_time_published`, `before_in_time_published`, `after_in_time_published`, `out_of_time_published`
+
+## 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/CHANGELOG.md

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

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,191 @@
+# InTimeScope
+
+[English](README.md) | [日本語](docs/ja/index.md) | [中文](docs/zh/index.md) | [Français](docs/fr/index.md) | [Deutsch](docs/de/index.md)
+
+Are you writing this every time in Rails?
+
+```ruby
+# Before
+Event.where("start_at <= ? AND (end_at IS NULL OR end_at > ?)", Time.current, Time.current)
+
+# After
+class Event < ActiveRecord::Base
+  in_time_scope
+end
+
+Event.in_time
+```
+
+That's it. One line of DSL, zero raw SQL in your models.
+
+**This is a simple, thin gem that just provides scopes. No learning curve required.**
+
+## Why This Gem?
+
+This gem exists to:
+
+- **Keep time-range logic consistent** across your entire codebase
+- **Avoid copy-paste SQL** that's easy to get wrong
+- **Make time a first-class domain concept** with named scopes like `in_time_published`
+- **Auto-detect nullability** from your schema for optimized queries
+
+## Recommended For
+
+- New Rails applications with validity periods
+- Models with `start_at` / `end_at` columns
+- Teams that want consistent time logic without scattered `where` clauses
+
+## Installation
+
+```bash
+bundle add in_time_scope
+```
+
+## Quick Start
+
+```ruby
+class Event < ActiveRecord::Base
+  in_time_scope
+end
+
+# Class scope
+Event.in_time                          # Records active now
+Event.in_time(Time.parse("2024-06-01")) # Records active at specific time
+
+# Instance method
+event.in_time?                          # Is this record active now?
+event.in_time?(some_time)               # Was it active at that time?
+```
+
+## Features
+
+### Auto-Optimized SQL
+
+The gem reads your schema and generates the right SQL:
+
+```ruby
+# NULL-allowed columns → NULL-aware query
+WHERE (start_at IS NULL OR start_at <= ?) AND (end_at IS NULL OR end_at > ?)
+
+# NOT NULL columns → simple query
+WHERE start_at <= ? AND end_at > ?
+```
+
+### Named Scopes
+
+Multiple time windows per model:
+
+```ruby
+class Article < ActiveRecord::Base
+  in_time_scope :published   # → Article.in_time_published
+  in_time_scope :featured    # → Article.in_time_featured
+end
+```
+
+### Custom Columns
+
+```ruby
+class Campaign < ActiveRecord::Base
+  in_time_scope start_at: { column: :available_at },
+                end_at: { column: :expired_at }
+end
+```
+
+### Start-Only Pattern (Version History)
+
+For records where each row is valid until the next one:
+
+```ruby
+class Price < ActiveRecord::Base
+  in_time_scope start_at: { null: false }, end_at: { column: nil }
+end
+
+# Bonus: efficient has_one with NOT EXISTS
+class User < ActiveRecord::Base
+  has_one :current_price, -> { latest_in_time(:user_id) }, class_name: "Price"
+end
+
+User.includes(:current_price)  # No N+1, fetches only latest per user
+```
+
+### End-Only Pattern (Expiration)
+
+For records that are active until they expire:
+
+```ruby
+class Coupon < ActiveRecord::Base
+  in_time_scope start_at: { column: nil }, end_at: { null: false }
+end
+```
+
+### Inverse Scopes
+
+Query records outside the time window:
+
+```ruby
+# Records not yet started (start_at > time)
+Event.before_in_time
+event.before_in_time?
+
+# Records already ended (end_at <= time)
+Event.after_in_time
+event.after_in_time?
+
+# Records outside time window (before OR after)
+Event.out_of_time
+event.out_of_time?  # Logical inverse of in_time?
+```
+
+Works with named scopes too:
+
+```ruby
+Article.before_in_time_published  # Not yet published
+Article.after_in_time_published   # Publication ended
+Article.out_of_time_published     # Not currently published
+```
+
+## Options Reference
+
+| Option | Default | Description | Example |
+| --- | --- | --- | --- |
+| `scope_name` (1st arg) | `:in_time` | Named scope like `in_time_published` | `in_time_scope :published` |
+| `start_at: { column: }` | `:start_at` | Custom column name, `nil` to disable | `start_at: { column: :available_at }` |
+| `end_at: { column: }` | `:end_at` | Custom column name, `nil` to disable | `end_at: { column: nil }` |
+| `start_at: { null: }` | auto-detect | Force NULL handling | `start_at: { null: false }` |
+| `end_at: { null: }` | auto-detect | Force NULL handling | `end_at: { null: true }` |
+
+## Acknowledgements
+
+Inspired by [onk/shibaraku](https://github.com/onk/shibaraku). This gem extends the concept with:
+
+- Schema-aware NULL handling for optimized queries
+- Multiple named scopes per model
+- Start-only / End-only patterns
+- `latest_in_time` / `earliest_in_time` for efficient `has_one` associations
+- Inverse scopes: `before_in_time`, `after_in_time`, `out_of_time`
+
+## Development
+
+```bash
+# Install dependencies
+bin/setup
+
+# Run tests
+bundle exec rspec
+
+# Run linting
+bundle exec rubocop
+
+# Generate CLAUDE.md (for AI coding assistants)
+npx rulesync generate
+```
+
+This project uses [rulesync](https://github.com/dyoshikawa/rulesync) to manage AI assistant rules. Edit `.rulesync/rules/*.md` and run `npx rulesync generate` to update `CLAUDE.md`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/kyohah/in_time_scope).
+
+## License
+
+MIT License

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/Steepfile

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Steepfile for InTimeScope type checking
+
+target :lib do
+  signature "sig"
+
+  check "lib"
+
+  # Use RBS collection for external gem types
+  collection_config "rbs_collection.yaml"
+
+  # Configure libraries
+  library "time"
+
+  # Ignore implementation details that use ActiveRecord internals
+  # The public API is properly typed, but internal methods use
+  # dynamic ActiveRecord features that are hard to type statically
+  configure_code_diagnostics do |hash|
+    # Allow untyped method calls for ActiveRecord dynamic methods
+    hash[Steep::Diagnostic::Ruby::NoMethod] = :hint
+    hash[Steep::Diagnostic::Ruby::UnknownInstanceVariable] = :hint
+    hash[Steep::Diagnostic::Ruby::RequiredBlockMissing] = :hint
+  end
+end

data/docs/book.toml

@@ -0,0 +1,14 @@
+[book]
+title = "InTimeScope"
+authors = ["kyohah"]
+language = "en"
+src = "src"
+
+[build]
+build-dir = "book"
+
+[output.html]
+default-theme = "light"
+preferred-dark-theme = "navy"
+git-repository-url = "https://github.com/kyohah/in_time_scope"
+edit-url-template = "https://github.com/kyohah/in_time_scope/edit/main/docs/{path}"

data/docs/de/SUMMARY.md

@@ -0,0 +1,5 @@
+# Inhaltsverzeichnis
+
+- [Einführung](./index.md)
+- [Punktesystem mit Ablaufdatum](./point-system.md)
+- [Benutzernamen-Historie](./user-name-history.md)