polytypo 1.0.0

data/lib/polytypo/modes/markdown.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require_relative "spans"
+require_relative "html"
+require_relative "parse_error"
+require_relative "../errors"
+
+module Polytypo
+  module Modes
+    # Markdown span extraction via `commonmarker` (the Ruby binding to the `comrak` Rust
+    # CommonMark/GFM engine). `dialect="mdx"` returns POLYTYPO_INVALID_DIALECT: this runtime has
+    # no MDX/JSX parser, which the spec permits (a narrower conformance claim, not a silent
+    # mishandling of a dialect it claims to support).
+    #
+    # `require "commonmarker"` happens lazily, inside this file only, never at the top of
+    # lib/polytypo.rb -- a caller who only ever uses mode: "text" never loads the native
+    # commonmarker extension.
+    module Markdown
+      def self.resolve_dialect(dialect)
+        case dialect
+        when nil, ""
+          raise Polytypo::Error.new(
+            Polytypo::CODE_INVALID_DIALECT,
+            'mode "markdown" requires a dialect; there is no default'
+          )
+        when "commonmark"
+          nil
+        when "mdx"
+          raise Polytypo::Error.new(
+            Polytypo::CODE_INVALID_DIALECT,
+            'dialect "mdx" is not supported by this runtime (no MDX/JSX parser available); ' \
+            'only "commonmark" is supported'
+          )
+        else
+          raise Polytypo::Error.new(
+            Polytypo::CODE_INVALID_DIALECT,
+            "unknown dialect #{dialect.inspect}; this runtime supports \"commonmark\""
+          )
+        end
+      end
+
+      # Block/inline node types that are never processable, in full (modes.md 3.7.3): fenced and
+      # indented code (comrak represents both as :code_block), inline code spans, thematic
+      # breaks (no prose content), and frontmatter (skipped whole including its delimiters).
+      SKIP_WHOLE_TYPES = %i[code code_block thematic_break frontmatter].freeze
+
+      # A leaf whose Segment/source_position directly delineates literal, processable prose --
+      # comrak's AST is segment-based like goldmark's: structural bytes (emphasis delimiters,
+      # link brackets/destination, table pipes and the delimiter row, list markers, blockquote
+      # markers, heading hashes, fence lines and info strings) are consumed during parsing and
+      # never represented as a node's own source_position at all, so no gap-filling step is
+      # needed here -- emitting a span for exactly every :text node's source_position already
+      # reconstructs precisely the processable prose, nothing more (same discovery as the Go
+      # port's goldmark-based adapter).
+      TEXT_LEAF_TYPES = %i[text].freeze
+
+      # detect_frontmatter_delimiter: comrak's frontmatter extension takes one literal delimiter
+      # string and requires the opening AND closing lines to match it exactly -- unlike the Go
+      # port (which had to hand-roll frontmatter detection entirely), here only the *which
+      # delimiter* choice needs to be made upfront, from the document's own leading bytes.
+      def self.detect_frontmatter_delimiter(source)
+        return "+++" if source.start_with?("+++")
+        return "---" if source.start_with?("---")
+
+        nil
+      end
+      private_class_method :detect_frontmatter_delimiter
+
+      # Locates the processable spans of a Markdown document. dialect must already be validated
+      # via resolve_dialect (== "commonmark"); this function does not re-check it.
+      def self.markdown_spans(source)
+        require "commonmarker"
+
+        cp = Polytypo::Engine::Codepoints.to_codepoints(source)
+        chars = cp.map { |c| [c].pack("U") }
+        line_starts = build_line_starts(chars)
+
+        delimiter = detect_frontmatter_delimiter(source)
+        options = { parse: { sourcepos_chars: true } }
+        options[:extension] = { front_matter_delimiter: delimiter } if delimiter
+
+        spans = []
+        ParseError.wrap do
+          doc = Commonmarker.parse(source, options: options)
+          html_stack_holder = { stack: [] }
+          walk(doc, chars, line_starts, spans, html_stack_holder)
+        end
+        spans
+      end
+
+      # line_starts[i] is the 0-based code-point index at which comrak's 1-based line i begins.
+      def self.build_line_starts(chars)
+        starts = [0]
+        chars.each_with_index do |ch, i|
+          starts << (i + 1) if ch == "\n"
+        end
+        starts
+      end
+      private_class_method :build_line_starts
+
+      def self.offset_of(line_starts, line, column)
+        line_starts[line - 1] + (column - 1)
+      end
+      private_class_method :offset_of
+
+      def self.walk(node, chars, line_starts, spans, html_holder)
+        type = node.type
+        return if SKIP_WHOLE_TYPES.include?(type)
+
+        if type == :html_block
+          handle_html_block(node, chars, line_starts, spans)
+          return
+        end
+
+        if type == :html_inline
+          handle_html_inline(node, chars, line_starts, html_holder)
+          return
+        end
+
+        if type == :link || type == :image
+          sp = node.source_position
+          start_offset = offset_of(line_starts, sp[:start_line], sp[:start_column])
+          unless chars[start_offset] == "["
+            # No leading "[" at the link's own source position: this is an autolink
+            # (<https://…> or a bare GFM autolink literal), not a real [text](url) link --
+            # skipped whole, per modes.md 3.7.3.
+            return
+          end
+          # A real link/image: fall through to the generic child walk below, which emits the
+          # link text (or image alt text) as processable prose. The destination/title are never
+          # represented as child nodes at all, so there is nothing further to exclude.
+        end
+
+        if TEXT_LEAF_TYPES.include?(type)
+          sp = node.source_position
+          start_offset = offset_of(line_starts, sp[:start_line], sp[:start_column])
+          end_offset = offset_of(line_starts, sp[:end_line], sp[:end_column]) + 1
+          if html_holder[:stack].empty? && end_offset > start_offset
+            spans << Spans::Span.new(start_offset, end_offset)
+          end
+          return
+        end
+
+        if %i[paragraph heading table_cell].include?(type)
+          # A fresh top-level inline-bearing container: the raw-HTML skip stack resets here (an
+          # unclosed skipped start tag skips to the end of the block, modes.md 3.7.3).
+          html_holder[:stack] = []
+        end
+
+        node.each { |child| walk(child, chars, line_starts, spans, html_holder) }
+      end
+      private_class_method :walk
+
+      def self.handle_html_block(node, chars, line_starts, spans)
+        sp = node.source_position
+        start_offset = offset_of(line_starts, sp[:start_line], sp[:start_column])
+        end_offset = offset_of(line_starts, sp[:end_line], sp[:end_column]) + 1
+        return if end_offset <= start_offset
+
+        text = chars[start_offset...end_offset].join
+        Html.html_spans(text).each do |s|
+          spans << Spans::Span.new(start_offset + s.start, start_offset + s.end)
+        end
+      end
+      private_class_method :handle_html_block
+
+      def self.handle_html_inline(node, chars, line_starts, html_holder)
+        sp = node.source_position
+        start_offset = offset_of(line_starts, sp[:start_line], sp[:start_column])
+        end_offset = offset_of(line_starts, sp[:end_line], sp[:end_column]) + 1
+        raw = chars[start_offset...end_offset]
+        name, closing, self_closing = Html.read_tag(raw) || [nil, nil, nil]
+        return if name.nil?
+
+        stack = html_holder[:stack]
+        if closing
+          if !stack.empty? && stack[-1] == name
+            stack.pop
+          end
+        elsif !self_closing && Html::SKIPPED_ELEMENTS.include?(name)
+          stack << name
+        end
+      end
+      private_class_method :handle_html_inline
+    end
+  end
+end

data/lib/polytypo/modes/parse_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+
+module Polytypo
+  module Modes
+    # Wraps any error either mode parser produces into POLYTYPO_MALFORMED_INPUT -- no third-party
+    # parser's error type is ever allowed to escape Transform.
+    module ParseError
+      def self.wrap
+        yield
+      rescue Polytypo::Error
+        raise
+      rescue StandardError => e
+        raise Polytypo::Error.new(Polytypo::CODE_MALFORMED_INPUT, "input did not parse: #{e.message}")
+      end
+    end
+  end
+end

data/lib/polytypo/modes/runner.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "spans"
+require_relative "../engine/edits"
+require_relative "../engine/registry"
+
+module Polytypo
+  module Modes
+    # modes.md 3.5. The pipeline runs once, over the marker-separated concatenation of every
+    # processable span -- not per span (would pair quotation marks in isolation), and not over a
+    # naive concatenation (would manufacture adjacencies the document does not have).
+    module Runner
+      # The same sequence as Engine::Pipeline.run_rules, with the two boundary filters of
+      # modes.md 3.4 interposed.
+      def self.run_rules_over_spans(cp, plan, locale_data, ctx)
+        current = cp
+        plan.each do |rule_id|
+          fn = Engine::Registry.rule(rule_id)
+          edits = fn.call(current, locale_data, ctx)
+          filtered = Spans.filter_boundary_edits(current, edits, Spans.span_ranges_of(current))
+          next if filtered.empty?
+
+          current = Engine::Edits.apply_edits(current, filtered, rule_id)
+        end
+        current
+      end
+      private_class_method :run_rules_over_spans
+
+      # The output is the input with a set of disjoint substring replacements applied and nothing
+      # else (modes.md 4). A span whose content the rules did not change contributes no
+      # replacement, so a document needing no changes comes back byte-identical.
+      #
+      # source_cp is the whole input already converted to code points; spans address it by
+      # code-point index.
+      def self.run_over_spans(source_cp, spans, plan, locale_data, ctx)
+        normalized = Spans.normalize_spans(spans)
+        return source_cp.pack("U*") if normalized.empty?
+
+        concatenated = Spans.concatenate_spans(source_cp, normalized)
+        transformed = run_rules_over_spans(concatenated, plan, locale_data, ctx)
+        pieces = Spans.split_on_marker(transformed, normalized.length)
+
+        out = []
+        cursor = 0
+        normalized.each_with_index do |span, i|
+          piece = pieces[i]
+          original = source_cp[span.start...span.end]
+          out.concat(source_cp[cursor...span.start])
+          out.concat(piece == original ? original : piece)
+          cursor = span.end
+        end
+        out.concat(source_cp[cursor..])
+        out.pack("U*")
+      end
+    end
+  end
+end

data/lib/polytypo/modes/spans.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative "../engine/sentinels"
+require_relative "../errors"
+
+module Polytypo
+  module Modes
+    # The span model shared by every mode adapter that is not "text" (spec/rules/modes.md
+    # 3.2-3.5). Mirrors the other three ports' spans.{ts,py,go} exactly: markers are written here
+    # (mode layer), classified in Engine::Sentinels and in each rule's own class definitions (L1).
+    module Spans
+      LINE_TERMINATORS = [0x0A, 0x0D, 0x0B, 0x0C, 0x85, 0x2028, 0x2029].freeze
+
+      # A processable span, identified by its offsets in the original source, addressed as
+      # code-point indices (ARCHITECTURE.md section 4.2) -- Ruby String indices are already
+      # code-point indices for a UTF-8 String, no separate byte/char distinction to manage here.
+      Span = Struct.new(:start, :end)
+
+      # A span's extent in the concatenated code-point array: s0/s1 of modes.md 3.4. `:first`
+      # deliberately shadows Struct#first with the equivalent one-argument-less accessor -- this
+      # struct is never called with an integer argument the way Struct#first(n) would expect, and
+      # `first`/`last` match every other port's SpanRange naming exactly.
+      SpanRange = Struct.new(:first, :last) # rubocop:disable Lint/StructNewOverride
+
+      def self.gap_is_line_boundary?(cp, from, to)
+        (from...to).any? { |i| LINE_TERMINATORS.include?(cp[i]) }
+      end
+      private_class_method :gap_is_line_boundary?
+
+      # Sorts, drops empties, and coalesces spans separated by nothing in the source (modes.md
+      # 7.5). Overlapping spans are an extractor bug and are rejected rather than silently merged.
+      def self.normalize_spans(spans)
+        sorted = spans.select { |s| s.end > s.start }.sort_by(&:start)
+        out = []
+        sorted.each do |span|
+          if out.empty?
+            out << span
+            next
+          end
+          last = out[-1]
+          if span.start < last.end
+            raise Polytypo::Error.new(
+              Polytypo::CODE_RULE_CONTRACT,
+              "mode extractor produced overlapping spans (#{last.start}, #{last.end}) and " \
+              "(#{span.start}, #{span.end})"
+            )
+          end
+          if span.start == last.end
+            out[-1] = Span.new(last.start, span.end)
+          else
+            out << span
+          end
+        end
+        out
+      end
+
+      # S1 (marker) S2 ... Sm (modes.md 3.5 step 2), given the source's full code-point array.
+      def self.concatenate_spans(source_cp, spans)
+        cp = []
+        previous = nil
+        spans.each do |span|
+          unless previous.nil?
+            cp << (gap_is_line_boundary?(source_cp, previous.end, span.start) ? Engine::LINE_MARKER : Engine::MARKER)
+          end
+          cp.concat(source_cp[span.start...span.end])
+          previous = span
+        end
+        cp
+      end
+
+      # The span extents of the array as it stands. Recomputed after every rule, because applying
+      # edits shifts every index after the first one -- the markers themselves always survive,
+      # since no edit may contain one.
+      def self.span_ranges_of(cp)
+        ranges = []
+        first = 0
+        cp.each_with_index do |value, i|
+          if Engine.marker?(value)
+            ranges << SpanRange.new(first, i - 1)
+            first = i + 1
+          end
+        end
+        ranges << SpanRange.new(first, cp.length - 1)
+        ranges
+      end
+
+      def self.span_containing(ranges, p)
+        ranges.find { |r| r.first <= p && p <= r.last + 1 }
+      end
+      private_class_method :span_containing
+
+      # modes.md 3.4, two safety nets, both pure functions of (p, q, r, s0, s1):
+      #
+      #  1. No edit may contain a marker -- one that does is a bug, discarded rather than
+      #     redistributed.
+      #  2. The edge-growth rule: an edit is discarded if it would place code points at an
+      #     extremity of its span that were not there before.
+      def self.filter_boundary_edits(cp, edits, ranges)
+        edits.select do |edit|
+          next false if (edit.start...edit.end).any? { |i| Engine.marker?(cp[i]) }
+
+          p = edit.start
+          q = edit.end - 1
+          d = edit.end - edit.start
+          r = edit.replacement.length
+          span = span_containing(ranges, p)
+          !(span && r > d && (p == span.first || q == span.last))
+        end
+      end
+
+      # Redistributes the transformed array back to one piece per span (modes.md 3.5 step 4).
+      def self.split_on_marker(cp, expected)
+        pieces = [[]]
+        cp.each do |value|
+          if Engine.marker?(value)
+            pieces << []
+          else
+            pieces[-1] << value
+          end
+        end
+        if pieces.length != expected
+          raise Polytypo::Error.new(
+            Polytypo::CODE_RULE_CONTRACT,
+            "boundary markers did not survive the pipeline: expected #{expected} spans, " \
+            "found #{pieces.length}"
+          )
+        end
+        pieces
+      end
+    end
+  end
+end

data/lib/polytypo/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Polytypo
+  VERSION = "1.0.0"
+end

data/lib/polytypo.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "polytypo/version"
+require_relative "polytypo/errors"
+require_relative "polytypo/engine/codepoints"
+require_relative "polytypo/engine/pipeline"
+require_relative "polytypo/engine/rules" # side effect: registers all 9 rules
+require_relative "polytypo/modes/spans"
+require_relative "polytypo/modes/runner"
+require_relative "polytypo/modes/html"
+
+# polytypo is locale-correct microtypography: quotes, dashes, ellipses, apostrophes, symbols and
+# no-break spaces, from a spec shared across every polytypo runtime
+# (github.com/polytypo/polytypo). See spec/CONFORMANCE.md there for exactly what this runtime
+# implements.
+module Polytypo
+  # Applies polytypo's rule pipeline to +input+ and returns the result.
+  #
+  # +locale+ is required, with no default -- an unknown locale raises Polytypo::Error with
+  # CODE_UNKNOWN_LOCALE; there is never a fallback to English. +mode+ is "text" (default), "html"
+  # or "markdown". +dialect+ is required iff mode is "markdown" ("commonmark"; "mdx" is not
+  # implemented by this runtime). +rules+ is an opt-out Hash keyed by rule id.
+  #
+  # Pure: no I/O, no environment, no clock, no globals, no class-level mutable state --
+  # thread-safe and reentrant, callable concurrently from any number of Threads with no external
+  # synchronization (ARCHITECTURE.md section 7).
+  #
+  # Only `mode: "text"`/`"html"` ever touch this file's own requires; `mode: "markdown"` lazily
+  # requires "commonmarker" from within Modes::Markdown, never at load time of this file.
+  def self.transform(input, locale:, mode: "text", dialect: nil, rules: nil)
+    resolved_mode = resolve_mode(mode)
+
+    case resolved_mode
+    when "text"
+      if dialect
+        raise Error.new(CODE_INVALID_DIALECT, '"dialect" is only valid when mode is "markdown"')
+      end
+      transform_text(input, locale, rules)
+    when "html"
+      if dialect
+        raise Error.new(CODE_INVALID_DIALECT, '"dialect" is only valid when mode is "markdown"')
+      end
+      transform_html(input, locale, rules)
+    else # "markdown"
+      transform_markdown(input, locale, dialect, rules)
+    end
+  end
+
+  def self.resolve_mode(mode)
+    case mode
+    when nil, "text"
+      "text"
+    when "html", "markdown"
+      mode
+    else
+      raise Error.new(CODE_INVALID_MODE, "unknown mode #{mode.inspect}. Expected \"text\", \"html\" or \"markdown\"")
+    end
+  end
+  private_class_method :resolve_mode
+
+  def self.transform_text(input, locale, rules)
+    _resolved, locale_data, plan = Engine::Pipeline.prepare(locale, rules)
+    cp = Engine::Codepoints.to_codepoints(input)
+    ctx = Engine::RuleContext.new(mode: "text", dialect: nil, locale: locale)
+    result = Engine::Pipeline.run_rules(cp, plan, locale_data, ctx)
+    Engine::Codepoints.from_codepoints(result)
+  end
+  private_class_method :transform_text
+
+  def self.transform_html(input, locale, rules)
+    resolved_locale, locale_data, plan = Engine::Pipeline.prepare(locale, rules)
+    spans = Modes::Html.html_spans(input)
+    ctx = Engine::RuleContext.new(mode: "html", dialect: nil, locale: resolved_locale)
+    cp = Engine::Codepoints.to_codepoints(input)
+    Modes::Runner.run_over_spans(cp, spans, plan, locale_data, ctx)
+  end
+  private_class_method :transform_html
+
+  def self.transform_markdown(input, locale, dialect, rules)
+    # Validation order is public, tested behaviour, identical across every runtime: rules (an
+    # unknown rule id), then locale (an unknown locale), then dialect/parsing.
+    resolved_locale, locale_data, plan = Engine::Pipeline.prepare(locale, rules)
+    require_relative "polytypo/modes/markdown"
+    Modes::Markdown.resolve_dialect(dialect)
+    spans = Modes::Markdown.markdown_spans(input)
+    ctx = Engine::RuleContext.new(mode: "markdown", dialect: dialect, locale: resolved_locale)
+    cp = Engine::Codepoints.to_codepoints(input)
+    Modes::Runner.run_over_spans(cp, spans, plan, locale_data, ctx)
+  end
+  private_class_method :transform_markdown
+end

data/polytypo.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "lib/polytypo/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "polytypo"
+  spec.version = Polytypo::VERSION
+  spec.authors = ["Iurii Rogulia"]
+  spec.email = ["iurii@rogulia.fi"]
+
+  spec.summary = "Locale-correct microtypography: quotes, dashes, ellipses, apostrophes, symbols and no-break spaces"
+  spec.description = "polytypo is a locale-correct microtypography engine -- quotes, dashes, " \
+                      "ellipses, apostrophes, symbols and no-break spaces -- driven by a spec " \
+                      "shared across every polytypo runtime (github.com/polytypo/polytypo)."
+  spec.homepage = "https://polytypo.dev/"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/polytypo/polytypo-ruby"
+  spec.metadata["changelog_uri"] = "https://github.com/polytypo/polytypo-ruby/releases"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  # Everything under lib/, plus top-level docs. Never RSpec's own spec/ directory (test-only,
+  # not part of the published gem) or CI/dev-only files.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").select do |f|
+      f.start_with?("lib/") || %w[README.md LICENSE polytypo.gemspec].include?(f)
+    end
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "commonmarker", "~> 2.0"
+  # Development dependencies live in the Gemfile, not here (Gemspec/DevelopmentDependencies):
+  # a gemspec's dependencies ship as metadata with every install, while dev-only tooling like
+  # rspec/rubocop belongs only to this repository's own Bundler group.
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: polytypo
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Iurii Rogulia
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: commonmarker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: polytypo is a locale-correct microtypography engine -- quotes, dashes,
+  ellipses, apostrophes, symbols and no-break spaces -- driven by a spec shared across
+  every polytypo runtime (github.com/polytypo/polytypo).
+email:
+- iurii@rogulia.fi
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/polytypo.rb
+- lib/polytypo/data/README.md
+- lib/polytypo/data/UNICODE
+- lib/polytypo/data/VERSION
+- lib/polytypo/data/fixtures/de-CH.json
+- lib/polytypo/data/fixtures/de-DE.json
+- lib/polytypo/data/fixtures/el.json
+- lib/polytypo/data/fixtures/en-GB.json
+- lib/polytypo/data/fixtures/en-US.json
+- lib/polytypo/data/fixtures/fi.json
+- lib/polytypo/data/fixtures/fr-CA.json
+- lib/polytypo/data/fixtures/fr.json
+- lib/polytypo/data/fixtures/locale-resolution.json
+- lib/polytypo/data/fixtures/ru.json
+- lib/polytypo/data/fixtures/sv.json
+- lib/polytypo/data/locales/de-CH.json
+- lib/polytypo/data/locales/de-DE.json
+- lib/polytypo/data/locales/el.json
+- lib/polytypo/data/locales/en-GB.json
+- lib/polytypo/data/locales/en-US.json
+- lib/polytypo/data/locales/fi.json
+- lib/polytypo/data/locales/fr-CA.json
+- lib/polytypo/data/locales/fr.json
+- lib/polytypo/data/locales/registry.json
+- lib/polytypo/data/locales/ru.json
+- lib/polytypo/data/locales/sv.json
+- lib/polytypo/data/rules/dashes.md
+- lib/polytypo/data/rules/order.json
+- lib/polytypo/data/schema/fixtures.schema.json
+- lib/polytypo/data/schema/locale.schema.json
+- lib/polytypo/data/schema/registry.schema.json
+- lib/polytypo/data/schema/resolution.schema.json
+- lib/polytypo/engine/codepoints.rb
+- lib/polytypo/engine/edits.rb
+- lib/polytypo/engine/locale.rb
+- lib/polytypo/engine/pipeline.rb
+- lib/polytypo/engine/registry.rb
+- lib/polytypo/engine/rules.rb
+- lib/polytypo/engine/rules/apostrophe.rb
+- lib/polytypo/engine/rules/dash_shared.rb
+- lib/polytypo/engine/rules/dashes.rb
+- lib/polytypo/engine/rules/ellipsis.rb
+- lib/polytypo/engine/rules/hyphen.rb
+- lib/polytypo/engine/rules/nbsp.rb
+- lib/polytypo/engine/rules/quote_ambiguity.rb
+- lib/polytypo/engine/rules/quotes.rb
+- lib/polytypo/engine/rules/ranges.rb
+- lib/polytypo/engine/rules/spaces.rb
+- lib/polytypo/engine/rules/symbols.rb
+- lib/polytypo/engine/sentinels.rb
+- lib/polytypo/engine/unicode_util.rb
+- lib/polytypo/errors.rb
+- lib/polytypo/modes/html.rb
+- lib/polytypo/modes/markdown.rb
+- lib/polytypo/modes/parse_error.rb
+- lib/polytypo/modes/runner.rb
+- lib/polytypo/modes/spans.rb
+- lib/polytypo/version.rb
+- polytypo.gemspec
+homepage: https://polytypo.dev/
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://polytypo.dev/
+  source_code_uri: https://github.com/polytypo/polytypo-ruby
+  changelog_uri: https://github.com/polytypo/polytypo-ruby/releases
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: 'Locale-correct microtypography: quotes, dashes, ellipses, apostrophes, symbols
+  and no-break spaces'
+test_files: []