in_time_scope 0.1.5 → 0.1.7

data/lib/in_time_scope/class_methods.rb

@@ -21,8 +21,6 @@ module InTimeScope
     # @option end_at [Boolean] :null Whether the column allows NULL values
     #   (auto-detected from schema if not specified)
     #
-    # @param prefix [Boolean] If true, creates +<scope_name>_in_time+ instead of +in_time_<scope_name>+
-    #
     # @raise [ColumnNotFoundError] When a specified column doesn't exist (at class load time)
     # @raise [ConfigurationError] When both columns are nil, or when using start-only/end-only
     #   pattern with a nullable column (at scope call time)
@@ -56,7 +54,7 @@ module InTimeScope
     #   in_time_scope start_at: { column: nil }, end_at: { null: false }
     #   # Also creates: Model.latest_in_time(:foreign_key), Model.earliest_in_time(:foreign_key)
     #
-    def in_time_scope(scope_name = :in_time, start_at: {}, end_at: {}, prefix: false)
+    def in_time_scope(scope_name = :in_time, start_at: {}, end_at: {})
       table_column_hash = columns_hash
       time_column_prefix = scope_name == :in_time ? "" : "#{scope_name}_"
 
@@ -66,10 +64,8 @@ module InTimeScope
       start_at_null = fetch_null_option(start_at, start_at_column, table_column_hash)
       end_at_null = fetch_null_option(end_at, end_at_column, table_column_hash)
 
-      scope_method_name = method_name(scope_name, prefix)
-
       define_scope_methods(
-        scope_method_name,
+        scope_name == :in_time ? "" : "_#{scope_name}",
         start_at_column: start_at_column,
         start_at_null: start_at_null,
         end_at_column: end_at_column,
@@ -97,96 +93,97 @@ module InTimeScope
       column_info.null
     end
 
-    # Generates the method name for the scope
-    #
-    # @param scope_name [Symbol] The scope name
-    # @param prefix [Boolean] Whether to use prefix style
-    # @return [Symbol] The generated method name
-    # @api private
-    def method_name(scope_name, prefix)
-      return :in_time if scope_name == :in_time
-
-      prefix ? "#{scope_name}_in_time" : "in_time_#{scope_name}"
-    end
-
     # Defines the appropriate scope methods based on configuration
     #
-    # @param scope_method_name [Symbol] The name of the scope method to create
+    # @param suffix [String] The suffix for method names ("" or "_#{scope_name}")
     # @param start_at_column [Symbol, nil] Start column name
     # @param start_at_null [Boolean, nil] Whether start column allows NULL
     # @param end_at_column [Symbol, nil] End column name
     # @param end_at_null [Boolean, nil] Whether end column allows NULL
     # @return [void]
     # @api private
-    def define_scope_methods(scope_method_name, start_at_column:, start_at_null:, end_at_column:, end_at_null:)
+    def define_scope_methods(suffix, start_at_column:, start_at_null:, end_at_column:, end_at_null:)
       # Define class-level scope and instance method
       if start_at_column.nil? && end_at_column.nil?
-        define_error_scope_and_method(scope_method_name,
+        define_error_scope_and_method(suffix,
                                       "At least one of start_at or end_at must be specified")
       elsif end_at_column.nil?
         # Start-only pattern (history tracking) - requires non-nullable column
         if start_at_null
-          define_error_scope_and_method(scope_method_name,
+          define_error_scope_and_method(suffix,
                                         "Start-only pattern requires non-nullable column. " \
                                         "Set `start_at: { null: false }` or add an end_at column")
         else
-          define_start_only_scope(scope_method_name, start_at_column)
-          define_instance_method(scope_method_name, start_at_column, start_at_null, end_at_column, end_at_null)
+          define_start_only_scope(suffix, start_at_column)
+          define_instance_method(suffix, start_at_column, start_at_null, end_at_column, end_at_null)
+          define_latest_one_scope(suffix, start_at_column)
+          define_earliest_one_scope(suffix, start_at_column)
+          define_before_scope(suffix, start_at_column, start_at_null)
+          define_after_scope(suffix, end_at_column, end_at_null)
+          define_out_of_time_scope(suffix)
         end
       elsif start_at_column.nil?
         # End-only pattern (expiration) - requires non-nullable column
         if end_at_null
-          define_error_scope_and_method(scope_method_name,
+          define_error_scope_and_method(suffix,
                                         "End-only pattern requires non-nullable column. " \
                                         "Set `end_at: { null: false }` or add a start_at column")
         else
-          define_end_only_scope(scope_method_name, end_at_column)
-          define_instance_method(scope_method_name, start_at_column, start_at_null, end_at_column, end_at_null)
+          define_end_only_scope(suffix, end_at_column)
+          define_instance_method(suffix, start_at_column, start_at_null, end_at_column, end_at_null)
+          define_latest_one_scope(suffix, end_at_column)
+          define_earliest_one_scope(suffix, end_at_column)
+          define_before_scope(suffix, start_at_column, start_at_null)
+          define_after_scope(suffix, end_at_column, end_at_null)
+          define_out_of_time_scope(suffix)
         end
       else
         # Both start and end
-        define_full_scope(scope_method_name, start_at_column, start_at_null, end_at_column, end_at_null)
-        define_instance_method(scope_method_name, start_at_column, start_at_null, end_at_column, end_at_null)
+        define_full_scope(suffix, start_at_column, start_at_null, end_at_column, end_at_null)
+        define_instance_method(suffix, start_at_column, start_at_null, end_at_column, end_at_null)
+        define_before_scope(suffix, start_at_column, start_at_null)
+        define_after_scope(suffix, end_at_column, end_at_null)
+        define_out_of_time_scope(suffix)
       end
     end
 
     # Defines a scope and instance method that raise ConfigurationError
     #
-    # @param scope_method_name [Symbol] The name of the scope method
+    # @param suffix [String] The suffix for method names
     # @param message [String] The error message
     # @return [void]
     # @api private
-    def define_error_scope_and_method(scope_method_name, message)
-      err_message = message
-
-      scope scope_method_name, ->(_time = Time.current) {
-        raise InTimeScope::ConfigurationError, err_message
-      }
-
-      define_method("#{scope_method_name}?") do |_time = Time.current|
-        raise InTimeScope::ConfigurationError, err_message
+    def define_error_scope_and_method(suffix, message)
+      method_names = [
+        :"in_time#{suffix}",
+        :"before_in_time#{suffix}",
+        :"after_in_time#{suffix}",
+        :"out_of_time#{suffix}"
+      ]
+
+      method_names.each do |method_name|
+        scope method_name, ->(_time = Time.current) {
+          raise InTimeScope::ConfigurationError, message
+        }
+
+        define_method("#{method_name}?") do |_time = Time.current|
+          raise InTimeScope::ConfigurationError, message
+        end
       end
     end
 
     # Defines a start-only scope (for history tracking pattern)
     #
-    # @param scope_method_name [Symbol] The name of the scope method
+    # @param suffix [String] The suffix for method names
     # @param column [Symbol] The start column name
     # @return [void]
     # @api private
-    def define_start_only_scope(scope_method_name, column)
-      col = column
-
+    def define_start_only_scope(suffix, column)
       # Simple scope - WHERE only, no ORDER BY
       # Users can add .order(start_at: :desc) externally if needed
-      scope scope_method_name, ->(time = Time.current) {
-        where(col => ..time)
+      scope :"in_time#{suffix}", ->(time = Time.current) {
+        where(column => ..time)
       }
-
-      # 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_one_scope(scope_method_name, column)
-      define_earliest_one_scope(scope_method_name, column)
     end
 
     # Defines the latest_in_time scope using NOT EXISTS subquery
@@ -194,7 +191,13 @@ module InTimeScope
     # This scope efficiently finds the latest record per foreign key,
     # suitable for use with has_one associations and includes.
     #
-    # @param scope_method_name [Symbol] The base scope method name
+    # @note When multiple records share the same timestamp for a given foreign key,
+    #   all of them will be returned. This is safe for +has_one+ associations
+    #   (ActiveRecord picks one), but callers using this as a standalone scope
+    #   should be aware that the result may contain multiple records per foreign key
+    #   in the case of timestamp ties.
+    #
+    # @param suffix [String] The suffix for method names
     # @param column [Symbol] The timestamp column name
     # @return [void]
     #
@@ -202,25 +205,39 @@ module InTimeScope
     #   has_one :current_price, -> { latest_in_time(:user_id) }, class_name: 'Price'
     #
     # @api private
-    def define_latest_one_scope(scope_method_name, column)
-      latest_method_name = scope_method_name == :in_time ? :latest_in_time : :"latest_#{scope_method_name}"
-      col = column
-
+    def define_latest_one_scope(suffix, column)
       # NOT EXISTS approach: select records where no later record exists for the same foreign key
-      scope latest_method_name, ->(foreign_key, time = Time.current) {
+      scope :"latest_in_time#{suffix}", ->(foreign_key, time = Time.current) {
         p2 = arel_table.alias("p2")
 
         subquery = Arel::SelectManager.new(arel_table)
                                       .from(p2)
                                       .project(Arel.sql("1"))
                                       .where(p2[foreign_key].eq(arel_table[foreign_key]))
-                                      .where(p2[col].lteq(time))
-                                      .where(p2[col].gt(arel_table[col]))
+                                      .where(p2[column].lteq(time))
+                                      .where(p2[column].gt(arel_table[column]))
                                       .where(p2[:id].not_eq(arel_table[:id]))
 
+        # Propagate simple equality conditions from the current scope into the NOT EXISTS
+        # subquery. This ensures that chained scopes like `.approved.latest_in_time(:user_id)`
+        # only consider approved records when searching for "a newer record exists",
+        # preventing a newer rejected record from shadowing the latest approved one.
+        where_values_hash.each do |col, val|
+          next if col.to_s == column.to_s      # time column already handled above
+          next if col.to_s == foreign_key.to_s # foreign key already handled above
+
+          subquery = if val.nil?
+                       subquery.where(p2[col].eq(nil))
+                     elsif val.is_a?(Array)
+                       subquery.where(p2[col].in(val))
+                     else
+                       subquery.where(p2[col].eq(val))
+                     end
+        end
+
         not_exists = Arel::Nodes::Not.new(Arel::Nodes::Exists.new(subquery.ast))
 
-        where(col => ..time).where(not_exists)
+        where(column => ..time).where(not_exists)
       }
     end
 
@@ -229,7 +246,13 @@ module InTimeScope
     # This scope efficiently finds the earliest record per foreign key,
     # suitable for use with has_one associations and includes.
     #
-    # @param scope_method_name [Symbol] The base scope method name
+    # @note When multiple records share the same timestamp for a given foreign key,
+    #   all of them will be returned. This is safe for +has_one+ associations
+    #   (ActiveRecord picks one), but callers using this as a standalone scope
+    #   should be aware that the result may contain multiple records per foreign key
+    #   in the case of timestamp ties.
+    #
+    # @param suffix [String] The suffix for method names
     # @param column [Symbol] The timestamp column name
     # @return [void]
     #
@@ -237,70 +260,73 @@ module InTimeScope
     #   has_one :first_price, -> { earliest_in_time(:user_id) }, class_name: 'Price'
     #
     # @api private
-    def define_earliest_one_scope(scope_method_name, column)
-      earliest_method_name = scope_method_name == :in_time ? :earliest_in_time : :"earliest_#{scope_method_name}"
-      col = column
-
+    def define_earliest_one_scope(suffix, column)
       # NOT EXISTS approach: select records where no earlier record exists for the same foreign key
-      scope earliest_method_name, ->(foreign_key, time = Time.current) {
+      scope :"earliest_in_time#{suffix}", ->(foreign_key, time = Time.current) {
         p2 = arel_table.alias("p2")
 
         subquery = Arel::SelectManager.new(arel_table)
                                       .from(p2)
                                       .project(Arel.sql("1"))
                                       .where(p2[foreign_key].eq(arel_table[foreign_key]))
-                                      .where(p2[col].lteq(time))
-                                      .where(p2[col].lt(arel_table[col]))
+                                      .where(p2[column].lteq(time))
+                                      .where(p2[column].lt(arel_table[column]))
                                       .where(p2[:id].not_eq(arel_table[:id]))
 
+        # Propagate simple equality conditions from the current scope into the NOT EXISTS
+        # subquery (same reasoning as define_latest_one_scope).
+        where_values_hash.each do |col, val|
+          next if col.to_s == column.to_s
+          next if col.to_s == foreign_key.to_s
+
+          subquery = if val.nil?
+                       subquery.where(p2[col].eq(nil))
+                     elsif val.is_a?(Array)
+                       subquery.where(p2[col].in(val))
+                     else
+                       subquery.where(p2[col].eq(val))
+                     end
+        end
+
         not_exists = Arel::Nodes::Not.new(Arel::Nodes::Exists.new(subquery.ast))
 
-        where(col => ..time).where(not_exists)
+        where(column => ..time).where(not_exists)
       }
     end
 
     # Defines an end-only scope (for expiration pattern)
     #
-    # @param scope_method_name [Symbol] The name of the scope method
+    # @param suffix [String] The suffix for method names
     # @param column [Symbol] The end column name
     # @return [void]
     # @api private
-    def define_end_only_scope(scope_method_name, column)
-      col = column
-
-      scope scope_method_name, ->(time = Time.current) {
-        where.not(col => ..time)
+    def define_end_only_scope(suffix, column)
+      scope :"in_time#{suffix}", ->(time = Time.current) {
+        where.not(column => ..time)
       }
-
-      # Efficient scope for has_one + includes using NOT EXISTS subquery
-      define_latest_one_scope(scope_method_name, column)
-      define_earliest_one_scope(scope_method_name, column)
     end
 
     # Defines a full scope with both start and end columns
     #
-    # @param scope_method_name [Symbol] The name of the scope method
+    # @param suffix [String] The suffix for method names
     # @param start_column [Symbol] The start column name
     # @param start_null [Boolean] Whether start column allows NULL
     # @param end_column [Symbol] The end column name
     # @param end_null [Boolean] Whether end column allows NULL
     # @return [void]
     # @api private
-    def define_full_scope(scope_method_name, start_column, start_null, end_column, end_null)
-      s_col = start_column
-      e_col = end_column
-
-      scope scope_method_name, ->(time = Time.current) {
+    def define_full_scope(suffix, start_column, start_null, end_column, end_null)
+      scope :"in_time#{suffix}", ->(time = Time.current) {
         start_scope = if start_null
-                        where(s_col => nil).or(where(s_col => ..time))
+                        where(start_column => nil).or(where(start_column => ..time))
                       else
-                        where(s_col => ..time)
+                        where(start_column => ..time)
                       end
 
         end_scope = if end_null
-                      where(e_col => nil).or(where.not(e_col => ..time))
+                      where(end_column => nil).or(where.not(end_column => ..time))
                     else
-                      where.not(e_col => ..time)
+                      where.not(end_column => ..time)
                     end
 
         start_scope.merge(end_scope)
@@ -313,15 +339,15 @@ module InTimeScope
 
     # Defines the instance method to check if a record is within the time window
     #
-    # @param scope_method_name [Symbol] The name of the scope method
+    # @param suffix [String] The suffix for method names
     # @param start_column [Symbol, nil] The start column name
     # @param start_null [Boolean, nil] Whether start column allows NULL
     # @param end_column [Symbol, nil] The end column name
     # @param end_null [Boolean, nil] Whether end column allows NULL
     # @return [void]
     # @api private
-    def define_instance_method(scope_method_name, start_column, start_null, end_column, end_null)
-      define_method("#{scope_method_name}?") do |time = Time.current|
+    def define_instance_method(suffix, start_column, start_null, end_column, end_null)
+      define_method("in_time#{suffix}?") do |time = Time.current|
         start_ok = if start_column.nil?
                      true
                    elsif start_null
@@ -341,5 +367,71 @@ module InTimeScope
         start_ok && end_ok
       end
     end
+
+    # Defines before_in_time scope (records not yet started: start_at > time)
+    #
+    # @param suffix [String] The suffix for method names
+    # @param start_column [Symbol, nil] The start column name
+    # @param start_null [Boolean, nil] Whether start column allows NULL
+    # @return [void]
+    # @api private
+    def define_before_scope(suffix, start_column, start_null)
+      # No start column means always started (never before)
+      # start_at > time means not yet started
+      # NULL start_at is treated as "already started" (not before)
+      scope :"before_in_time#{suffix}", ->(time = Time.current) {
+        start_column.nil? ? none : where.not(start_column => ..time)
+      }
+
+      define_method("before_in_time#{suffix}?") do |time = Time.current|
+        return false if start_column.nil?
+
+        val = send(start_column)
+        return false if val.nil? && start_null
+
+        val > time
+      end
+    end
+
+    # Defines after_in_time scope (records already ended: end_at <= time)
+    #
+    # @param suffix [String] The suffix for method names
+    # @param end_column [Symbol, nil] The end column name
+    # @param end_null [Boolean, nil] Whether end column allows NULL
+    # @return [void]
+    # @api private
+    def define_after_scope(suffix, end_column, end_null)
+      # No end column means never ends (never after)
+      # end_at <= time means already ended
+      # NULL end_at is treated as "never ends" (not after)
+      scope :"after_in_time#{suffix}", ->(time = Time.current) {
+        end_column.nil? ? none : where(end_column => ..time)
+      }
+
+      define_method("after_in_time#{suffix}?") do |time = Time.current|
+        return false if end_column.nil?
+
+        val = send(end_column)
+        return false if val.nil? && end_null
+
+        val <= time
+      end
+    end
+
+    # Defines out_of_time scope (records outside time window: before OR after)
+    #
+    # @param suffix [String] The suffix for method names
+    # @return [void]
+    # @api private
+    def define_out_of_time_scope(suffix)
+      # out_of_time = before_in_time OR after_in_time
+      scope :"out_of_time#{suffix}", ->(time = Time.current) {
+        send(:"before_in_time#{suffix}", time).or(send(:"after_in_time#{suffix}", time))
+      }
+
+      define_method("out_of_time#{suffix}?") do |time = Time.current|
+        send("before_in_time#{suffix}?", time) || send("after_in_time#{suffix}?", time)
+      end
+    end
   end
 end

data/lib/in_time_scope/version.rb

@@ -2,5 +2,5 @@
 
 module InTimeScope
   # The current version of the InTimeScope gem
-  VERSION = "0.1.5"
+  VERSION = "0.1.7"
 end

data/rulesync.jsonc

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://raw.githubusercontent.com/dyoshikawa/rulesync/refs/heads/main/config-schema.json",
+  "targets": ["claudecode"],
+  "features": ["rules", "commands"],
+  "baseDirs": ["."]
+}

data/sig/in_time_scope.rbs

@@ -36,15 +36,13 @@ module InTimeScope
     # @param scope_name [Symbol] The name of the scope (default: :in_time)
     # @param start_at [Hash] Configuration for the start column
     # @param end_at [Hash] Configuration for the end column
-    # @param prefix [Boolean] If true, creates prefix-style method names
     # @return [void]
     # @raise [ColumnNotFoundError] When a specified column doesn't exist
     # @raise [ConfigurationError] When the configuration is invalid (at scope call time)
     def in_time_scope: (
       ?Symbol scope_name,
       ?start_at: start_at_config,
-      ?end_at: end_at_config,
-      ?prefix: bool
+      ?end_at: end_at_config
     ) -> void
 
     private
@@ -52,30 +50,42 @@ module InTimeScope
     # Private implementation methods
     # These use ActiveRecord internals and are typed as untyped for flexibility
     def fetch_null_option: (untyped config, untyped column, untyped table_column_hash) -> untyped
-    def method_name: (Symbol scope_name, bool prefix) -> (Symbol | String)
-    def define_scope_methods: (untyped scope_method_name, start_at_column: untyped, start_at_null: untyped, end_at_column: untyped, end_at_null: untyped) -> void
-    def define_error_scope_and_method: (untyped scope_method_name, String message) -> void
-    def define_start_only_scope: (untyped scope_method_name, Symbol column) -> void
-    def define_latest_one_scope: (untyped scope_method_name, Symbol column) -> void
-    def define_earliest_one_scope: (untyped scope_method_name, Symbol column) -> void
-    def define_end_only_scope: (untyped scope_method_name, Symbol column) -> void
-    def define_full_scope: (untyped scope_method_name, Symbol start_column, untyped start_null, Symbol end_column, untyped end_null) -> void
-    def define_instance_method: (untyped scope_method_name, Symbol? start_column, untyped start_null, Symbol? end_column, untyped end_null) -> void
+    def define_scope_methods: (String suffix, start_at_column: untyped, start_at_null: untyped, end_at_column: untyped, end_at_null: untyped) -> void
+    def define_error_scope_and_method: (String suffix, String message) -> void
+    def define_start_only_scope: (String suffix, Symbol column) -> void
+    def define_latest_one_scope: (String suffix, Symbol column) -> void
+    def define_earliest_one_scope: (String suffix, Symbol column) -> void
+    def define_end_only_scope: (String suffix, Symbol column) -> void
+    def define_full_scope: (String suffix, Symbol start_column, untyped start_null, Symbol end_column, untyped end_null) -> void
+    def define_instance_method: (String suffix, Symbol? start_column, untyped start_null, Symbol? end_column, untyped end_null) -> void
+    def define_before_scope: (String suffix, Symbol? start_column, untyped start_null) -> void
+    def define_after_scope: (String suffix, Symbol? end_column, untyped end_null) -> void
+    def define_out_of_time_scope: (String suffix) -> void
   end
 end
 
 # Generated scope methods (dynamically defined)
 # When you call `in_time_scope` on a model, it creates these methods:
 #
-# Class methods:
+# Class methods (primary - records in time window):
 #   Model.in_time(time = Time.current) -> ActiveRecord::Relation
 #   Model.in_time_<name>(time = Time.current) -> ActiveRecord::Relation  (for named scopes)
 #   Model.latest_in_time(foreign_key, time = Time.current) -> ActiveRecord::Relation  (start-only/end-only)
 #   Model.earliest_in_time(foreign_key, time = Time.current) -> ActiveRecord::Relation (start-only/end-only)
 #
-# Instance methods:
+# Class methods (inverse - records outside time window):
+#   Model.before_in_time(time = Time.current) -> ActiveRecord::Relation  (not yet started)
+#   Model.after_in_time(time = Time.current) -> ActiveRecord::Relation   (already ended)
+#   Model.out_of_time(time = Time.current) -> ActiveRecord::Relation     (before OR after)
+#
+# Instance methods (primary):
 #   model.in_time?(time = Time.current) -> bool
 #   model.in_time_<name>?(time = Time.current) -> bool  (for named scopes)
+#
+# Instance methods (inverse):
+#   model.before_in_time?(time = Time.current) -> bool
+#   model.after_in_time?(time = Time.current) -> bool
+#   model.out_of_time?(time = Time.current) -> bool
 
 # Extend ActiveRecord::Base to include InTimeScope
 class ActiveRecord::Base

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: in_time_scope
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - kyohah
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: irb
   requirement: !ruby/object:Gem::Requirement
@@ -121,6 +121,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  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: yard
   requirement: !ruby/object:Gem::Requirement
@@ -143,17 +157,40 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rubocop.yml"
+- ".rulesync/commands/translate-readme.md"
+- ".rulesync/rules/project.md"
 - CHANGELOG.md
-- CLAUDE.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
 - Rakefile
 - Steepfile
+- docs/book.toml
+- docs/de/SUMMARY.md
+- docs/de/index.md
+- docs/de/point-system.md
+- docs/de/user-name-history.md
+- docs/fr/SUMMARY.md
+- docs/fr/index.md
+- docs/fr/point-system.md
+- docs/fr/user-name-history.md
+- docs/ja/SUMMARY.md
+- docs/ja/index.md
+- docs/ja/point-system.md
+- docs/ja/user-name-history.md
+- docs/src/SUMMARY.md
+- docs/src/index.md
+- docs/src/point-system.md
+- docs/src/user-name-history.md
+- docs/zh/SUMMARY.md
+- docs/zh/index.md
+- docs/zh/point-system.md
+- docs/zh/user-name-history.md
 - lib/in_time_scope.rb
 - lib/in_time_scope/class_methods.rb
 - lib/in_time_scope/version.rb
 - rbs_collection.yaml
+- rulesync.jsonc
 - sig/in_time_scope.rbs
 homepage: https://github.com/kyohah/in_time_scope
 licenses: