polytypo 1.0.0

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "dash_shared"
+require_relative "../edits"
+require_relative "../registry"
+require_relative "../unicode_util"
+
+module Polytypo
+  module Engine
+    module Rules
+      # `ranges` -- spec/rules/ranges.md, order 25. Explicit opt-in: off by default
+      # (order.json's "default": "off" for this rule id; the pipeline's rule-plan resolution, not
+      # this file, is what enforces that). Split out of `dashes` (spec 0.5.0) -- see ranges.md 1
+      # and dashes.md 7.11 for why this is opt-in rather than a bounded structural fix: separating
+      # a genuine numeric range (`5-10`) from a compound label sharing the identical shape
+      # (`Figure 5-10`) needs the preceding word, which is exactly the open-ended, per-locale
+      # context this project's rules are built never to consult.
+      #
+      # This module's own behaviour does not depend on whether the rule is enabled -- enable/disable
+      # is the pipeline's concern (a rule's scan function only runs when it is active).
+      #
+      # Explicit index-based scanning only: no regex anywhere, and every index addresses the
+      # code-point array, never a native string (ARCHITECTURE.md 4.1, 4.2).
+      module Ranges
+        SOLIDUS = 0x2f
+
+        module_function
+
+        # ranges.md 3.3 G5: equal-length ASCII digit runs compare lexicographically, so no integer
+        # arithmetic (and no locale-dependent parsing) is needed.
+        def non_decreasing?(cp, left_start, right_start, length)
+          (0...length).each do |i|
+            l = cp[left_start + i]
+            r = cp[right_start + i]
+            return true if l < r
+            return false if l > r
+          end
+          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)
+
+          # G1 -- no letter adjacency.
+          return false if Polytypo::Engine::UnicodeUtil.letter?(before)
+
+          # G2 -- no chain: an ISO date, an ISBN or a phone number always trips this. This guard
+          # reads the input as it stood before this rule (or `dashes`) made any edit in this
+          # pipeline pass -- ranges.md 4's own reasoning for why `ranges` must run before `dashes`.
+          return false if DashShared.dash_union?(before)
+          return false if DashShared.dash_union?(after)
+
+          # G3 -- not part of a decimal or a path.
+          return false if before == DashShared::FULL_STOP || before == DashShared::COMMA || before == SOLIDUS
+          return false if after == SOLIDUS
+
+          # G4 -- run lengths: equal, or the directional (1,2) branch with no leading zero on Rrun.
+          left_length = left - a + 1
+          right_length = b - right + 1
+          return true if left_length == 1 && right_length == 2 && cp[right] != DashShared::DIGIT_ZERO
+          return false if left_length != right_length
+
+          # G5 -- non-decreasing (sound only because G4 guarantees equal length in this branch).
+          non_decreasing?(cp, a, right, left_length)
+        end
+
+        def scan(cp, locale_data, _ctx)
+          edits = []
+          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)
+
+            next unless guards_pass?(cp, token.left, token.right)
+
+            # "none": the locale has no verified range convention, so nothing is substituted --
+            # not a fallback to dash.parenthetical, nothing (ranges.md 2).
+            next if style == "none"
+
+            if DashShared.spaced_style?(style)
+              # T1: a tight token may not become spaced across a digit run that has a far dash.
+              next if token.lsp.zero? && token.rsp.zero? &&
+                      DashShared.spacing_transition_blocked?(cp, token.left, token.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)
+            end
+
+            # ranges.md 3.3.1: never make an edit whose entire content is invisible. Try the
+            # unbound replacement first; only add the joiner pair if the dash itself is genuinely
+            # changing.
+            unbound = DashShared.build_replacement(style, false)
+            only_binding_would_change = !DashShared.spaced_style?(style) &&
+                                         DashShared.same_content?(cp, token.span_start, token.span_end, unbound)
+            bind = !DashShared.spaced_style?(style) && !only_binding_would_change
+            replacement = bind ? DashShared.build_replacement(style, true) : unbound
+
+            next if DashShared.same_content?(cp, token.span_start, token.span_end, replacement)
+
+            edits << Polytypo::Engine::Edit.new(token.span_start, token.span_end, replacement, "ranges")
+          end
+
+          edits
+        end
+      end
+
+      Polytypo::Engine::Registry.register("ranges", ->(cp, locale_data, ctx) { Ranges.scan(cp, locale_data, ctx) })
+    end
+  end
+end

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

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require_relative "../edits"
+require_relative "../sentinels"
+require_relative "../unicode_util"
+require_relative "../registry"
+
+module Polytypo
+  module Engine
+    module Rules
+      # spec/rules/spaces.md. No regex anywhere (ARCHITECTURE.md section 4.1): a single
+      # left-to-right scan over the code-point array with explicit lookaround by index. Reads no
+      # locale data (spec/rules/spaces.md section 2): behaviour is identical in every locale.
+      module Spaces
+        SPACE = 0x20
+
+        LF = 0x0A
+        CR = 0x0D
+        VT = 0x0B
+        FF = 0x0C
+        NEL = 0x85
+        LS = 0x2028
+        PS = 0x2029
+
+        COMMA = 0x2C
+        FULL_STOP = 0x2E
+        SEMICOLON = 0x3B
+        COLON = 0x3A
+        EXCLAMATION = 0x21
+        QUESTION = 0x3F
+        ELLIPSIS = 0x2026
+
+        PAREN_OPEN = 0x28
+        PAREN_CLOSE = 0x29
+        SQUARE_OPEN = 0x5B
+        SQUARE_CLOSE = 0x5D
+        CURLY_OPEN = 0x7B
+        CURLY_CLOSE = 0x7D
+
+        HYPHEN_MINUS = 0x2D
+        CARET = 0x5E
+        SOLIDUS = 0x2F
+        REVERSE_SOLIDUS = 0x5C
+        VERTICAL_LINE = 0x7C
+        ASTERISK = 0x2A
+        DIGIT_ZERO = 0x30
+        DIGIT_NINE = 0x39
+        LETTER_D_UPPER = 0x44
+        LETTER_D_LOWER = 0x64
+        LETTER_P_UPPER = 0x50
+        LETTER_P_LOWER = 0x70
+        LETTER_O_UPPER = 0x4F
+        LETTER_O_LOWER = 0x6F
+
+        # 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
+
+          cp[i]
+        end
+
+        # BREAK (spaces.md 3.1), including LINE_MARKER: a member of BREAK for every rule,
+        # everywhere (modes.md 3.2).
+        def self.break?(value)
+          value == LF || value == CR || value == VT || value == FF ||
+            value == NEL || value == LS || value == PS || value == LINE_MARKER
+        end
+
+        # STRIP-BEFORE: exactly six code points. U+2026 is deliberately absent -- with it,
+        # "Wait ..." would keep its space here, `ellipsis` would yield "Wait …", and a second
+        # pipeline pass would then strip that space, a composition divergence (spaces.md 3.4).
+        def self.strip_before?(value)
+          value == COMMA || value == FULL_STOP || value == SEMICOLON ||
+            value == COLON || value == EXCLAMATION || value == QUESTION
+        end
+
+        def self.dotlike?(value)
+          value == FULL_STOP || value == ELLIPSIS
+        end
+
+        def self.open_bracket?(value)
+          value == PAREN_OPEN || value == SQUARE_OPEN || value == CURLY_OPEN
+        end
+
+        def self.close_bracket?(value)
+          value == PAREN_CLOSE || value == SQUARE_CLOSE || value == CURLY_CLOSE
+        end
+
+        def self.matching_closer(open)
+          return PAREN_CLOSE if open == PAREN_OPEN
+          return SQUARE_CLOSE if open == SQUARE_OPEN
+
+          CURLY_CLOSE
+        end
+
+        # spaces.md 3.3: "- [ ] item" must not become "- [] item". The run may still collapse to
+        # length 1.
+        def self.empty_bracket_guarded?(left, right)
+          open_bracket?(left) && right == matching_closer(left)
+        end
+
+        # spaces.md 3.4. A run of dots is a different token from a terminal full stop -- a
+        # relative path, a truncation, a typed ellipsis -- and deleting the space before it
+        # merges the run with a preceding abbreviation dot ("See ../docs" -> "See../docs").
+        #
+        # `e` indexes `right` in the input array, and the run is measured there. Measuring it
+        # 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.
+        def self.lone_dot?(cp, e)
+          return true if at(cp, e) != FULL_STOP
+
+          !dotlike?(at(cp, e + 1))
+        end
+
+        def self.digit_ascii?(value)
+          value >= DIGIT_ZERO && value <= DIGIT_NINE
+        end
+
+        # spaces.md 3.6: the recognised "mouth" glyphs of a Western text emoticon.
+        def self.emoticon_mouth?(value)
+          value == PAREN_OPEN || value == PAREN_CLOSE || value == SQUARE_OPEN ||
+            value == SQUARE_CLOSE || value == LETTER_D_UPPER || value == LETTER_D_LOWER ||
+            value == LETTER_P_UPPER || value == LETTER_P_LOWER ||
+            value == LETTER_O_UPPER || value == LETTER_O_LOWER ||
+            value == SOLIDUS || value == REVERSE_SOLIDUS ||
+            value == VERTICAL_LINE || value == ASTERISK
+        end
+
+        # spaces.md 3.6, the emoticon guard's eye side. A colon or semicolon immediately
+        # followed by an optional "nose" and a recognised "mouth" is the eye of a Western text
+        # emoticon (":-)", ":)", ";-)"), not sentence punctuation, and the space in front of it
+        # must survive.
+        #
+        # The mouth must not itself run into a letter or an ASCII digit -- ":Deal" is a colon
+        # before a capitalised word, not a face -- which is the one check needed to keep this
+        # from firing on ordinary prose. `e` indexes `right`, exactly as `lone_dot?` does.
+        def self.emoticon_eye_fires?(cp, e)
+          eye = at(cp, e)
+          return false unless eye == COLON || eye == SEMICOLON
+
+          i = e + 1
+          nose = at(cp, i)
+          i += 1 if nose == HYPHEN_MINUS || nose == CARET
+
+          return false unless emoticon_mouth?(at(cp, i))
+
+          i += 1
+          after = at(cp, i)
+          !UnicodeUtil.letter?(after) && !digit_ascii?(after)
+        end
+
+        # spaces.md 3.6, the mouth side. "(" and "[" are EMOTICON-MOUTH members and
+        # OPEN-BRACKET members at once, so without this the opening-bracket clause deleted the
+        # space after an emoticon the eye side had just recognised: "a :( b" became "a :(b",
+        # and then "a:(b" on a second pass, because a letter after the mouth stops the eye side
+        # firing.
+        #
+        # The walk mirrors the eye side's, backwards from `s`, and needs no trailing check: the
+        # code point after the mouth is the space run itself, which is neither a letter nor a
+        # digit. A nose with no eye behind it is not a face -- EMOTICON-NOSE and EMOTICON-EYE
+        # are disjoint, so the walk cannot mistake one for the other.
+        def self.emoticon_mouth_fires?(cp, s)
+          return false unless emoticon_mouth?(at(cp, s - 1))
+
+          j = s - 2
+          nose = at(cp, j)
+          j -= 1 if nose == HYPHEN_MINUS || nose == CARET
+
+          eye = at(cp, j)
+          eye == COLON || eye == SEMICOLON
+        end
+
+        # spaces.md 3.2 step 5: the replacement length is a pure function of the two bounding
+        # code points, computed once. A two-pass "collapse then strip" formulation would need a
+        # fixed-point loop, which two runtimes would iterate differently.
+        def self.replacement_length(cp, s, e, left, right)
+          # The guard is a clause of this decision, not a "skip the run" branch: "(  )"
+          # collapses to "( )" (spaces.md 3.3, normative reading).
+          return 1 if empty_bracket_guarded?(left, right)
+          return 0 if open_bracket?(left) && !emoticon_mouth_fires?(cp, s)
+          return 0 if close_bracket?(right)
+          return 0 if strip_before?(right) && lone_dot?(cp, e) && !emoticon_eye_fires?(cp, e)
+
+          1
+        end
+
+        # locale_data is unused: order.json declares "localeData": [] for this rule.
+        def self.scan(cp, _locale_data, _ctx)
+          n = cp.length
+          edits = []
+          i = 0
+
+          while i < n
+            if at(cp, i) != SPACE
+              i += 1
+              next
+            end
+
+            s = i
+            e = s
+            e += 1 while e < n && at(cp, e) == SPACE
+            k = e - s
+
+            left = at(cp, s - 1)
+            right = at(cp, e)
+
+            # Boundary guard (3.2 step 4): indentation, Markdown hard breaks and text-unit
+            # edges are structural. A span boundary marker counts as NONE here -- the one place
+            # in the whole spec where a marker is not opaque content, per modes.md 3.3.
+            if left == NONE || Polytypo::Engine.marker?(left) || break?(left) ||
+               right == NONE || Polytypo::Engine.marker?(right) || break?(right)
+              i = e
+              next
+            end
+
+            length = replacement_length(cp, s, e, left, right)
+            if length != k
+              replacement = length.zero? ? [] : [SPACE]
+              edits << Edit.new(s, e, replacement, "spaces")
+            end
+            i = e
+          end
+
+          edits
+        end
+      end
+    end
+
+    Registry.register("spaces", ->(cp, locale_data, ctx) { Rules::Spaces.scan(cp, locale_data, ctx) })
+  end
+end

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

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require_relative "../edits"
+require_relative "../sentinels"
+require_relative "../unicode_util"
+require_relative "../registry"
+
+module Polytypo
+  module Engine
+    module Rules
+      # `symbols` -- spec/rules/symbols.md (spec 0.1.0), order 60.
+      #
+      # Three unrelated substitutions, one left-to-right scan: `(c)`/`(r)`/`(tm)` literals
+      # become (c)/(r)/(tm) signs (3.2); a `DIGIT+ (MUL-LETTER DIGIT+)+` chain becomes
+      # multiplication signs, converted whole or not at all (3.3); the literal `+/-` becomes
+      # plus-minus (3.4). No locale data -- order.json declares "localeData": [] for this rule.
+      # No regex, no case folding anywhere (ARCHITECTURE.md section 4.1, 4.4): the accepted
+      # spellings are enumerated explicitly rather than derived from `downcase`/`upcase`, which
+      # are locale-dependent in the host process (Turkish dotless i).
+      module Symbols
+        PAREN_OPEN = 0x28
+        PAREN_CLOSE = 0x29
+        SQUARE_OPEN = 0x5B
+        SQUARE_CLOSE = 0x5D
+
+        COPYRIGHT = 0xA9
+        REGISTERED = 0xAE
+        TRADEMARK = 0x2122
+        MULTIPLICATION = 0xD7
+
+        SPACE = 0x20
+        NBSP = 0xA0
+        NNBSP = 0x202F
+
+        LOWER_X = 0x78
+        UPPER_X = 0x58
+        CYRILLIC_LOWER_HA = 0x445
+        CYRILLIC_UPPER_HA = 0x425
+        DIGIT_ZERO = 0x30
+        DIGIT_NINE = 0x39
+
+        PLUS = 0x2B
+        SOLIDUS = 0x2F
+        HYPHEN_MINUS = 0x2D
+        PLUS_MINUS = 0xB1
+
+        # 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
+
+          cp[i]
+        end
+
+        def self.digit?(cp)
+          cp >= DIGIT_ZERO && cp <= DIGIT_NINE
+        end
+
+        def self.alnum?(cp)
+          digit?(cp) || UnicodeUtil.letter?(cp)
+        end
+
+        # SPACE u NOBREAK-SPACE (symbols.md 3.1): U+0020, U+00A0, U+202F only -- no tabs, no
+        # other Unicode spaces, no line breaks. Narrower than nbsp's SPACELIKE on purpose: this
+        # rule only needs the spacing a multiplication chain can legally carry.
+        def self.space_like?(cp)
+          cp == SPACE || cp == NBSP || cp == NNBSP
+        end
+
+        # MUL-LETTER (symbols.md 3.1): exactly four code points, enumerated, never case-folded
+        # and never derived from locale data. The Cyrillic pair is unconditional -- U+0445
+        # between two ASCII digits is a Russian dimension typed on a Cyrillic layout or
+        # keyboard-layout debris, and the glyphs are visually identical to the Latin ones in
+        # every font, so no human review can catch a missed conversion.
+        def self.mul_letter?(cp)
+          cp == LOWER_X || cp == UPPER_X || cp == CYRILLIC_LOWER_HA || cp == CYRILLIC_UPPER_HA
+        end
+
+        # One row of the trademark table (symbols.md 3.1). guarded_by_s1 is true only for the
+        # (c)/(r) rows -- the (tm) rows are exempt from S1 (3.2 step 3).
+        TrademarkRow = Struct.new(:literal, :to, :guarded_by_s1)
+
+        # Exhaustive and case-explicit; nothing else matches. Longest literals first (the
+        # 4-code-point (tm) rows before the 3-code-point (c)/(r) rows), per 3.2 step 1.
+        TRADEMARK_TABLE = [
+          TrademarkRow.new([PAREN_OPEN, 0x74, 0x6D, PAREN_CLOSE], TRADEMARK, false), # (tm)
+          TrademarkRow.new([PAREN_OPEN, 0x54, 0x4D, PAREN_CLOSE], TRADEMARK, false), # (TM)
+          TrademarkRow.new([PAREN_OPEN, 0x54, 0x6D, PAREN_CLOSE], TRADEMARK, false), # (Tm)
+          TrademarkRow.new([PAREN_OPEN, 0x74, 0x4D, PAREN_CLOSE], TRADEMARK, false), # (tM)
+          TrademarkRow.new([PAREN_OPEN, 0x63, PAREN_CLOSE], COPYRIGHT, true),        # (c)
+          TrademarkRow.new([PAREN_OPEN, 0x43, PAREN_CLOSE], COPYRIGHT, true),        # (C)
+          TrademarkRow.new([PAREN_OPEN, 0x72, PAREN_CLOSE], REGISTERED, true),       # (r)
+          TrademarkRow.new([PAREN_OPEN, 0x52, PAREN_CLOSE], REGISTERED, true),       # (R)
+        ].freeze
+
+        def self.matches_at?(cp, i, literal)
+          return false if i + literal.length > cp.length
+
+          literal.each_with_index { |want, j| return false if at(cp, i + j) != want }
+          true
+        end
+
+        # symbols.md 3.2. Returns the Edit, or nil when no row matches or a guard rejects the
+        # candidate.
+        def self.trademark_at(cp, i)
+          TRADEMARK_TABLE.each do |row|
+            next unless matches_at?(cp, i, row.literal)
+
+            end_index = i + row.literal.length
+            before = at(cp, i - 1)
+            after = at(cp, end_index)
+
+            # S1 -- left adjacency, (c)/(r) rows only: a one-letter argument list ("f(c)") is
+            # common, "(tm)" tucked against a product name is not a call. The three replacement
+            # signs are listed so that "(c)(r)" converges to "(c)(r)" in one run (symbols.md 5).
+            if row.guarded_by_s1 && before != NONE &&
+               (alnum?(before) || before == PAREN_CLOSE || before == SQUARE_CLOSE ||
+                before == COPYRIGHT || before == REGISTERED || before == TRADEMARK)
+              return nil
+            end
+            # S2 -- right adjacency: "(r)evolution", "(c)ompiler".
+            return nil if after != NONE && alnum?(after)
+            # S3 -- no nesting: "((c))" is ASCII art or code.
+            return nil if before == PAREN_OPEN
+
+            return Edit.new(i, end_index, [row.to], "symbols")
+          end
+          nil
+        end
+
+        # One MUL-LETTER position within a multiplication chain, plus whether it carried a
+        # space on each side (0 or 1 code point -- symbols.md 3.3 never allows more than one).
+        ChainLink = Struct.new(:letter_index, :left_space, :right_space)
+
+        # The result of reading a whole DIGIT+ (MUL-LETTER DIGIT+)+ shape starting at a maximal
+        # digit run (symbols.md 3.3 step 1). end_index is the last code point read, whether or
+        # not any link was completed -- the caller resumes scanning at end_index + 1 either way.
+        # first_run_end is the last digit of the very first digit run, used only by guard M4.
+        Chain = Struct.new(:end_index, :first_run_end, :links)
+
+        # Reads the chain greedily and unconditionally; guard decisions happen afterward in
+        # chain_edits, never here, so the scan shape itself cannot express "how many links
+        # converted" -- only "whole chain or nothing" (symbols.md 3.3 step 2, 5).
+        def self.read_chain(cp, a)
+          p = a
+          p += 1 while digit?(at(cp, p))
+          first_run_end = p - 1
+          end_index = p - 1
+          links = []
+
+          loop do
+            q = p
+            left_space = 0
+            if space_like?(at(cp, q))
+              left_space = 1
+              q += 1
+            end
+            break unless mul_letter?(at(cp, q))
+
+            letter_index = q
+            q += 1
+            right_space = 0
+            if space_like?(at(cp, q))
+              right_space = 1
+              q += 1
+            end
+            break unless digit?(at(cp, q))
+
+            q += 1 while digit?(at(cp, q))
+            links << ChainLink.new(letter_index, left_space, right_space)
+            end_index = q - 1
+            p = q
+          end
+
+          Chain.new(end_index, first_run_end, links)
+        end
+
+        # Applies guards M1-M4 to a chain read by read_chain. Returns the edits, or nil when the
+        # chain is declined whole -- symbols.md 3.3 never half-converts a chain.
+        def self.chain_edits(cp, a, chain)
+          links = chain.links
+          first = links.first
+          return nil if first.nil?
+
+          # M1 -- every link symmetric, and every link agreeing with the first. "5x4 x 3" is
+          # ambiguous input and is declined whole rather than half-converted.
+          sp = first.left_space
+          links.each do |link|
+            return nil if link.left_space != link.right_space
+            return nil if link.left_space != sp
+          end
+
+          # M2/M3 -- the chain's OUTER boundaries, not each link. Applying them per link is
+          # exactly what made the pairwise form reject chains: the letter past the middle digit
+          # run is itself a MUL-LETTER, hence a LETTER.
+          before = at(cp, a - 1)
+          after = at(cp, chain.end_index + 1)
+          return nil if before != NONE && UnicodeUtil.letter?(before)
+          return nil if after != NONE && UnicodeUtil.letter?(after)
+
+          # M4 -- hexadecimal literal veto. Latin lowercase only: a hex literal is never
+          # written with Cyrillic. Inspects the first link alone.
+          if sp.zero? && at(cp, first.letter_index) == LOWER_X &&
+             chain.first_run_end == a && at(cp, a) == DIGIT_ZERO
+            return nil
+          end
+
+          # There is no M5. It was removed rather than extended (symbols.md 3.3 step 7, 7.3).
+          edits = []
+          links.each do |link|
+            j = link.letter_index
+            replacement =
+              sp.zero? ? [MULTIPLICATION] : [at(cp, j - 1), MULTIPLICATION, at(cp, j + 1)]
+            start_index = j - sp
+            end_span = j + sp + 1
+            next if replacement == cp[start_index...end_span]
+
+            edits << Edit.new(start_index, end_span, replacement, "symbols")
+          end
+          edits
+        end
+
+        # symbols.md 3.4. Only the literal "+/-"; the bare "+-" is never converted, in any
+        # context (3.4, 7.11).
+        def self.plus_minus_at(cp, i)
+          return nil if at(cp, i + 1) != SOLIDUS || at(cp, i + 2) != HYPHEN_MINUS
+
+          # F1 -- not a character class: "[+/-]" is a regular expression.
+          return nil if at(cp, i - 1) == SQUARE_OPEN
+
+          # F2 -- numeric context, with one optional intervening space so "+/-5" and "+/- 5"
+          # both work. Without it, prose that names the characters ("lines marked +/- were
+          # edited") is corrupted.
+          j = i + 3
+          j += 1 if at(cp, j) == SPACE
+          return nil unless digit?(at(cp, j))
+
+          Edit.new(i, i + 3, [PLUS_MINUS], "symbols")
+        end
+
+        # symbols.md 3.5: one left-to-right scan. The three branches key on different code
+        # points -- U+0028, a DIGIT, U+002B -- so no two can match at the same index; on a
+        # successful edit the scan continues from the index after the matched span.
+        #
+        # locale_data is unused: order.json declares "localeData": [] for this rule.
+        def self.scan(cp, _locale_data, _ctx)
+          n = cp.length
+          edits = []
+          i = 0
+
+          while i < n
+            current = at(cp, i)
+
+            if current == PAREN_OPEN
+              edit = trademark_at(cp, i)
+              if edit
+                edits << edit
+                i = edit.end
+                next
+              end
+            elsif digit?(current) && !digit?(at(cp, i - 1))
+              # Keyed on the start of a maximal digit run, not on the letter.
+              chain = read_chain(cp, i)
+              chain_result = chain_edits(cp, i, chain)
+              edits.concat(chain_result) if chain_result
+              # Continue past the chain whether or not it converted. A declined chain has no
+              # convertible sub-chain: any sub-chain starts right after a MUL-LETTER, which is
+              # a LETTER, so M2 would reject it too.
+              i = chain.end_index + 1
+              next
+            elsif current == PLUS
+              edit = plus_minus_at(cp, i)
+              if edit
+                edits << edit
+                i = edit.end
+                next
+              end
+            end
+            i += 1
+          end
+
+          edits
+        end
+      end
+    end
+  end
+end
+
+Polytypo::Engine::Registry.register(
+  "symbols",
+  ->(cp, locale_data, ctx) { Polytypo::Engine::Rules::Symbols.scan(cp, locale_data, ctx) },
+)

data/lib/polytypo/engine/rules.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Requiring this file is enough to register every rule id with Registry -- mirrors the other
+# three ports' own "importing the rules package/module is enough, no separate caller-side step"
+# pattern. Order here does not matter (registration order is never pipeline order -- that comes
+# from order.json, ARCHITECTURE.md section 4.5), but dash_shared and quote_ambiguity are required
+# first since dashes/ranges and quotes/apostrophe depend on them.
+require_relative "rules/dash_shared"
+require_relative "rules/quote_ambiguity"
+
+require_relative "rules/spaces"
+require_relative "rules/ellipsis"
+require_relative "rules/ranges"
+require_relative "rules/dashes"
+require_relative "rules/hyphen"
+require_relative "rules/quotes"
+require_relative "rules/apostrophe"
+require_relative "rules/symbols"
+require_relative "rules/nbsp"

data/lib/polytypo/engine/sentinels.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Polytypo
+  module Engine
+    # The three non-code-point values a rule can meet in the array it scans. They live together
+    # and must stay pairwise disjoint (mirrors src/engine/sentinels.ts in the JS reference
+    # implementation and its Python/Go equivalents):
+    #
+    #   - NONE — there is nothing at that index; the array ends here.
+    #   - MARKER — a span boundary whose skipped region has no line terminator. Per modes.md 3.3
+    #     it is opaque content everywhere except OPENISH/CLOSEISH, where it is a member of both.
+    #   - LINE_MARKER — a span boundary whose skipped region contains a line terminator. A member
+    #     of BREAK for every rule, everywhere.
+    MARKER = -1
+    LINE_MARKER = -2
+    NONE = -3
+
+    # True for either span boundary. NONE is deliberately not a marker: it is not in the array.
+    def self.marker?(value)
+      value == MARKER || value == LINE_MARKER
+    end
+  end
+end