polytypo 1.1.0 → 1.3.0

data/lib/polytypo/engine/origin.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "codepoints"
+
+module Polytypo
+  # One entry of Polytypo.analyze's result, in input coordinates (analyze.md section 2):
+  # +rule_id+ is a rule id from spec/rules/order.json, +start+/+end+ are code-point offsets into
+  # the input (inclusive/exclusive), and +before+/+after+ are the text on either side of that one
+  # edit. +start+ == +end+ is a pure insertion, and +before+ is then empty.
+  #
+  # Public API, so it is named in this namespace rather than in Engine, where it is built.
+  Change = Data.define(:rule_id, :start, :end, :before, :after)
+
+  module Engine
+    # analyze.md section 2: every reported offset is a code-point offset into the input the
+    # caller passed, in every mode. The rules, however, run over an array that is not the input
+    # -- in "text" mode edits from earlier rules have already shifted it, and in "html"/"markdown"
+    # mode it is the marker-joined concatenation of the processable spans (modes.md 3.5). This
+    # module carries the one structure that bridges the two: an origin map, parallel to the
+    # current code-point array, holding the input offset each code point came from, or NO_ORIGIN
+    # for one the pipeline itself produced. Mirrors polytypo-js's src/engine/origin.ts.
+    module Origin
+      NO_ORIGIN = -1
+
+      # The input offset an edit boundary at +index+ addresses. Synthetic code points have no
+      # origin of their own, so the scan runs forward to the first that has one -- an insertion
+      # between two earlier insertions still lands where the next real character is. Falling off
+      # the end means the boundary is at the end of the input.
+      def self.origin_at(origin, index, input_length)
+        (index...origin.length).each do |i|
+          return origin[i] unless origin[i] == NO_ORIGIN
+        end
+        input_length
+      end
+
+      # The origin map for the array Edits.apply_edits is about to produce. A replacement of
+      # equal length keeps its origins position by position, which is what makes a conversion
+      # (U+0020 -> U+00A0) still point at the character it converted; anything longer is
+      # synthetic beyond the positions it covers.
+      def self.apply_edits_to_origin(origin, edits)
+        return origin.dup if edits.empty?
+
+        out = []
+        cursor = 0
+        edits.each do |edit|
+          out.concat(origin[cursor...edit.start])
+          edit.replacement.each_index do |k|
+            source = edit.start + k
+            out << (source < edit.end ? origin[source] : NO_ORIGIN)
+          end
+          cursor = edit.end
+        end
+        out.concat(origin[cursor..])
+        out
+      end
+
+      # One rule's edits, in the coordinates that rule saw, rendered as Changes in input
+      # coordinates. +before+ is the text this rule replaced and +after+ what it replaced it with
+      # (analyze.md section 2), so on a text two rules have both touched, +before+ is what the
+      # second rule saw rather than what the caller typed -- section 5 says so and shows the
+      # French case where it matters.
+      def self.record_changes(cp, edits, origin, input_length, rule_id)
+        edits.map do |edit|
+          Polytypo::Change.new(
+            rule_id: rule_id,
+            start: origin_at(origin, edit.start, input_length),
+            end: origin_at(origin, edit.end, input_length),
+            before: Codepoints.from_codepoints(cp[edit.start...edit.end]),
+            after: Codepoints.from_codepoints(edit.replacement)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/polytypo/engine/pipeline.rb

@@ -2,13 +2,62 @@
 
 require_relative "edits"
 require_relative "locale"
+require_relative "origin"
 require_relative "registry"
 require_relative "../errors"
 
 module Polytypo
   module Engine
     # Per-call context every rule reads, alongside the code-point array and the locale data.
-    RuleContext = Struct.new(:mode, :dialect, :locale, keyword_init: true)
+    # :narrow_target is nbsp.md 3.1a's NARROW-TARGET, already resolved to a code point: U+202F
+    # by default, U+00A0 when the caller passed narrow_nbsp: "nbsp". A rule reads a code point
+    # and never the option, so the string never reaches the pipeline.
+    RuleContext = Struct.new(:mode, :dialect, :locale, :narrow_target, keyword_init: true)
+
+    # nbsp.md 3.1a: resolve the narrow_nbsp option to the code point the rule writes. Checked
+    # immediately after mode and before rules (ARCHITECTURE.md 7) -- the two checks that read
+    # nothing but the call itself come first -- and it runs whether or not `nbsp` is enabled, so
+    # a misspelled value still raises rather than being silently ignored.
+    NARROW_NO_BREAK_SPACE = 0x202F
+    NO_BREAK_SPACE = 0x00A0
+
+    def self.resolve_narrow_target(value)
+      return NARROW_NO_BREAK_SPACE if value.nil? || value == "narrow"
+      return NO_BREAK_SPACE if value == "nbsp"
+
+      raise Polytypo::Error.new(
+        Polytypo::CODE_INVALID_OPTION,
+        "Unknown narrow_nbsp #{value.inspect}. Expected \"narrow\" or \"nbsp\".",
+      )
+    end
+
+    # modes.md 3.8.2: "yaml" mode's `keys` option, resolved once at the call boundary.
+    #
+    # It has no default, for the reason `dialect` has none. YAML is a data format with islands of
+    # prose in it, and nothing in its syntax marks them -- `description` holds a sentence and
+    # `run` holds a shell script, spelled identically -- so a default would be a guess about the
+    # schema above the document. An empty list is legal: "process nothing" is a choice a caller
+    # may make, not an error. Checked after locale, last of the option checks, alongside dialect.
+    def self.resolve_yaml_keys(value)
+      unless value.is_a?(Array)
+        raise Polytypo::Error.new(
+          Polytypo::CODE_INVALID_OPTION,
+          '"keys" is required when mode is "yaml" and must be an Array of Strings ' \
+          "(modes.md 3.8.2). Received #{value.inspect}.",
+        )
+      end
+
+      value.each do |key|
+        next if key.is_a?(String)
+
+        raise Polytypo::Error.new(
+          Polytypo::CODE_INVALID_OPTION,
+          "\"keys\" must contain only Strings; received #{key.inspect}.",
+        )
+      end
+
+      value.to_set
+    end
 
     # Resolves the locale, builds the rule plan, and runs each enabled rule in
     # spec/rules/order.json order over a code-point array, applying its edits before the next
@@ -56,6 +105,28 @@ module Polytypo
         end
         current
       end
+
+      # run_rules, keeping the edits instead of discarding them (analyze.md section 1: same
+      # pipeline, same order, reporting rather than applying). The origin map travels alongside
+      # the array so every change comes back in input coordinates, and +filter_edits+ is the hook
+      # the span-runner needs for modes.md 3.4's boundary filters, passed as a block -- text mode
+      # passes none and gets the identity.
+      def self.run_rules_recording(cp, plan, locale_data, ctx, origin, input_length)
+        current = cp
+        current_origin = origin
+        changes = []
+        plan.each do |rule_id|
+          fn = Registry.rule(rule_id)
+          produced = fn.call(current, locale_data, ctx)
+          edits = block_given? ? yield(current, produced) : produced
+          next if edits.empty?
+
+          changes.concat(Origin.record_changes(current, edits, current_origin, input_length, rule_id))
+          current_origin = Origin.apply_edits_to_origin(current_origin, edits)
+          current = Edits.apply_edits(current, edits, rule_id)
+        end
+        changes
+      end
     end
   end
 end

data/lib/polytypo/engine/rules/apostrophe.rb

@@ -9,7 +9,7 @@ require_relative "../registry"
 module Polytypo
   module Engine
     module Rules
-      # spec/rules/apostrophe.md (spec 0.5.0), order 50.
+      # spec/rules/apostrophe.md (spec 1.2.0), order 50.
       #
       # Converts a straight U+0027 to U+2019 where it is genuinely an apostrophe: a contraction,
       # an elision, a possessive, or a decade elision. Runs immediately after `quotes` (order 40)
@@ -47,6 +47,10 @@ module Polytypo
           0x2D, 0x2011, 0x2013, 0x2014
         ].freeze
 
+        # OPENQUOTE is apostrophe.md 3.1 OPENQUOTE (spec 1.2.0): the quotation glyphs of OPENISH,
+        # without its brackets, its dashes and Engine::MARKER. Read only by case 3a.
+        OPENQUOTE = [0xAB, 0x2018, 0x201A, 0x201B, 0x201C, 0x201E, 0x201F, 0x2039].freeze
+
         BREAK = [0x0A, 0x0D, 0x0B, 0x0C, 0x85, 0x2028, 0x2029, Engine::LINE_MARKER].freeze
 
         # SPACELIKE, including Engine::LINE_MARKER as a member of BREAK for every rule everywhere
@@ -81,6 +85,11 @@ module Polytypo
             return true
           end
 
+          # Case 3a (spec 1.2.0) -- elision before a quotation: `d'« urine »`, `l'“idea”`. Case 3
+          # misses it because an opening quotation glyph is not in CLOSEISH; `f'(x)` stays straight
+          # because a bracket is not in OPENQUOTE.
+          return true if UnicodeUtil.letter?(left) && OPENQUOTE.include?(right)
+
           # Case 4 -- leading elision: `'90s`, `'tis`, `'em`, `'n'` (the leading mark). The
           # replacement is U+2019, never U+2018 -- a leading elision is a raised comma, not an
           # opening quotation mark, and `quotes` has already had its chance to claim the mark as a

data/lib/polytypo/engine/rules/dash_shared.rb

@@ -98,6 +98,21 @@ module Polytypo
           cp >= DIGIT_ZERO && cp <= DIGIT_NINE
         end
 
+        # ranges.md 3.2a CLOSED-SYMBOL (spec 1.3.0): the symbols conventionally written closed up
+        # to a number. A literal code-point set, never a Unicode category test -- a category makes
+        # the verdict depend on which Unicode version a runtime was built against, and the five
+        # runtimes must agree. The currency part is the U+20A0-U+20CF block by its own bounds, not
+        # the subset assigned in some Unicode version: the assigned subset drifts between
+        # releases, block bounds do not.
+        def closed_up_symbol?(cp)
+          return true if cp == 0x0024
+          return true if cp >= 0x00A2 && cp <= 0x00A5
+          return true if cp >= 0x20A0 && cp <= 0x20CF
+          return true if cp == 0x0025 || cp == 0x2030 || cp == 0x2031
+
+          cp == 0x00B0
+        end
+
         # BREAK, including Engine::LINE_MARKER: a member of BREAK for every rule everywhere
         # (modes.md 3.2).
         def break?(cp)
@@ -207,6 +222,63 @@ module Polytypo
           cp[i]
         end
 
+        # ranges.md 3.2a: a token's flanks after the closed-up-symbol walk, with the digit runs
+        # the guards and the replacement then read. `left`/`right` are L\u2032/R\u2032;
+        # `outer_left`/`outer_right` are the matched outer symbols' indices, or nil.
+        RangeFlanks = Data.define(:left, :right, :a, :b, :outer_left, :outer_right)
+
+        # ranges.md 3.2 and 3.2a -- is this token a range candidate, and where are its digit runs?
+        # nil means it is not one, which is the signal that the token belongs to `dashes`.
+        #
+        # Both sides are decided from the ORIGINAL left/right, simultaneously; a side consumes a
+        # closed-up symbol only when the opposite member repeats the same code point. An unmatched
+        # symbol leaves the flank a non-DIGIT, so "$15-\u20ac20" and "15-$20" are not candidates
+        # and do not change hands.
+        def range_flanks(cp, left, right)
+          n = cp.length
+          inner_right = if right >= 0 && right < n && closed_up_symbol?(cp[right]) &&
+                           right + 1 < n && digit?(cp[right + 1])
+                          cp[right]
+                        end
+          inner_left = if left.positive? && left < n && closed_up_symbol?(cp[left]) &&
+                          digit?(cp[left - 1])
+                         cp[left]
+                       end
+
+          l = inner_left.nil? ? left : left - 1
+          r = inner_right.nil? ? right : right + 1
+          return nil if l.negative? || l >= n || r.negative? || r >= n
+          return nil unless digit?(cp[l]) && digit?(cp[r])
+
+          a = l
+          a -= 1 while a.positive? && digit?(cp[a - 1])
+          b = r
+          b += 1 while b + 1 < n && digit?(cp[b + 1])
+
+          outer_left = nil
+          unless inner_right.nil?
+            outer_left = effective_index(cp, a - 1, -1)
+            return nil if outer_left.nil? || cp[outer_left] != inner_right
+          end
+          outer_right = nil
+          unless inner_left.nil?
+            outer_right = effective_index(cp, b + 1, 1)
+            return nil if outer_right.nil? || cp[outer_right] != inner_left
+          end
+
+          RangeFlanks.new(left: l, right: r, a: a, b: b, outer_left: outer_left,
+                          outer_right: outer_right)
+        end
+
+        # T1's reach is transparent to one CLOSED-SYMBOL on either end of a digit run (spec
+        # 1.3.0): the run it protects may be a range member carrying an outer symbol.
+        def skip_closed_up_symbol(cp, from, step)
+          i = effective_index(cp, from, step)
+          return from if i.nil? || !closed_up_symbol?(cp[i])
+
+          i + step
+        end
+
         # dashes.md 3.2 step 8 (T1) -- the spacing-transition guard. A tight token must not become
         # spaced when doing so would insert a U+0020 between itself and a digit run that has
         # another dash on its far side, read through effective neighbours (3.2b). Shared because a
@@ -215,10 +287,17 @@ module Polytypo
         def spacing_transition_blocked?(cp, left, right)
           n = cp.length
 
+          # Spec 1.3.0, position p1: step over a CLOSED-SYMBOL between the token and the run.
+          left -= 1 if left >= 0 && left < n && closed_up_symbol?(cp[left]) && left.positive? &&
+                       digit?(cp[left - 1])
+          right += 1 if right >= 0 && right < n && closed_up_symbol?(cp[right]) &&
+                        right + 1 < n && digit?(cp[right + 1])
+
           if left >= 0 && left < n && digit?(cp[left])
             d = left
             d -= 1 while d.positive? && digit?(cp[d - 1])
-            i1 = effective_index(cp, d - 1, -1)
+            # Position p2: and over one at the far end of the run.
+            i1 = effective_index(cp, skip_closed_up_symbol(cp, d - 1, -1), -1)
             one = i1.nil? ? Polytypo::Engine::NONE : cp[i1]
             two = i1.nil? ? Polytypo::Engine::NONE : effective_neighbour(cp, i1 - 1, -1)
             return true if dash_union?(one)
@@ -228,7 +307,7 @@ module Polytypo
           if right >= 0 && right < n && digit?(cp[right])
             d = right
             d += 1 while d + 1 < n && digit?(cp[d + 1])
-            i1 = effective_index(cp, d + 1, 1)
+            i1 = effective_index(cp, skip_closed_up_symbol(cp, d + 1, 1), 1)
             one = i1.nil? ? Polytypo::Engine::NONE : cp[i1]
             two = i1.nil? ? Polytypo::Engine::NONE : effective_neighbour(cp, i1 + 1, 1)
             return true if dash_union?(one)
@@ -309,7 +388,10 @@ module Polytypo
             left_cp = cp[left]
             right_cp = cp[right]
 
-            next if crossed_joiner && !(digit?(left_cp) && digit?(right_cp))
+            # dashes.md 3.2a: re-entry across a joiner is only ever a bound range `ranges`
+            # produced on an earlier pass. Spec 1.3.0 reads that condition after the
+            # closed-up-symbol walk, so a bound range carrying symbols re-enters the same way.
+            next if crossed_joiner && range_flanks(cp, left, right).nil?
             next if break?(left_cp) || break?(right_cp)
 
             # dashes.md 3.2 step 6 -- isolation guard.

data/lib/polytypo/engine/rules/dashes.rb

@@ -72,7 +72,10 @@ module Polytypo
           DashShared.find_tokens(cp).each do |token|
             # A digit-flanked token is `ranges`' territory, never `dashes`' -- declined
             # unconditionally, whether or not `ranges` is enabled (operator decision, spec 0.5.0).
-            next if DashShared.digit?(token.left_cp) && DashShared.digit?(token.right_cp)
+            # A range candidate is `ranges`' territory, never `dashes`'. Since spec 1.3.0 a
+            # candidate may carry a matched closed-up symbol on a flank (ranges.md 3.2a), which
+            # is why this is range_flanks rather than a digit test on both flanks.
+            next unless DashShared.range_flanks(cp, token.left, token.right).nil?
 
             # dashes.md 3.4 P5 -- authored en-dash mark-identity veto (spec 0.6.0). A run
             # consisting of exactly one U+2013 is declined unconditionally: every locale, tight or

data/lib/polytypo/engine/rules/nbsp.rb

@@ -9,7 +9,7 @@ require_relative "../../errors"
 module Polytypo
   module Engine
     module Rules
-      # `nbsp` -- spec/rules/nbsp.md (spec 0.6.0), order 70 (last).
+      # `nbsp` -- spec/rules/nbsp.md (spec 1.2.0), order 70 (last).
       #
       # Ten sub-rules, N1 through N10, evaluated in that fixed order (3.2); each produces
       # candidate edits keyed by the index of the space (or insertion point) it claims, and the
@@ -34,10 +34,34 @@ module Polytypo
         SQUARE_CLOSE = 0x5D
         BRACE_CLOSE = 0x7D
 
+        SEMICOLON = 0x3B
+        AMPERSAND = 0x26
+        HASH = 0x23
+        # The longest HTML named reference is 31 code points ("CounterClockwiseContourIntegral").
+        MAX_CHARACTER_REFERENCE_NAME = 32
+
         EN_DASH = 0x2013
         EM_DASH = 0x2014
         ELLIPSIS = 0x2026
 
+        # nbsp.md 3.3 step 4: do the code points left of this ";" have the shape of a character
+        # reference? A bounded left walk over ASCII alphanumerics, optionally one "#", then "&".
+        # Shape, not the HTML named-reference table -- declining on "&notaname;" costs nothing,
+        # and no runtime carries thousands of entries for it.
+        def self.ends_character_reference?(cp, index)
+          j = index - 1
+          j -= 1 while j >= 0 && ascii_alnum?(cp[j])
+          length = index - 1 - j
+          return false if length < 1 || length > MAX_CHARACTER_REFERENCE_NAME
+
+          j -= 1 if j >= 0 && cp[j] == HASH
+          j >= 0 && cp[j] == AMPERSAND
+        end
+
+        def self.ascii_alnum?(cp)
+          (cp >= 0x30 && cp <= 0x39) || (cp >= 0x41 && cp <= 0x5A) || (cp >= 0x61 && cp <= 0x7A)
+        end
+
         # cp[i], or NONE if i is out of bounds -- the spec's own boundary value.
         def self.at(cp, i)
           return NONE if i.negative? || i >= cp.length
@@ -54,16 +78,7 @@ module Polytypo
         end
 
         # BREAK (nbsp.md 3.1), including LINE_MARKER -- a member of BREAK for every rule,
-        # everywhere (modes.md 3.2).
-        #
-        # MARKER is deliberately NOT a member here, and openish?/closeish? below do not add it
-        # either. modes.md 3.3's table says nbsp's OPENISH/CLOSEISH include the span-boundary
-        # MARKER, the same way quotes' and apostrophe's do -- but the JS reference
-        # implementation's own isBreak/isOpenish/isCloseish never test for MARKER, only
-        # LINE_MARKER via isBreak. That is a documented, preserved discrepancy (tracked, not
-        # resolved, in the roadmap), carried forward here unchanged rather than "corrected"
-        # against the table, for cross-runtime consistency with the already-shipped JS, Python
-        # and Go ports.
+        # everywhere (modes.md 3.2). MARKER is not a member of BREAK; see closeish? below.
         def self.break?(cp)
           cp == 0x0A || cp == 0x0D || cp == 0x0B || cp == 0x0C || cp == 0x85 ||
             cp == 0x2028 || cp == 0x2029 || cp == LINE_MARKER
@@ -107,6 +122,8 @@ module Polytypo
           :before_punctuation, :narrow_before_punctuation, :short_words, :abbreviations,
           :units, :before_number, :before_word, :symbols, :initial_binding, :opens, :closes,
           :quote_pairs,
+          # nbsp.md 3.1a NARROW-TARGET: what N2 writes, and what N8 writes for a narrow-nbsp pair.
+          :narrow_target,
           keyword_init: true,
         )
 
@@ -130,7 +147,7 @@ module Polytypo
         # Resolves the locale's nbsp and quotes fields to code points once. nbsp.md 2 lists the
         # fields; 2.1 explains why the mechanism (U+00A0 vs U+202F, convert-only vs insert)
         # lives here and not in the locale file.
-        def self.prepare(locale_data)
+        def self.prepare(locale_data, narrow_target = NNBSP)
           data = locale_data["nbsp"]
           before_punctuation = data["beforePunctuation"].map { |e| single_code_point(e, "beforePunctuation") }
           narrow_before_punctuation =
@@ -176,7 +193,7 @@ module Polytypo
             # (7.5).
             next if open_cp == close_cp
 
-            target = pair["innerSpace"] == "nbsp" ? NBSP : NNBSP
+            target = pair["innerSpace"] == "nbsp" ? NBSP : narrow_target
             quote_pairs << QuoteTarget.new(open_cp, close_cp, target)
           end
 
@@ -193,17 +210,24 @@ module Polytypo
             opens: opens,
             closes: closes,
             quote_pairs: quote_pairs,
+            narrow_target: narrow_target,
           )
         end
 
         # OPENISH / CLOSEISH (nbsp.md 3.1): the ASCII brackets plus every locale quote glyph.
-        # See break?'s comment for why MARKER is not a member here.
+        #
+        # Since spec 1.2.0 the span boundary MARKER is a member of CLOSEISH and not of OPENISH
+        # (nbsp.md 3.1 and 7 item 12, modes.md 3.3). CLOSEISH is read only by N1/N2's right-context
+        # guard, where membership lets French `<strong>gel :</strong>` keep its no-break space
+        # after `spaces` deletes the U+0020. OPENISH stays marker-free: with the marker in it,
+        # N1/N2's quote-glyph guard would decline `<em>non</em> ! Oui`, and the left-boundary
+        # tests of N3, N7, N9, N10 would widen at span edges.
         def self.openish?(prep, cp)
           prep.opens.include?(cp)
         end
 
         def self.closeish?(prep, cp)
-          prep.closes.include?(cp)
+          cp == MARKER || prep.closes.include?(cp)
         end
 
         def self.mark?(prep, cp)
@@ -298,7 +322,12 @@ module Polytypo
             next if openish?(prep, left)
             next if left != NONE && space_like?(left) && openish?(prep, at(cp, i - 2))
 
-            # Step 4.
+            # Step 4 (spec 1.3.0) -- character-reference guard. text mode has no markup concept,
+            # so a locale listing ";" used to insert before the ";" that *ends* a reference and
+            # "Bonjour&#160;: oui" stopped being what it was (nbsp.md 3.3 step 4).
+            next if cp[i] == SEMICOLON && ends_character_reference?(cp, i)
+
+            # Step 5.
             next if left == target
 
             if left == SPACE || left == other
@@ -584,12 +613,16 @@ module Polytypo
         # yielding the index to a lower-priority sub-rule. Sub-rules wanting *different* code
         # points at a shared index are therefore made disjoint by construction elsewhere
         # (N1/N2's quote-glyph guard, nbsp.md 3.10.1) rather than relying on ordering alone.
-        def self.scan(cp, locale_data, _ctx)
-          prep = prepare(locale_data)
+        def self.scan(cp, locale_data, ctx)
+          prep = prepare(locale_data, ctx.narrow_target)
           claims = Array.new(cp.length + 1)
 
-          punctuation_sub_rule(cp, prep, claims, prep.before_punctuation, NBSP, NNBSP)       # N1
-          punctuation_sub_rule(cp, prep, claims, prep.narrow_before_punctuation, NNBSP, NBSP) # N2
+          punctuation_sub_rule(cp, prep, claims, prep.before_punctuation, NBSP, NNBSP) # N1
+          # N2's target is NARROW-TARGET (nbsp.md 3.1a); `other` is the NOBREAK member that is
+          # not the target, which is what the sub-rule converts. With the substitution on, N2 and
+          # N1 want the same character -- never different ones.
+          other = prep.narrow_target == NBSP ? NNBSP : NBSP
+          punctuation_sub_rule(cp, prep, claims, prep.narrow_before_punctuation, prep.narrow_target, other) # N2
           short_words_sub_rule(cp, prep, claims)                                             # N3
           abbreviations_sub_rule(cp, prep, claims)                                           # N4
           units_sub_rule(cp, prep, claims)                                                   # N5

data/lib/polytypo/engine/rules/ranges.rb

@@ -38,17 +38,19 @@ module Polytypo
           true
         end
 
-        # ranges.md 3.3, G1-G5. left/right are the token's post-joiner-walk flank indices (both
-        # already known to be DIGIT by the caller).
-        def guards_pass?(cp, left, right)
-          n = cp.length
-          a = left
-          a -= 1 while a.positive? && DashShared.digit?(cp[a - 1])
-          b = right
-          b += 1 while b + 1 < n && DashShared.digit?(cp[b + 1])
-
-          before = DashShared.effective_neighbour(cp, a - 1, -1)
-          after = DashShared.effective_neighbour(cp, b + 1, 1)
+        # ranges.md 3.2, G1-G5, over the flanks and digit runs 3.2a's walk produced. before/after
+        # read past a matched outer closed-up symbol, so G1-G3 judge the text in front of the
+        # whole member rather than the symbol itself -- which is what declines "US$15-$20" on G1.
+        def guards_pass?(cp, flanks)
+          left = flanks.left
+          right = flanks.right
+          a = flanks.a
+          b = flanks.b
+
+          before_from = flanks.outer_left || a
+          after_from = flanks.outer_right || b
+          before = DashShared.effective_neighbour(cp, before_from - 1, -1)
+          after = DashShared.effective_neighbour(cp, after_from + 1, 1)
 
           # G1 -- no letter adjacency.
           return false if Polytypo::Engine::UnicodeUtil.letter?(before)
@@ -78,13 +80,13 @@ module Polytypo
           style = locale_data["dash"]["range"]
 
           DashShared.find_tokens(cp).each do |token|
-            # ranges.md 3.2 -- a range candidate iff both flanks are DIGIT. `ranges` never
-            # processes any other token shape; that is `dashes`' territory, and `dashes` declines
-            # a digit-flanked token unconditionally too (operator decision, spec 0.5.0) -- neither
-            # rule reinterprets the other's shape, whether or not `ranges` is enabled.
-            next unless DashShared.digit?(token.left_cp) && DashShared.digit?(token.right_cp)
+            # ranges.md 3.2, 3.2a -- a candidate iff both flanks are DIGIT once a matched
+            # closed-up symbol has been walked over. Anything else is `dashes`' territory, and
+            # `dashes` declines a candidate unconditionally too (operator decision, spec 0.5.0).
+            flanks = DashShared.range_flanks(cp, token.left, token.right)
+            next if flanks.nil?
 
-            next unless guards_pass?(cp, token.left, token.right)
+            next unless guards_pass?(cp, flanks)
 
             # "none": the locale has no verified range convention, so nothing is substituted --
             # not a fallback to dash.parenthetical, nothing (ranges.md 2).
@@ -92,12 +94,14 @@ module Polytypo
 
             if DashShared.spaced_style?(style)
               # T1: a tight token may not become spaced across a digit run that has a far dash.
+              # T1/T2 read the walked flanks: ranges.md 3.2a makes cp[L']/cp[R'] what every
+              # shared guard sees once a closed-up symbol has been consumed.
               next if token.lsp.zero? && token.rsp.zero? &&
-                      DashShared.spacing_transition_blocked?(cp, token.left, token.right)
+                      DashShared.spacing_transition_blocked?(cp, flanks.left, flanks.right)
 
               # T2: the emitted U+0020 must not land where `spaces` (order 10) would delete it.
-              next if DashShared.strip_before_or_close_bracket?(token.right_cp)
-              next if DashShared.open_bracket?(token.left_cp)
+              next if DashShared.strip_before_or_close_bracket?(cp[flanks.right])
+              next if DashShared.open_bracket?(cp[flanks.left])
             end
 
             # ranges.md 3.3.1: never make an edit whose entire content is invisible. Try the

data/lib/polytypo/engine/rules/spaces.rb

@@ -107,10 +107,17 @@ module Polytypo
         # after any edit had been applied would break the Chicago spaced ellipsis
         # "Hello . . .", where every dot is a lone dot at decision time and all three spaces
         # must still strip.
+        #
+        # Spec 1.2.0's word-start clause: a single dot directly followed by a letter or an ASCII
+        # digit starts a token (".NET", ".env", ".5"), so "Use .NET" keeps its space. A span
+        # boundary marker after the dot is neither, so "a .</em>" still strips.
         def self.lone_dot?(cp, e)
           return true if at(cp, e) != FULL_STOP
 
-          !dotlike?(at(cp, e + 1))
+          after = at(cp, e + 1)
+          return false if UnicodeUtil.letter?(after) || digit_ascii?(after)
+
+          !dotlike?(after)
         end
 
         def self.digit_ascii?(value)

data/lib/polytypo/errors.rb

@@ -10,6 +10,9 @@ module Polytypo
   CODE_MALFORMED_LOCALE_DATA = "POLYTYPO_MALFORMED_LOCALE_DATA"
   CODE_RULE_CONTRACT = "POLYTYPO_RULE_CONTRACT"
   CODE_MALFORMED_INPUT = "POLYTYPO_MALFORMED_INPUT"
+  # Spec 1.3.0. Deliberately general: every option added from 1.3.0 on shares this code, while
+  # `mode` and `dialect` keep their own because callers branch on them.
+  CODE_INVALID_OPTION = "POLYTYPO_INVALID_OPTION"
 
   # The only error type Transform ever raises. One class is enough: the stable machine-readable
   # +code+ is the contract, not the exception type or the message text.

data/lib/polytypo/modes/runner.rb

@@ -2,6 +2,7 @@
 
 require_relative "spans"
 require_relative "../engine/edits"
+require_relative "../engine/pipeline"
 require_relative "../engine/registry"
 
 module Polytypo
@@ -52,6 +53,22 @@ module Polytypo
         out.concat(source_cp[cursor..])
         out.pack("U*")
       end
+
+      # run_over_spans, reporting instead of applying (analyze.md section 1). The span table
+      # supplies the origin map, so every change comes back in DOCUMENT coordinates -- analyze.md
+      # section 6 names a runtime that reports span-local offsets here as the mistake that passes
+      # every text-mode test.
+      def self.analyze_over_spans(source_cp, spans, plan, locale_data, ctx)
+        normalized = Spans.normalize_spans(spans)
+        return [] if normalized.empty?
+
+        Engine::Pipeline.run_rules_recording(
+          Spans.concatenate_spans(source_cp, normalized),
+          plan, locale_data, ctx,
+          Spans.origin_of_spans(normalized),
+          source_cp.length
+        ) { |current, edits| Spans.filter_boundary_edits(current, edits, Spans.span_ranges_of(current)) }
+      end
     end
   end
 end