disarm 0.14.1-aarch64-linux → 0.16.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40d3335e15f74858ee0ae3ea3ce35093febb3cadcac08d62cd7a873cf0d14acd
-  data.tar.gz: 92a8dee4515698525dcbf550b0a794543f3595b6258966f16f82a3d13407878a
+  metadata.gz: 8ecc331ffb977947b213f31133c21afa3aede8d64f44a43a5e624eeb122013df
+  data.tar.gz: e09891674097fa1eb7f61318e3df6c7e23740a132e313f309012ff68a2951bfe
 SHA512:
-  metadata.gz: 8ddcbc8bd78371985f105e6bd4f42b631e1c8edfcb951447785f804a0cdb1f7cc9587f3a1d62925113d59bed5c9e83751e44e04a852f0f6f5f6cb9f91b654a03
-  data.tar.gz: 6b55888ddad977c96ac7ddb4ac92941769c10bf298ca640d8706cd0841ac9ecea2625595de757e25609edddd8bd128bb8100ecd54513587c011f064578c38e0f
+  metadata.gz: 1784010e8ff92e9493d600eabb0bd856d56405310dd3d12b53fdc1badeddbb7c668efcf608812360f2332772c51735cb7d44dff5bf4d1287dc5ec74497ac1bd3
+  data.tar.gz: 0dfc2d60de872b386ac671594a8bea2bc0c4cf87b731c15343dc488d494c4d9e8a7bc4728b7249a44877b2d82ec953ea3c3135299f8ef973f458a1302f40b7ba

data/README.md

@@ -19,9 +19,10 @@ gem "disarm"
 gem install disarm
 ```
 
-Requires Ruby >= 3.1. `gem install disarm` pulls a precompiled platform gem
-(Linux x86_64/aarch64, macOS x86_64/arm64, Windows) when one is available, and
-falls back to compiling from source (needs a Rust toolchain) otherwise.
+Requires Ruby >= 3.1. Precompiled platform gems ship for Ruby 3.1 through 4.0
+(Linux x86_64/aarch64, macOS x86_64/arm64, Windows). On a supported Ruby with no
+matching platform gem, the source gem installs and compiles locally, which needs a
+Rust toolchain. Below 3.1 the gem does not install at all.
 
 ## Usage
 
@@ -49,7 +50,7 @@ Disarm.demojize("I ❤️ Ruby")                          # => "I red heart Ruby
 Disarm.demojize("👍🏽", strip_modifiers: true)
 
 # Security presets
-Disarm.strip_obfuscation("Ѕ𝗲𝗰𝗿𝗲𝘁  ​data")            # deobfuscated
+Disarm.strip_obfuscation("Ѕ𝗲𝗰𝗿𝗲𝘁  \u200bdata")            # deobfuscated
 Disarm.canonicalize("…")                           # homoglyph/bidi/zero-width clean
 
 # IDN / hostname spoof check (a false result is not a safety guarantee)

data/lib/disarm/version.rb

@@ -2,5 +2,5 @@
 
 module Disarm
   # Kept in lockstep with the Rust crate / Python package version.
-  VERSION = "0.14.1"
+  VERSION = "0.16.0"
 end

data/lib/disarm.rb

@@ -55,15 +55,22 @@ module Disarm
 
     # Fold cross-script confusables toward `target:` (:latin or :cyrillic).
     #
-    # `digit_policy:` selects how non-Latin DIGITS fold (#561). `:numeric` (default)
-    # sends them to the ASCII digit — `०` becomes `0` — which is right for prose, where
-    # a Devanagari zero really is a zero. `:tr39` uses upstream's targets, which send
-    # most of them to a Latin letter (`०` → `o`; three of the 45 rows fold to `.` or
-    # to the two characters `rn` instead); that is what an identifier *skeleton*
-    # wants, since its only job is to make two confusable identifiers collide. The two
-    # differ on 45 rows and agree everywhere else. Scoped to `target: :latin` — the
-    # override rows are generated from the Latin table and carry TR39's Latin-script
-    # targets, so with `target: :cyrillic` it is a no-op.
+    # `digit_policy:` selects how non-Latin DIGITS fold (#561).
+    #
+    # `:numeric` (default) sends them to the ASCII digit — `०` becomes `0` — which is
+    # right for prose, where a Devanagari zero really is a zero.
+    #
+    # `:tr39` uses upstream's targets, which send most of them to a Latin letter
+    # (`०` → `o`; three of the 45 rows fold to `.` or to the two characters `rn`
+    # instead). That is what an identifier *skeleton* wants, since its only job is to
+    # make two confusable identifiers collide. The two differ on 45 rows and agree
+    # everywhere else. Scoped to `target: :latin` — the override rows are generated from
+    # the Latin table and carry TR39's Latin-script targets, so with `target: :cyrillic`
+    # it is a no-op.
+    #
+    # `:preserve` leaves the digit alone (#648). The other two both yield a mixed-script
+    # numeral — `२०२४` becomes `२0२४` or `२o२४` — so neither keeps the script. Unlike
+    # `:tr39` it applies under every target script.
     def normalize_confusables(text, target: :latin, digit_policy: :numeric)
       translate_errors { _normalize_confusables(text, target.to_s, digit_policy.to_s) }
     end
@@ -109,18 +116,58 @@ module Disarm
       translate_errors { _demojize(text, strip_modifiers) }
     end
 
+    # Replace every emoji with +replacement+, verbatim.
+    #
+    # The counterpart to +demojize+, and a different question of a different table.
+    # +demojize+ asks what CLDR calls a character, so its domain is the name table, which
+    # is wider than the emoji: <tt>demojize("x\u2122y")</tt> is "x trade mark y". This
+    # asks whether the UCD calls it an emoji — Emoji_Presentation=Yes, an Emoji=Yes base
+    # carrying U+FE0F, and the ZWJ, modifier, keycap and flag sequences on those. Nothing
+    # else moves.
+    #
+    # +replacement+ is inserted exactly as given: "" closes an intra-word split and " "
+    # keeps two words apart, and no rule serves both.
+    def replace_emoji(text, replacement = "")
+      translate_errors { _replace_emoji(text, replacement) }
+    end
+
+    # Canonicalize, but raise rather than silently normalize a structural difference
+    # away — the half of the pair that lets a caller reject input instead of comparing
+    # a value the sender never wrote.
+    def canonicalize_strict(text, digit_policy: :numeric)
+      translate_errors { _canonicalize_strict(text, digit_policy.to_s) }
+    end
+
+    # Strip the non-interchange and invisible classes while KEEPING the script.
+    #
+    # Unlike `canonicalize` it folds no confusables, so non-Latin text survives as
+    # itself. It cannot be rebuilt from the seven universal `strip_*` methods, and the
+    # difference runs both ways: this preserves the Private Use Area (icon fonts) and
+    # keeps the VS15/VS16 presentation selectors after a base, which the naive chain
+    # deletes, and it collapses TAB/LF to a space, which the primitives leave alone.
+    def strip_format(text)
+      _strip_format(text)
+    end
+
     # Remove obfuscation (zero-width, bidi, combining-mark abuse) while keeping
     # legible content.
-    def strip_obfuscation(text)
-      translate_errors { _strip_obfuscation(text) }
+    def strip_obfuscation(text, digit_policy: :numeric)
+      translate_errors { _strip_obfuscation(text, digit_policy.to_s) }
     end
 
     # Canonicalize text for security-sensitive comparison: strip obfuscation,
     # control characters, and other spoofing vectors. The name describes the
     # mechanism (Unicode canonicalization for matching), not a safety guarantee —
     # this is not an output sanitizer; encode at the sink.
-    def canonicalize(text)
-      translate_errors { _canonicalize(text) }
+    #
+    # Two steps introduce ASCII, not one (#719): the leading NFKC, and the confusable
+    # fold, which reaches characters NFKC leaves alone. U+2236 RATIO becomes ":", U+2044
+    # FRACTION SLASH becomes "/", U+2216 SET MINUS becomes "\\". A string that carried no
+    # delimiter can leave here carrying one. #inspect_anomalies reports it as :confusable
+    # WHEN the word also carries an ASCII letter, which is the gate that keeps ordinary
+    # non-Latin text from firing; a delimiter-only string is not reported.
+    def canonicalize(text, digit_policy: :numeric)
+      translate_errors { _canonicalize(text, digit_policy.to_s) }
     end
 
     # @deprecated Renamed to {#canonicalize} in 0.11 (the +_clean+ name
@@ -133,22 +180,60 @@ module Disarm
     # Case/accent/script-insensitive search lookup key. `lang:` applies a
     # language profile for transliteration (e.g. "ru", "uk"); nil means none.
     # Raises Disarm::InvalidArgument on an unknown lang.
-    def search_key(text, lang: nil)
-      translate_errors { _search_key(text, lang&.to_s) }
+    def search_key(text, lang: nil, digit_policy: :numeric)
+      translate_errors { _search_key(text, lang&.to_s, digit_policy.to_s) }
     end
 
     # Collation sort key (like #search_key, but keeps base accented characters
     # for correct ordering). `lang:` applies a language profile; nil means none.
     # Raises Disarm::InvalidArgument on an unknown lang.
-    def sort_key(text, lang: nil)
-      translate_errors { _sort_key(text, lang&.to_s) }
+    def sort_key(text, lang: nil, digit_policy: :numeric)
+      translate_errors { _sort_key(text, lang&.to_s, digit_policy.to_s) }
     end
 
     # Library catalog deduplication key (search_key plus confusable folding).
     # `lang:` applies a language profile; `strict_iso9:` selects the ISO 9:1995
     # Cyrillic scheme. Raises Disarm::InvalidArgument on an unknown lang.
-    def catalog_key(text, lang: nil, strict_iso9: false)
-      translate_errors { _catalog_key(text, lang&.to_s, strict_iso9) }
+    def catalog_key(text, lang: nil, strict_iso9: false, digit_policy: :numeric)
+      translate_errors { _catalog_key(text, lang&.to_s, strict_iso9, digit_policy.to_s) }
+    end
+
+    # The TR39 identifier skeleton plus the two prototype classes disarm keeps apart
+    # (#650). A spoof key: its only job is to make confusable identifiers collide, and its
+    # output is never for display. `digit_policy:` is `:numeric` (the letter half only),
+    # `:tr39` (adds `1 ≡ l` and `0 ≡ O`) or `:preserve` (a non-Latin numeral keeps its
+    # script).
+    def skeleton_key(text, digit_policy: :numeric)
+      translate_errors { _skeleton_key(text, digit_policy.to_s) }
+    end
+
+    # Levenshtein edit distance between `a` and `b`, in characters (#894). The one class
+    # of registry spoofing the confusable tables deliberately do not model — `paypa1`,
+    # `adm1n`. Canonicalize both sides first when composed and decomposed spellings
+    # should compare equal.
+    def edit_distance(left, right)
+      translate_errors { _edit_distance(left, right) }
+    end
+
+    # The candidate closest to `value`, as `{ value:, distance: }`, or nil beyond
+    # `max_distance:` (#894). Reports; it does not decide. An exact match is reported with
+    # distance 0, and ties go to the first candidate at the lowest distance.
+    def nearest_match(value, candidates, max_distance: 1)
+      hit = translate_errors { _nearest_match(value, candidates.map(&:to_s), max_distance) }
+      hit && { value: hit[0], distance: hit[1] }
+    end
+
+    # Whether `text` is already its own canonical form under `preset:` (#730).
+    #
+    # The verification-path counterpart to the presets: text in, normalized text out is
+    # the generation path, and this is the question a caller asks about bytes that arrive
+    # already bound. `has_anomalies?` is not this predicate — 142,760 assigned code points are
+    # reported clean by the detector and are not their own canonical form.
+    #
+    # `preset:` is any name in the preset registry or any profile. Raises
+    # Disarm::InvalidArgument on an unknown one.
+    def canonical?(text, preset: "canonicalize")
+      translate_errors { _is_canonical?(text, preset.to_s) }
     end
 
     # Strip diacritics ("café" → "cafe").
@@ -208,14 +293,14 @@ module Disarm
     # confusable test flags essentially every non-Latin host), not a precise verdict;
     # branch on the granular signals plus your own policy. Keys: :suspicious,
     # :scripts, :mixed_script, :has_confusables, :bidi_conflict, :bidi_control,
-    # :has_invisible, :cross_label_script,
+    # :has_invisible, :compat_fold, :cross_label_script,
     # :label_scripts, :whole_script_confusable, :label_whole_script_confusable,
     # :canonical. `:whole_script_confusable` is a graded signal, NOT folded into
     # `:suspicious` (see #545).
     def analyze_hostname(host, contractions: false)
       suspicious, scripts, mixed_script, has_confusables, bidi_conflict,
-        bidi_control, has_invisible, cross_label_script, label_scripts,
-        whole_script_confusable, label_whole_script_confusable, canonical =
+        bidi_control, has_invisible, compat_fold, cross_label_script, label_scripts,
+        whole_script_confusable, (label_whole_script_confusable, canonical) =
         translate_errors { _analyze_hostname(host, contractions) }
       {
         suspicious:,
@@ -225,6 +310,7 @@ module Disarm
         bidi_conflict:,
         bidi_control:,
         has_invisible:,
+        compat_fold:,
         cross_label_script:,
         label_scripts:,
         whole_script_confusable:,
@@ -337,6 +423,12 @@ module Disarm
     # (default), :windows, or :posix; `preserve_extension:` keeps the final
     # extension when truncating to `max_length:`. Raises Disarm::InvalidArgument
     # on an unknown platform.
+    #
+    # A safe *filename*, not a safe URL path segment. "%" is legal in a filename, so one
+    # the caller typed is kept — sanitize_filename("..%2Fetc") returns "%2Fetc" — and a
+    # consumer that percent-decodes the result must validate AFTER decoding. What this
+    # will not do is manufacture one: "%" never appears in the output unless it appeared
+    # in the input (#721).
     def sanitize_filename(text, separator: "_", max_length: 255, platform: :universal,
                           lang: nil, preserve_extension: true)
       translate_errors do
@@ -415,6 +507,15 @@ module Disarm
       translate_errors { _has_bidi_conflict?(text) }
     end
 
+    # Whether `text` carries any of the twelve UAX #9 explicit formatting characters,
+    # with no context taken into account. The counterpart to `bidi_conflict?`, which
+    # reads strong-direction letters and is blind to these; the two are disjoint. The
+    # anomaly detector's `bidi` kind reports nine of the twelve, holding back LRM, RLM
+    # and ALM because a lone directional mark is ordinary in right-to-left text.
+    def bidi_control?(text)
+      _has_bidi_control?(text)
+    end
+
     # Explain how `lang: "auto"` detection resolves `text`: a hash with
     # `:script`, `:chosen_lang` (both nil if undetected), `:reason`, and
     # `:discriminators_hit`.
@@ -438,9 +539,39 @@ module Disarm
       translate_errors { _script_info(name.to_s) }
     end
 
+    # TR39 confusable sources whose prototype is in +script+, and how many of those
+    # disarm's bundled tables fold. Returns a Hash with +:script+, +:sources+ and
+    # +:folded+ keys.
+    #
+    # The denominator +unmapped_confusables+ does not have: that measures one bundled
+    # table against the whole 6,565-source population, so a script disarm ships no table
+    # for reports a number determined by that absence rather than by its coverage.
+    #
+    # +:folded+ counts sources any bundled table reaches, not sources folded *toward*
+    # this script — Greek is 71 of 159, because the Latin table folds Greek letters that
+    # look Latin. A script disarm knows that TR39 never uses as a prototype returns 0 of
+    # 0. Raises Disarm::InvalidArgument on an unknown script.
+    def confusable_coverage(script)
+      translate_errors { _confusable_coverage(script.to_s) }
+    end
+
     # The Unicode `confusables.txt` release the bundled confusable tables were folded
     # from, e.g. "17.0.0". Not a Unicode version for the library as a whole — the
     # case-folding and width tables track different releases (see docs/provenance.md).
+    # The UCD release disarm's normalizer implements. Not a library-wide Unicode
+    # version — the bundled tables track different releases. This is the one integrators
+    # ask about: it decides whether disarm's normalization agrees with Ruby's.
+    def unicode_version
+      _unicode_version
+    end
+
+    # Whether a key stored under an earlier release still compares equal. A monotonic
+    # counter, not a version: two artifacts reporting the same value produce the same key
+    # for the same input. Meaningless in isolation, by design.
+    def key_schema_version
+      _key_schema_version
+    end
+
     def confusables_version
       translate_errors { _confusables_version }
     end
@@ -512,7 +643,9 @@ module Disarm
     #   pipe.process("Café") # => "cafe"
     #   pipe.process("Köln") # reuse the same handle
     #
-    # Disarm::Pipeline#process is the Rust-defined instance method on the handle.
+    # Disarm::Pipeline#process is the Rust-defined instance method on the handle, and
+    # Disarm::Pipeline#with_digit_policy(policy) returns a copy whose confusable passes
+    # fold under `policy` (#646); a profile with no confusables step refuses one.
     def get_pipeline(profile)
       translate_errors { _get_pipeline(profile.to_s) }
     end
@@ -553,4 +686,17 @@ module Disarm
       raise Error, e.message, e.backtrace
     end
   end
+
+  # The reusable handle `Disarm.get_pipeline` returns. `#process` is Rust-defined; this
+  # reopens the class for the one method that can fail, so its error arrives as
+  # `Disarm::InvalidArgument` the way every module-level call's does.
+  class Pipeline
+    # A copy of this pipeline whose confusable passes fold under `policy` (#646):
+    # `:numeric`, `:tr39` or `:preserve`. Raises Disarm::InvalidArgument when the profile
+    # has no confusables step and the policy is not the default — a setting that would
+    # never run is refused rather than kept.
+    def with_digit_policy(policy)
+      Disarm.send(:translate_errors) { _with_digit_policy(policy.to_s) }
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: disarm
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.16.0
 platform: aarch64-linux
 authors:
 - Richard Quinn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-08-28 00:00:00.000000000 Z
+date: 2026-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -98,6 +98,8 @@ files:
 - lib/disarm/3.1/disarm.so
 - lib/disarm/3.2/disarm.so
 - lib/disarm/3.3/disarm.so
+- lib/disarm/3.4/disarm.so
+- lib/disarm/4.0/disarm.so
 - lib/disarm/version.rb
 homepage: https://github.com/raeq/disarm
 licenses:
@@ -118,7 +120,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '3.1'
   - - "<"
     - !ruby/object:Gem::Version
-      version: 3.4.dev
+      version: 4.1.dev
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="