concerns_on_rails 1.34.0 → 1.35.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9acfbd10f8e27c5a4535a3486fec52255d7d5e997e3b7654547e864802bdcf58
-  data.tar.gz: 31701400ec820ac47a7cd26e8b68579dab0fba3d43bd1d8cea87b63c60f244ce
+  metadata.gz: 0542404e12b0b684a042ebcb69ca240f9581cfd75a2399782b93b4a14433832c
+  data.tar.gz: b0a7d63e3c1ed59c36d29bccb238e6bf9531d4a40a0841d5544217a0c5cbc04f
 SHA512:
-  metadata.gz: 0fc6561854bcdb26fbbae74b6f9b623bd9af28b240b313f56dcaa5c40da9c03726db39908e2b6ddb6af67d326fdd1f597c4ec81d31fc951711753320f44cf533
-  data.tar.gz: 4471742ad951b6b0dfd9998c93c43ba2e6627d44e5d6b94c0e48c366dcd5732f0c51b5df7886d3d88f0c6a71cf63a33f1a6695adfa1bf8292b8d51eb91d49609
+  metadata.gz: a678f1400483f94da5e10f0c24b5d9f2ce8f1c476183629fb8bf3ce96187c54a68a131650de902efd6913acf363168be22cfc9cde922de3f1c2607567f8f91d3
+  data.tar.gz: 1695643e945d899a7a279a803ddf0abadab8e54c9ac152af4d93a2a6002914448a2fc03e572f4bab4d3ecc38f3d98e54e990106359cafca8878d746b45b1e3d9

data/CHANGELOG.md

@@ -1,5 +1,61 @@
 <!-- CHANGELOG.md -->
 
+## 1.35.0 (2026-11-09)
+
+A small correctness release following the 2026-10-29 audit: it fixes the 3 findings the 1.34.0 release left open
+(DATA-S2, PARAMS-S2, TRANS-S4). Two of them change behaviour. Read **Upgrading** first.
+
+### Upgrading
+
+- [ ] **Paginatable, a relation you already limited or offset:** `paginated(Player.order(score: :desc).limit(10))`
+  now pages INSIDE that window: `X-Total-Count`, `X-Total-Pages` and `pagination_meta` describe the rows the relation
+  returns (`max(0, min(limit, rows - offset))`) and the pages slice them. A "top 10, 3 per page" relation has a total
+  of 10, pages 1-3 hold 3 rows and page 4 holds 1; later pages are empty. Before, your LIMIT/OFFSET was replaced by the
+  page's own and stripped from the COUNT, so the total was the whole table and page 4+ served rows beyond your window.
+  A relation without `limit`/`offset` is unchanged. If you relied on the old reading (a LIMIT used as "a big batch"
+  while paging the whole table), drop the `.limit(...)`/`.offset(...)` before `paginated`. (PARAMS-S2)
+- [ ] **CursorPaginatable, a relation you already limited or offset:** `cursor_paginated` / `cursor_pagination_meta`
+  raise `ArgumentError` for a relation carrying `limit`/`offset`. Before, the per_page + 1 probe replaced your LIMIT
+  and the walk ran to the end of the table (OFFSET has no meaning under a keyset WHERE). Drop them, or page the window
+  with Paginatable. (PARAMS-S2)
+- [ ] **Internal constants removed:** `Searchable::EDGE_SPACE` and `Taggable::EDGE_SPACE` no longer exist (they were
+  never public API); `Normalizable::EDGE_SPACE` stays. Use `ConcernsOnRails::Support::EdgeSpace` if you referenced
+  them. (TRANS-S4)
+
+### Fixed
+
+- **Tokenizable / Hashable / Sequenceable / Sortable: a create halted by a later `before_create` (`throw :abort`)
+  inside a caller's transaction left the drawn value on the record.** `Support::GeneratedValues::Revertible` restored
+  the token/hash/sequence number/position only from `rolledback!`, which never runs when `save` returns false inside a
+  joined transaction (Rails swallows the Rollback). A retried `save` re-used a value that was never inserted; for
+  Sequenceable that is a number another row may have taken meanwhile, so a duplicate or `RecordNotUnique`. `Revertible`
+  now also restores the recorded values the moment the create callbacks halt, inside or outside a transaction.
+  (DATA-S2)
+- **Paginatable / CursorPaginatable: a caller's LIMIT/OFFSET.** See Upgrading: Paginatable pages inside the window by
+  combining the windows arithmetically on the caller's own relation (no derived table, so `eager_load`/`includes`,
+  STI, `readonly` and `strict_loading` behave as in Rails); CursorPaginatable refuses it. (PARAMS-S2)
+- **Normalizable / Searchable / Taggable / Monetizable: edge-whitespace stripping was ~1 microsecond per character.**
+  A long interior run of spaces made `gsub(/\A[[:space:]\0]+|[[:space:]\0]+\z/, "")` cost over 1 s of CPU per MB of
+  untrusted input (a 1 MB `"a" + " " * N + "b"` query parameter). Each edge is now stripped with one anchored match
+  through `Support::EdgeSpace`, linear and byte-identical in result. `TimeValue.names_year?` (verb time arguments such
+  as `expire!`/`publish_at!`) answers false for a String over 128 bytes before running its trailing-comment regex,
+  which `Date._parse` refuses anyway (the result was already false). (TRANS-S4)
+
+### Known issues (not fixed in this release)
+- CounterCacheable: a parent destroyed inside the same rolled-back transaction keeps the
+  mirrored counter/lock_version in memory.
+- Aliasable: eager-loading an alias together with its source in one query loads each child twice.
+- Encryptable: on the pre-7.1 Marshal format, a record whose field has a per-field Proc `key:`
+  cannot be `Marshal.dump`ed (`Rails.cache`).
+- CursorPaginatable: on PostgreSQL, a page ending on a timestamp stored as `'infinity'` now mints
+  its cursor (it used to be a 500), but the next page answers 400 — the walk cannot step past it.
+- Normalizable / Sanitizable: on an unvalidated (`update_attribute`) save that is halted and retried, with TWO
+  transforms on one column where the SECOND (not Normalizable) rewrites the first's output, Sanitizable's own record
+  holds only the first's output, so a validated retry re-sanitizes.
+- Sluggable `history: true` + `scope:`: friendly_id's history finder ignores scope, so after a record moves scope its
+  stale history slug can still match `Model.where(scope).friendly.find(old_slug)`. This is stock friendly_id
+  behaviour; the gem does not change it. (GRAPH-5)
+
 ## 1.34.0 (2026-10-29)
 
 A correctness release: it fixes the 43 bugs proven by the 2026-10-29 audit of 1.33.0. Some fixes change behaviour,

data/README.md

@@ -2041,7 +2041,7 @@ Render it straight into a `1 … 44 45 46 [47] 48 49 50 … 100` bar:
 `?page=` past the last page windows around the last page (as `rel="prev"` already does), and
 `window:` must be a non-negative Integer or `nil`/`false` — validated at declaration.
 
-A relation's total is a `COUNT` with `ORDER`/`LIMIT`/`OFFSET` stripped; a `DISTINCT` relation with its own `SELECT` list (`Membership.select(:group_id).distinct`, or DISTINCT written into the list: `select("DISTINCT category")`) is counted as a raw `SELECT COUNT(*) FROM (…)` subquery (STI-safe), so the total is the number of distinct rows it returns, not the underlying row count. MySQL alone rejects repeated output names in that subquery (`select("a.id, b.id")`); there the count is retried with the list re-aliased positionally, and a list that cannot be re-aliased (`table.*`) falls back to the plain over-count. A model class (`paginated(Article)`) is counted through `.all`.
+A relation's total is a `COUNT` with `ORDER`/`LIMIT`/`OFFSET` stripped, then bounded by the window the relation itself carries: `paginated(Player.order(score: :desc).limit(10))` pages a top 10 (total 10, so 3 per page gives 4 pages and page 5 is empty, never rows past the 10) — the pages offset and limit the caller's own relation, so `eager_load`/`includes`, STI and `readonly` keep working; a `DISTINCT` relation with its own `SELECT` list (`Membership.select(:group_id).distinct`, or DISTINCT written into the list: `select("DISTINCT category")`) is counted as a raw `SELECT COUNT(*) FROM (…)` subquery (STI-safe), so the total is the number of distinct rows it returns, not the underlying row count. MySQL alone rejects repeated output names in that subquery (`select("a.id, b.id")`); there the count is retried with the list re-aliased positionally, and a list that cannot be re-aliased (`table.*`) falls back to the plain over-count. A model class (`paginated(Article)`) is counted through `.all`.
 
 **Response headers**: `X-Total-Count`, `X-Page`, `X-Per-Page`, `X-Total-Pages`, and an RFC 8288 `Link`
 header with `first` / `prev` / `next` / `last` URLs rebuilt from the current request (other query params
@@ -2067,6 +2067,8 @@ class ArticlesController < ApplicationController
 end
 ```
 
+A relation already carrying `limit`/`offset` is refused with an `ArgumentError`; page such a window with Paginatable.
+
 **URL params**
 
 | Param        | Default | Notes                                                    |
@@ -2871,7 +2873,7 @@ Point your agent at `llms.txt` for an overview, or paste a single concern's `.md
 bundle install                                  # install dev dependencies
 bundle exec rspec                               # run the test suite (3,420 examples)
 gem build concerns_on_rails.gemspec             # build the gem
-gem install ./concerns_on_rails-1.34.0.gem      # install locally
+gem install ./concerns_on_rails-1.35.0.gem      # install locally
 
 # Preview the docs site locally (GitHub Pages serves docs/ as-is):
 cd docs && python3 -m http.server 8000          # → http://localhost:8000

data/lib/concerns_on_rails/controllers/cursor_paginatable.rb

@@ -1,6 +1,7 @@
 require "active_support/concern"
 require "concerns_on_rails/support/error_envelope"
 require "concerns_on_rails/support/scalar_param"
+require "concerns_on_rails/support/caller_window"
 require "concerns_on_rails/support/numeric_operand"
 require "concerns_on_rails/support/time_value"
 require "json"
@@ -320,6 +321,7 @@ module ConcernsOnRails
 
       def cursor_paginate_result(relation, order:, per_page:, bidirectional: nil)
         relation = relation.all if relation.is_a?(Class)
+        cursor_refuse_caller_window!(relation)
         pairs = cursor_order_pairs(relation, order)
         limit = cursor_per_page(per_page)
         bidi = bidirectional.nil? ? self.class.cursor_paginatable_bidirectional : bidirectional
@@ -329,6 +331,18 @@ module ConcernsOnRails
           meta: cursor_build_meta(relation.model, pairs, limit, fetch, bidi) }
       end
 
+      # The keyset query's own `limit(per_page + 1)` would replace the
+      # caller's LIMIT and the walk would run past it to the end of the table
+      # (PARAMS-S2), and OFFSET has no meaning under a keyset WHERE. Refuse
+      # rather than walk rows the caller meant to exclude.
+      def cursor_refuse_caller_window!(relation)
+        return unless ConcernsOnRails::Support::CallerWindow.window?(relation)
+
+        raise ArgumentError,
+              "#{CursorPaginatable.name}: cursor pagination replaces the relation's LIMIT/OFFSET; " \
+              "drop them or use Paginatable"
+      end
+
       # A backward ("prev") cursor walks the INVERTED ordering so LIMIT grabs
       # the rows nearest the boundary, then flips the page back to canonical
       # order. reorder (not order) so the keyset columns REPLACE any prior

data/lib/concerns_on_rails/controllers/paginatable.rb

@@ -1,5 +1,6 @@
 require "active_support/concern"
 require "concerns_on_rails/support/scalar_param"
+require "concerns_on_rails/support/caller_window"
 require "concerns_on_rails/support/link_header"
 
 module ConcernsOnRails
@@ -196,7 +197,7 @@ module ConcernsOnRails
           elsif source.is_a?(Array)
             source[offset, per_page] || []
           else
-            source.limit(per_page).offset(offset)
+            paginatable_page_relation(source, offset, per_page)
           end
 
         @paginatable_meta =
@@ -269,6 +270,13 @@ module ConcernsOnRails
         return source.size if source.is_a?(Array)
 
         relation = paginatable_count_relation(source)
+        total = paginatable_unwindowed_total(relation)
+        ConcernsOnRails::Support::CallerWindow.window?(relation) ? ConcernsOnRails::Support::CallerWindow.rows_in(total, relation) : total
+      end
+
+      # The count with the caller's own LIMIT/OFFSET stripped (every path below
+      # does); paginatable_total then bounds it to the caller's window.
+      def paginatable_unwindowed_total(relation)
         if paginatable_distinct_select?(relation) || paginatable_grouped_having_select?(relation)
           return paginatable_distinct_select_total(relation)
         end
@@ -284,6 +292,21 @@ module ConcernsOnRails
         source.is_a?(Class) && source.respond_to?(:all) ? source.all : source
       end
 
+      # A relation the caller already limited/offset is paged INSIDE that
+      # window (PARAMS-S2): its offset plus the page's, its limit cut to what
+      # is left of the window. Still the caller's own relation, so ORDER,
+      # eager loading, STI, readonly and quoting stay Rails'. A page past the
+      # window's end is empty (no query).
+      def paginatable_page_relation(source, offset, per_page)
+        relation = paginatable_count_relation(source)
+        return source.limit(per_page).offset(offset) unless ConcernsOnRails::Support::CallerWindow.window?(relation)
+
+        window_offset, limit = ConcernsOnRails::Support::CallerWindow.page_window(relation, offset, per_page)
+        return relation.none if limit.zero?
+
+        relation.limit(limit).offset(window_offset)
+      end
+
       def paginatable_plain_count(relation)
         counted = relation.except(:order, :limit, :offset, :select).count(:all)
         counted.is_a?(Hash) ? counted.length : counted

data/lib/concerns_on_rails/models/normalizable.rb

@@ -6,6 +6,7 @@ require "active_support/core_ext/string/filters"
 require "active_support/core_ext/string/inflections"
 require "uri"
 require "concerns_on_rails/support/column_guard"
+require "concerns_on_rails/support/edge_space"
 require "concerns_on_rails/support/transform_backstop"
 
 module ConcernsOnRails
@@ -43,7 +44,8 @@ module ConcernsOnRails
       # drops the suffix of "customer_id" outright.
       TITLEIZE_WORD = /(?<![[:alnum:]'])[[:alpha:]]+/
       # Leading/trailing Unicode whitespace (plus NUL, which String#strip also
-      # removed), for the stripping presets.
+      # removed), for the stripping presets. Kept for callers that match it
+      # themselves; stripping goes through Support::EdgeSpace (linear time).
       EDGE_SPACE = /\A[[:space:]\0]+|[[:space:]\0]+\z/
 
       # `:url` — strip, default the scheme to https://, lowercase the scheme and
@@ -85,7 +87,7 @@ module ConcernsOnRails
       # [[:space:]]); :nullify_blank uses it too, so a value of nothing but
       # no-break spaces is blank.
       def self.strip(value)
-        value.gsub(EDGE_SPACE, "")
+        Support::EdgeSpace.strip(value)
       end
 
       # `host=` also clears the userinfo on uri >= 1.1 (Ruby 3.2's bundled

data/lib/concerns_on_rails/models/searchable.rb

@@ -1,5 +1,6 @@
 require "active_support/concern"
 require "concerns_on_rails/support/column_guard"
+require "concerns_on_rails/support/edge_space"
 
 module ConcernsOnRails
   module Models
@@ -45,9 +46,6 @@ module ConcernsOnRails
 
       LIKE_ESCAPE = "\\".freeze
       LIKE_SPECIAL = /[\\%_]/
-      # Leading/trailing Unicode whitespace (plus NUL, which String#strip also
-      # removed) — Normalizable::EDGE_SPACE.
-      EDGE_SPACE = /\A[[:space:]\0]+|[[:space:]\0]+\z/
       VALID_MODES = %i[any all].freeze
       VALID_MATCHES = %i[contains prefix exact].freeze
       # Which match tiers can be told apart under each match mode (best first).
@@ -120,7 +118,7 @@ module ConcernsOnRails
         # Unicode-aware (String#strip / #split are ASCII-only): a no-break or
         # an IME's ideographic space is whitespace too.
         def search_terms(query)
-          text = query.to_s.gsub(EDGE_SPACE, "")
+          text = Support::EdgeSpace.strip(query.to_s)
           return [] if text.empty?
 
           searchable_mode == :all ? text.split(/[[:space:]]+/) : [text]

data/lib/concerns_on_rails/models/taggable.rb

@@ -1,6 +1,7 @@
 require "active_support/concern"
 require "concerns_on_rails/support/batch_ops"
 require "concerns_on_rails/support/column_guard"
+require "concerns_on_rails/support/edge_space"
 require "concerns_on_rails/support/transform_backstop"
 
 module ConcernsOnRails
@@ -61,9 +62,6 @@ module ConcernsOnRails
       # the escape character for us, so a backslash is portable here.
       LIKE_ESCAPE = "\\".freeze
       LIKE_SPECIAL = /[\\%_]/
-      # Leading/trailing Unicode whitespace (plus NUL, which String#strip also
-      # removed) — Normalizable::EDGE_SPACE.
-      EDGE_SPACE = /\A[[:space:]\0]+|[[:space:]\0]+\z/
 
       included do
         class_attribute :taggable_field, instance_accessor: false, default: DEFAULT_FIELD
@@ -207,7 +205,7 @@ module ConcernsOnRails
         # kept as a distinct tag that tagged_with("ruby") never found, though
         # it looked identical in all_tags.
         def taggable_clean(tag)
-          tag = taggable_trim_straddle(tag.to_s.gsub(EDGE_SPACE, ""))
+          tag = taggable_trim_straddle(Support::EdgeSpace.strip(tag.to_s))
           taggable_downcase ? tag.downcase : tag
         end
 
@@ -236,7 +234,7 @@ module ConcernsOnRails
           tag = tag[0, tag.length - trailing.length] if trailing
           leading = suffixes.find { |suffix| tag.start_with?(suffix) }
           tag = tag[leading.length..] if leading
-          tag.gsub(EDGE_SPACE, "")
+          Support::EdgeSpace.strip(tag)
         end
 
         # For each period k of the delimiter d (d == d[0, k] + d[k..], i.e.

data/lib/concerns_on_rails/support/caller_window.rb

@@ -0,0 +1,39 @@
+module ConcernsOnRails
+  module Support
+    # A relation the caller already LIMITed and/or OFFSET (`Player.order(:score).limit(10)`)
+    # is a window: Paginatable pages INSIDE it (PARAMS-S2) instead of replacing
+    # its LIMIT with the page's own. The two windows are combined arithmetically
+    # on the caller's own relation, so ORDER, eager loading, STI, readonly and
+    # identifier quoting stay exactly as Rails builds them.
+    module CallerWindow
+      module_function
+
+      # True for a relation carrying a limit or a non-zero offset. A model
+      # class, an Array and a duck-typed source have no window.
+      def window?(relation)
+        return false unless %i[limit_value offset_value].all? { |reader| relation.respond_to?(reader) }
+
+        !relation.limit_value.nil? || offset_of(relation).positive?
+      end
+
+      def offset_of(relation)
+        relation.offset_value.to_i
+      end
+
+      # Rows inside the window, given the unwindowed row count: max(0, min(L, N - O)).
+      def rows_in(total, relation)
+        rows = total - offset_of(relation)
+        rows = [rows, relation.limit_value.to_i].min unless relation.limit_value.nil?
+        [rows, 0].max
+      end
+
+      # [offset, limit] for the page starting `page_offset` rows into the
+      # window. A limit of 0 is a page past the window's end.
+      def page_window(relation, page_offset, per_page)
+        limit = per_page
+        limit = (relation.limit_value.to_i - page_offset).clamp(0, per_page) unless relation.limit_value.nil?
+        [offset_of(relation) + page_offset, limit]
+      end
+    end
+  end
+end

data/lib/concerns_on_rails/support/edge_space.rb

@@ -0,0 +1,31 @@
+module ConcernsOnRails
+  module Support
+    # Strips Unicode whitespace (and NUL, which String#strip also removed) from
+    # both ends of a String — String#strip is ASCII-only, so a pasted no-break
+    # or ideographic space survived it. Shared by Normalizable, Searchable,
+    # Taggable and Money.
+    #
+    # The one-regex form (`gsub(/\A[[:space:]\0]+|[[:space:]\0]+\z/, "")`) had
+    # to start a `[[:space:]]+\z` attempt at every position of an interior run
+    # of spaces. Ruby 3.2's match cache keeps that from going quadratic, but
+    # at about a microsecond per character: a 1 MB `"a" + " " * N + "b"` query
+    # parameter cost ~1 s of CPU, and 3 MB of `"a b" * N` over 2 s. Two
+    # anchored `\A` runs (the end is reached by reversing the String, whose
+    # whitespace characters are all single code points) match each edge in one
+    # pass and stop at the first non-space character.
+    module EdgeSpace
+      LEADING = /\A[[:space:]\0]+/
+      LEADING_NO_NUL = /\A[[:space:]]+/
+
+      module_function
+
+      # A new String, like gsub returned. Raises ArgumentError on invalid byte
+      # sequences, as the regex form did. `nul: false` leaves NUL alone
+      # (Money's reader never stripped it).
+      def strip(string, nul: true)
+        edge = nul ? LEADING : LEADING_NO_NUL
+        string.sub(edge, "").reverse.sub(edge, "").reverse
+      end
+    end
+  end
+end

data/lib/concerns_on_rails/support/generated_values.rb

@@ -36,6 +36,10 @@ module ConcernsOnRails
     # each column's pre-create value on the record, and `Revertible` — included
     # by every producer — puts them back when the create rolls back.
     #
+    # A create HALTED by a later before_create (`throw :abort`) puts them back
+    # at the halt itself: inside a caller's transaction Rails swallows the
+    # Rollback it raises for the false `save`, so `rolledback!` never runs.
+    #
     # Every hook is idempotent — it re-derives, it never appends — so two
     # producers reporting in one create (a token and a number) are safe. The
     # hooks are NOT free outside a save (friendly_id's slug-availability
@@ -81,6 +85,18 @@ module ConcernsOnRails
 
         def generated_values_enrolled; end
 
+        # A before_create that halts (`throw :abort`) after a producer drew its
+        # value makes the create callbacks answer false. `save` then raises
+        # Rollback, but inside a caller's transaction that Rollback is swallowed
+        # by the JOINED transaction and `rolledback!` never runs — so the
+        # restore happens here, at the halt, inside or outside a transaction.
+        # A real rollback still reverts through `rolledback!`.
+        def _create_record(*, **, &)
+          result = super
+          generated_values_revert! if result == false
+          result
+        end
+
         # Puts back the columns a create path generated, while the record is a
         # new record again. A column the caller has changed since (no longer
         # the generated value) is left alone; a persisted record keeps what it

data/lib/concerns_on_rails/support/money.rb

@@ -1,4 +1,5 @@
 require "bigdecimal"
+require "concerns_on_rails/support/edge_space"
 
 module ConcernsOnRails
   module Support
@@ -238,7 +239,7 @@ module ConcernsOnRails
 
       # String#strip misses Unicode whitespace such as a no-break space.
       def strip_space(string)
-        string.gsub(/\A[[:space:]]+|[[:space:]]+\z/, "")
+        EdgeSpace.strip(string, nul: false)
       end
 
       # Subunits to a BigDecimal amount. A grouped relation's aggregate is a

data/lib/concerns_on_rails/support/time_value.rb

@@ -55,6 +55,11 @@ module ConcernsOnRails
       # JavaScript Date#toString's "(Eastern Daylight Time)", RFC 9557's
       # "[America/New_York]".
       TRAILING_COMMENTS = /(?:\s*(?:\([^()]*\)|\[[^\[\]]*\]))+\s*\z/
+      # Date._parse refuses a String longer than this many BYTES (its `limit:`
+      # default). names_year? answers false for such a String before it runs
+      # TRAILING_COMMENTS, whose match cost grows with the input (about a
+      # microsecond per character, seconds for a few MB).
+      DATE_PARSE_LIMIT = 128
 
       module_function
 
@@ -147,6 +152,7 @@ module ConcernsOnRails
       # ActiveRecord does.
       def names_year?(value)
         return true unless value.is_a?(::String)
+        return false if value.bytesize > DATE_PARSE_LIMIT
 
         bare = value.sub(TRAILING_COMMENTS, "")
         return false if bare.match?(/[()\[\]]/)

data/lib/concerns_on_rails/version.rb

@@ -1,3 +1,3 @@
 module ConcernsOnRails
-  VERSION = "1.34.0".freeze
+  VERSION = "1.35.0".freeze
 end

data/lib/concerns_on_rails.rb

@@ -66,6 +66,7 @@ module ConcernsOnRails
   module Support
     autoload :ColumnGuard,             "concerns_on_rails/support/column_guard"
     autoload :IncludeTree,             "concerns_on_rails/support/include_tree"
+    autoload :CallerWindow,            "concerns_on_rails/support/caller_window"
     autoload :ScalarParam,             "concerns_on_rails/support/scalar_param"
     autoload :UniqueRetry,             "concerns_on_rails/support/unique_retry"
     autoload :ErrorEnvelope,           "concerns_on_rails/support/error_envelope"
@@ -87,6 +88,7 @@ module ConcernsOnRails
     autoload :VaryHeader,              "concerns_on_rails/support/vary_header"
     autoload :NumericOperand,          "concerns_on_rails/support/numeric_operand"
     autoload :TimeValue,               "concerns_on_rails/support/time_value"
+    autoload :EdgeSpace,               "concerns_on_rails/support/edge_space"
     autoload :NativeJson,              "concerns_on_rails/support/native_json"
     autoload :Callable,                "concerns_on_rails/support/callable"
     autoload :SlugSources,             "concerns_on_rails/support/slug_sources"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: concerns_on_rails
 version: !ruby/object:Gem::Version
-  version: 1.34.0
+  version: 1.35.0
 platform: ruby
 authors:
 - Ethan Nguyen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-11-04 00:00:00.000000000 Z
+date: 2026-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -190,8 +190,10 @@ files:
 - lib/concerns_on_rails/support/association_scope.rb
 - lib/concerns_on_rails/support/batch_ops.rb
 - lib/concerns_on_rails/support/callable.rb
+- lib/concerns_on_rails/support/caller_window.rb
 - lib/concerns_on_rails/support/column_guard.rb
 - lib/concerns_on_rails/support/contextual_destroy.rb
+- lib/concerns_on_rails/support/edge_space.rb
 - lib/concerns_on_rails/support/encrypted_lookup.rb
 - lib/concerns_on_rails/support/encryptor.rb
 - lib/concerns_on_rails/support/error_envelope.rb