expressir 2.4.2 → 2.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f786a7123d34be8bada764d132f213c09f229d5f94046509dbdbfc37a0d4279
-  data.tar.gz: 9b32c54df109ca8e6945ab03d2b7e3697d2b0bce3afbb67476bfe1510e0eb2fe
+  metadata.gz: 0b0fe8cde3b24a7a4ce39599fa68b61b02d3f8af45c1a8f5e45ce2607a213922
+  data.tar.gz: 869991a150512a7b12fb94f18f97e66bc6954317c311f630b3fac41d55d001b0
 SHA512:
-  metadata.gz: 5225e02955f94be94f71e9005330d1c58173ebd9cb5aa97956abfa9b8b8f3f2e964f25648d8074ad8ba41fb678530dad4348570ed8c697c6445224fe77c1514f
-  data.tar.gz: f97f4c7be51de8b6c5e4e71301555f20d05bdb268b61ef7df2e7be4bd06796af255b1f2cc362e6a25a61867fd62ab0b3610eb25683d57d6b36401c9a338598f5
+  metadata.gz: d04f62c906dc98f43a469f88ec56382decf8636407766c94b1248f94fbc21a2667144cc421a021dda592ea5d56987937ca20ea819a4300540589ea935c2767c2
+  data.tar.gz: eeaa19435f4e66921136fbe3cee4ac729f5dfd5fa4f5731cc5b88a601639518c6be3ebfa70af4d29ef8f78500e80586a50df7636a88892a03f93787d9bee2182

data/TODO.max-perf/01-restore-ci-green.md

@@ -16,7 +16,9 @@ yeptris has since released 0.6.4.1 and 0.6.5.1.
       (`package_fixtures_spec`, `package_spec`, `cache_spec`): 84/84 green on
       0.6.5.1
 - [x] Re-run the failed rake workflow on main (resolves 0.6.5.1)
-- [ ] Confirm the rake workflow on main is green
+- [x] Confirmed: rake green on main after yeptris 0.6.5.3 (mingw FFI
+      constants now defined in ffi.rb; new x64-mingw32/x86_64-darwin-24
+      platform builds) — verified via the run on this merge
 - [x] 0.6.5.1 does NOT fix mingw (same NameError, all Windows jobs) — filed
       leptris/yeptris#318 with the CI repro
 - [x] expressir-side guard: `Expressir.select_serialization_engines` pins the
@@ -24,6 +26,11 @@ yeptris has since released 0.6.4.1 and 0.6.5.1.
       lutaml-model's autodetection never loads the broken mingw build; Unix
       keeps yeptris. Spec: spec/expressir/engine_selection_spec.rb
 
+- [x] Follow-up (2026-09-19): yeptris 0.6.7.4 re-vendors libyeptris (mingw
+      gem ships libyeptris.dll + per-Ruby natives; FFI constants defined in
+      ffi.rb). Engine loads and parses on darwin via the FFI ladder; this
+      PR's matrix run is the Windows verdict with the engine active again.
+
 ## Acceptance
 
 rake workflow green on main across the full platform matrix.

data/lib/expressir/express/node_position_index.rb

@@ -13,6 +13,9 @@ module Expressir
     # instances; this module turns those spans into a line-keyed index that
     # remark attachment can query.
     class NodePositionIndex
+      EMPTY = [].freeze
+      private_constant :EMPTY
+
       # Single source of truth for "what collections does this node have"
       # lives on the model — each class declares its own via the
       # `collection_attributes` macro. Referenced by both RemarkAttacher
@@ -21,31 +24,133 @@ module Expressir
 
       attr_reader :nodes
 
+      # Semantic entries starting on `line` (node order).
+      def starting_at(line)
+        semantic_by_line[line] || EMPTY
+      end
+
+      # Semantic entries ending on `line` (node order).
+      def ending_at(line)
+        semantic_by_end_line[line] || EMPTY
+      end
+
+      # Semantic entries whose span covers `line` (node order within the
+      # covering band).
+      def spanning(line)
+        band = line / BAND
+        bands = span_bands
+        return EMPTY unless bands.key?(band)
+
+        bands[band].select { |n| line.between?(n[:line], n[:end_line]) }
+      end
+
+      # Semantic entries with end_line < line, ascending by end_line.
+      def semantic_ending_before(line)
+        sorted = semantic_by_end_line_list
+        idx = sorted.bsearch_index { |n| n[:end_line] >= line } || sorted.size
+        sorted[0...idx]
+      end
+
+      # The first semantic entry (smallest line), for preamble remarks.
+      def first_semantic
+        first_by_line = semantic_by_line.keys.min
+        first_by_line && semantic_by_line[first_by_line]&.first
+      end
+
+      # Entries owned by `owner` within any of `collections`, in node order.
+      # Identity-keyed: ownership is object identity (the tree-walker's
+      # `.equal?` semantics), and value-equal model objects must not
+      # collide.
+      def children_in(owner, collections)
+        per_collection = children_index[owner]
+        return EMPTY unless per_collection
+
+        entries = per_collection.values_at(*collections).compact.flatten(1)
+        entries.sort_by { |n| node_order(n) }
+      end
+
+      # First node (in node order) that is_a?(type), memoized per type.
+      def first_node_of_type(type)
+        @first_of_type ||= {}
+        @first_of_type[type] ||= @nodes.find { |n| n[:node].is_a?(type) }&.dig(:node)
+      end
+
+      def semantic_entries
+        @semantic_entries ||=
+          @nodes.select { |n| n[:line] && semantic?(n[:node]) }
+      end
+
+      # Non-vivifying: missed lookups must not materialize keys, or
+      # `keys.min`-style queries see phantom lines.
+      def semantic_by_line
+        @semantic_by_line ||= begin
+          h = {}
+          semantic_entries.each { |n| (h[n[:line]] ||= []) << n }
+          h
+        end
+      end
+
+      def semantic_by_end_line
+        @semantic_by_end_line ||= begin
+          h = {}
+          semantic_entries.each { |n| (h[n[:end_line]] ||= []) << n if n[:end_line] }
+          h
+        end
+      end
+
+      def semantic_by_end_line_list
+        @semantic_by_end_line_list ||=
+          semantic_entries.select { |n| n[:end_line] }.sort_by { |n| n[:end_line] }
+      end
+
+      def children_index
+        @children_index ||= begin
+          index = {}.compare_by_identity
+          @nodes.each do |n|
+            next unless n[:owner] && n[:line]
+
+            per_owner = (index[n[:owner]] ||= {})
+            (per_owner[n[:collection]] ||= []) << n
+          end
+          index
+        end
+      end
+
+      def span_bands
+        @span_bands ||= begin
+          bands = Hash.new { |hash, key| hash[key] = [] }
+          semantic_entries.each do |n|
+            next unless n[:end_line]
+
+            ((n[:line] / BAND)..(n[:end_line] / BAND)).each do |band|
+              bands[band] << n
+            end
+          end
+          bands
+        end
+      end
+
+      BAND = 1024
+      private_constant :BAND
+
       def initialize(model, line_map)
         @model = model
         @line_map = line_map
         @nodes = build_sorted_nodes
+        @node_order = nil
       end
 
       # Returns the most-specific node whose span contains `remark_line`,
       # preferring same-line starts/ends, then smallest containing span.
       # Excludes Repository and Cache (not semantic scopes for remarks).
       def nearest_node_to(remark_line)
-        same_start = nodes.select do |n|
-          n[:line] == remark_line && semantic?(n[:node])
-        end
+        same_start = starting_at(remark_line)
         return same_start.last[:node] if same_start.any?
 
-        same_end = nodes.select do |n|
-          n[:end_line] == remark_line && semantic?(n[:node])
-        end
+        same_end = ending_at(remark_line)
         return same_end.last[:node] if same_end.any?
 
-        containing = nodes.select do |n|
-          n[:line] && n[:end_line] &&
-            n[:line] <= remark_line && n[:end_line] >= remark_line &&
-            semantic?(n[:node])
-        end
+        containing = spanning(remark_line)
 
         if containing.any?
           exp_file_node = containing.find { |n| n[:node].is_a?(Model::ExpFile) }
@@ -62,16 +167,13 @@ module Expressir
           candidates = containing if candidates.empty?
           candidates.min_by { |n| n[:end_line] - n[:line] }[:node]
         else
-          before = nodes.select do |n|
-            n[:end_line] && n[:end_line] < remark_line && semantic?(n[:node])
-          end
+          before = semantic_ending_before(remark_line)
           if before.any?
             before.max_by { |n| n[:end_line] }[:node]
           else
             # Remark is before all nodes (e.g., preamble comment before SCHEMA).
             # Attach to the first semantic node.
-            after = nodes.select { |n| n[:line] && semantic?(n[:node]) }
-            after.min_by { |n| n[:line] }[:node] if after.any?
+            first_semantic&.dig(:node)
           end
         end
       end
@@ -90,17 +192,28 @@ module Expressir
                     end
         return nil unless node_type
 
-        matching = nodes.select do |n|
+        candidates = (0..2).flat_map do |back|
+          ending_at(remark_line - back)
+        end.select do |n|
           n[:node].is_a?(node_type) &&
-            (n[:end_line] == remark_line ||
-             (n[:end_line] && n[:end_line] <= remark_line && n[:end_line] >= remark_line - 2))
+            n[:end_line] <= remark_line && n[:end_line] >= remark_line - 2
         end
 
-        matching.first&.dig(:node) || nodes.find { |n| n[:node].is_a?(node_type) }&.dig(:node)
+        candidates.min_by { |n| node_order(n) }&.dig(:node) ||
+          first_node_of_type(node_type)
       end
 
       private
 
+      def node_order(entry)
+        @node_order ||= begin
+          map = {}.compare_by_identity
+          @nodes.each_with_index { |n, i| map[n] = i }
+          map
+        end
+        @node_order[entry]
+      end
+
       def semantic?(node)
         !node.is_a?(Model::Repository) && !node.is_a?(Model::Cache)
       end

data/lib/expressir/express/remark_attacher.rb

@@ -245,21 +245,20 @@ module Expressir
       # shares a line with a node or sits outside any statement-bearing node.
       def find_body_comment_target(remark)
         line = remark.line
-        nodes = @node_index.nodes
         # An own-line comment shares its line with no node. A node STARTING
         # here means the remark is an inline tail (code; -- note). The
         # end-line check is restricted to statements: container end_lines are
         # child-derived approximations that can collide with comment lines.
-        return inline_target(remark, nodes) if inline_remark?(remark)
+        return inline_target(remark, @node_index.starting_at(line)) if inline_remark?(remark)
 
         # A closing keyword on the next code line is decisive: the comment
         # closes that body. Without this check the comment would instead be
         # read as leading the next statement of an OUTER region, which is
         # where it would wrongly render.
-        closing = closing_region_target(line, nodes)
+        closing = closing_region_target(line)
         return closing if closing.first
 
-        enclosing, region, = statement_region_for(line, nodes)
+        enclosing, region, = statement_region_for(line)
         return [nil, nil, nil] unless region
 
         following = region
@@ -339,7 +338,7 @@ module Expressir
       # every span and never reaches statement_region_for. Resolve it from
       # the keyword that follows: it names both the owner type and the body
       # being closed.
-      def closing_region_target(line, nodes)
+      def closing_region_target(line)
         keyword_owner, region, keyword_line = closing_keyword_after(line)
         return [nil, nil, nil] unless keyword_owner
 
@@ -351,8 +350,8 @@ module Expressir
         opener_line = active_opener_line(keyword_line, keyword_owner)
         return [nil, nil, nil] unless opener_line
 
-        owner = nodes.find do |n|
-          n[:node].is_a?(keyword_owner) && n[:line] == opener_line
+        owner = @node_index.starting_at(opener_line).find do |n|
+          n[:node].is_a?(keyword_owner)
         end
         return [nil, nil, nil] unless owner
 
@@ -458,18 +457,15 @@ module Expressir
         [nil, nil, nil]
       end
 
-      def statement_region_for(line, nodes)
-        candidates = nodes.select do |n|
+      def statement_region_for(line, nodes = nil)
+        candidates = (nodes || @node_index.spanning(line)).select do |n|
           n[:line] && n[:end_line] && n[:line] <= line && n[:end_line] >= line &&
             (n[:node].is_a?(Model::Statement) || function_rule_procedure?(n[:node]))
         end
         enclosing = innermost_candidate(candidates)
         return [nil, nil, nil] unless enclosing
 
-        children = nodes.select do |n|
-          n[:owner].equal?(enclosing[:node]) &&
-            STATEMENT_REGIONS.include?(n[:collection]) && n[:line]
-        end
+        children = @node_index.children_in(enclosing[:node], STATEMENT_REGIONS)
         return [enclosing, nil, nil] if children.empty?
 
         preceding = children.select { |n| n[:line] < line }.max_by { |n| n[:position] }

data/lib/expressir/version.rb

@@ -3,6 +3,6 @@ module Expressir
   # autoload it (Ruby autoload only works for module/class constants, not
   # for string constants like `Expressir::VERSION`).
   module Version
-    VERSION = "2.4.2".freeze
+    VERSION = "2.4.3".freeze
   end
 end

data/lib/expressir.rb

@@ -1,5 +1,7 @@
 require "lutaml/model"
-require "liquid" # To enable Lutaml::Model::Liquefiable
+# Liquid is intentionally NOT required here: lutaml-model's Liquefiable
+# lazily loads it on first #to_liquid (lutaml-model#800), keeping ~170ms
+# off the boot of every consumer that never renders Liquid templates.
 
 # ..........................................................
 # https://bugs.ruby-lang.org/issues/19319
@@ -21,24 +23,6 @@ else
 end
 
 module Expressir
-  # yeptris mingw builds crash once loaded (`uninitialized constant
-  # Yeptris::FFI::NODE_SCALAR`, leptris/yeptris#318) and the gem rebinds
-  # core YAML on require, so merely having it in the bundle breaks every
-  # Hash#to_yaml on Windows. Pinning the portable adapters stops
-  # lutaml-model's bundle-based autodetection from loading yeptris there;
-  # other platforms keep the native engine. Revisit when yeptris ships a
-  # working mingw build.
-  def self.select_serialization_engines(windows: Gem.win_platform?)
-    return unless windows
-
-    Lutaml::Model::Config.configure do |config|
-      config.yaml_adapter_type = :standard
-      config.json_adapter_type = :standard
-    end
-  end
-
-  select_serialization_engines
-
   # Namespace modules - autoload loads the namespace file which contains
   # autoload definitions for classes within that namespace
   autoload :Config, "#{__dir__}/expressir/config"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expressir
 version: !ruby/object:Gem::Version
-  version: 2.4.2
+  version: 2.4.3
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-18 00:00:00.000000000 Z
+date: 2026-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64