fix

Author: NextdoorPsycho

lib/components/inspector/preview_match_editor.dart

@@ -327,7 +327,7 @@ class PreviewMatchEditor extends StatelessWidget {
     title: 'Install on the server',
     children: <Widget>[
       HuiDetailRow('Preview file', '$huiPreviewFolder${store.menuId}.json'),
-      const HuiDetailRow('Permission', 'holoui.preview'),
+      const HuiDetailRow('Permission', 'gloss.preview'),
     ],
   );
 

lib/config/field_docs.dart

@@ -604,7 +604,8 @@ const Map<String, HuiFieldDoc> huiFieldDocs = <String, HuiFieldDoc>{
     body:
         'A disabled emoji stays in the list (and in tab-complete data the '
         'service builds) but is filtered out of the replacer, so nothing '
-        'substitutes until it is enabled again.',
+        'substitutes until it is enabled again. A file that omits the key '
+        'is enabled.',
     citation: 'EmojiReplacer.java:14-19',
   ),
 

lib/config/shipped_preview_json.dart

@@ -131,7 +131,7 @@ const String kBlankHologramJson = r'''
         "type": "decoration",
         "icon": {
           "type": "text",
-          "text": "&7Edit this with /holoui menu or the web editor."
+          "text": "&7Edit this with /gloss menu or the web editor."
         }
       }
     },

lib/config/templates.dart

@@ -5,12 +5,10 @@
 /// style.wordWrapChars())`: strip `§` colour pairs (only `§`, never `&` —
 /// `stripColors`), soft-wrap through VolmLib's `Form.wrapWords`, split on
 /// newlines and drop blank lines. [glossFormWrapWords] is a literal port of
-/// `Form.wrapPrefixed(s, "", len, null, true, " ")` as that code actually
-/// reads — including its one divergence from the commons-lang original: the
-/// FIRST space found in a window is recorded window-relative (no `+ offset`),
-/// so a window whose only space sits before the current absolute offset takes
-/// the hard-cut branch. The Java behavior is the contract; the quirk is
-/// ported, not fixed.
+/// `Form.wrap(s, len, null, true, " ")` as that code actually reads: every
+/// space found in a window is recorded at its absolute index (`start +
+/// offset`), so wrapping always breaks at the last space that fits the
+/// window and only hard-cuts a word longer than the window.
 library;
 
 /// `BubbleLines.split`.
@@ -63,9 +61,7 @@ String glossFormWrapWords(String s, int len) {
         offset += matches.current.end;
         continue;
       }
-      // The literal port: window-relative, no `+ offset` — see the library
-      // comment.
-      spaceToWrapAt = matches.current.start;
+      spaceToWrapAt = matches.current.start + offset;
     }
 
     if (inputLength - offset <= len) break;

lib/logic/bubble_lines.dart

@@ -14,7 +14,11 @@
 library;
 
 import 'preview_expr.dart';
-import 'preview_sim.dart' show previewSimGroupVariables;
+import 'preview_sim.dart'
+    show
+        kLegacyPreviewLangPrefix,
+        previewRenamedLangKey,
+        previewSimGroupVariables;
 import 'preview_variant_resolver.dart' show previewMatchesGlob;
 import 'validation.dart';
 import '../model/preview_doc.dart';
@@ -175,6 +179,41 @@ void previewCollectVarRefs(PExpr expr, void Function(String name) visit) {
   }
 }
 
+/// Visits every `PStr` literal anywhere in [expr], mirroring
+/// [previewCollectVarRefs]'s traversal — used to spot legacy
+/// `holoui.preview.*` lang keys passed to `lang()` or concatenated into text.
+void _previewCollectStrLiterals(PExpr expr, void Function(String value) visit) {
+  switch (expr) {
+    case PStr(value: final String value):
+      visit(value);
+    case PList(items: final List<PExpr> items):
+      for (final PExpr item in items) {
+        _previewCollectStrLiterals(item, visit);
+      }
+    case PUnary(operand: final PExpr operand):
+      _previewCollectStrLiterals(operand, visit);
+    case PBinary(left: final PExpr left, right: final PExpr right):
+      _previewCollectStrLiterals(left, visit);
+      _previewCollectStrLiterals(right, visit);
+    case PTernary(
+      condition: final PExpr condition,
+      ifTrue: final PExpr ifTrue,
+      ifFalse: final PExpr ifFalse,
+    ):
+      _previewCollectStrLiterals(condition, visit);
+      _previewCollectStrLiterals(ifTrue, visit);
+      _previewCollectStrLiterals(ifFalse, visit);
+    case PCall(args: final List<PExpr> args):
+      for (final PExpr arg in args) {
+        _previewCollectStrLiterals(arg, visit);
+      }
+    case PNum():
+    case PVar():
+    case PBool():
+      break;
+  }
+}
+
 /// True when [expr] contains no `PVar` and no `PCall` anywhere in its tree —
 /// the editor's mirror of the plugin's `ExprEvaluator.isConstant`. A call is
 /// never folded even with constant arguments: folding runs against an empty
@@ -364,6 +403,17 @@ List<HuiIssue> validatePreviewDoc(
 
   final Set<String> declaredVars = previewDeclaredVars(doc);
 
+  void warnLegacyLangKey(String value, String path) {
+    if (!value.startsWith(kLegacyPreviewLangPrefix)) return;
+    add(
+      HuiSeverity.warning,
+      path,
+      'Lang key "$value" uses the legacy "$kLegacyPreviewLangPrefix" prefix, '
+      'renamed in Gloss; imported docs are rewritten on import.',
+      fix: 'Use "${previewRenamedLangKey(value)}".',
+    );
+  }
+
   /// Parses [raw] (when it is an expression string) and checks every
   /// variable reference plus, when the whole expression is constant, that it
   /// evaluates cleanly (catching a constant division by zero, for instance).
@@ -391,6 +441,9 @@ List<HuiIssue> validatePreviewDoc(
       );
       if (problem != null) add(problem.severity, path, problem.message);
     });
+    _previewCollectStrLiterals(expr, (String value) {
+      warnLegacyLangKey(value, path);
+    });
     if (previewIsConstantExpr(expr)) {
       try {
         evalPreviewExpr(expr, _previewEmptyScope);
@@ -405,6 +458,7 @@ List<HuiIssue> validatePreviewDoc(
       if (value is num || value is bool) return;
       final String path = '$pathPrefix.$key';
       if (value is String) {
+        warnLegacyLangKey(value, path);
         if (!value.startsWith('#')) return;
         try {
           final PExpr expr = parsePreviewExpr(value);

lib/logic/preview_doc_validation.dart

@@ -166,12 +166,27 @@ class SimSlotItem {
   String toString() => 'SimSlotItem($slot, $material x$count)';
 }
 
+/// The lang-key prefix HoloUI shipped before the Gloss merger renamed the
+/// preview keys to [kPreviewLangPrefix]. Gloss's importer rewrites these on
+/// import; the editor resolves them for display and warns in validation.
+const String kLegacyPreviewLangPrefix = 'holoui.preview.';
+
+/// The current preview lang-key prefix, matching `GlossMessages.java`.
+const String kPreviewLangPrefix = 'gloss.preview.';
+
+/// The `gloss.preview.*` twin of a legacy `holoui.preview.*` id, or null when
+/// [key] does not carry the legacy prefix.
+String? previewRenamedLangKey(String key) =>
+    key.startsWith(kLegacyPreviewLangPrefix)
+    ? '$kPreviewLangPrefix${key.substring(kLegacyPreviewLangPrefix.length)}'
+    : null;
+
 /// The English message templates `lang()` renders against.
 ///
 /// `web/assets/catalog/preview-lang-en.json` is generated from the plugin's
-/// `HoloMessages.java` by `tool/extract_preview_lang.dart`; only the templates'
-/// placeholder names and order matter, which is why the snapshot has to come
-/// from the Java constants rather than a locale file.
+/// `GlossMessages.java` by `tool/extract_preview_lang.dart`; only the
+/// templates' placeholder names and order matter, which is why the snapshot
+/// has to come from the Java constants rather than a locale file.
 class PreviewLangCatalog {
   const PreviewLangCatalog(this.messages);
 
@@ -186,6 +201,16 @@ class PreviewLangCatalog {
 
   String? template(String key) => messages[key];
 
+  /// [template] for [key], falling back to its `gloss.preview.*` twin when
+  /// [key] still carries the legacy `holoui.preview.*` prefix — the same
+  /// rename Gloss's importer applies to a whole document on import.
+  String? _resolvedTemplate(String key) {
+    final String? direct = messages[key];
+    if (direct != null) return direct;
+    final String? renamed = previewRenamedLangKey(key);
+    return renamed == null ? null : messages[renamed];
+  }
+
   /// Decodes `{"messages":{"<id>":"<template>"}}`. Never throws: a missing or
   /// malformed snapshot degrades to [empty], and every key then renders as
   /// itself — which is also what the plugin does for an id its catalog does not
@@ -206,15 +231,16 @@ class PreviewLangCatalog {
   /// Renders [key] with [args] bound positionally onto the template's own
   /// placeholder names: argument 1 fills the first `{name}`, argument 2 the
   /// second, and so on. That is what lets a document write
-  /// `lang("holoui.preview.state.smelting_item", item, percent)` and get
+  /// `lang("gloss.preview.state.smelting_item", item, percent)` and get
   /// `Smelting Iron Ore 42%` out of `Smelting {item} {percent}%`.
   ///
-  /// An unknown id renders as itself, arguments past the last placeholder go
-  /// unused, and a placeholder no argument reached stays literal — the lenient
-  /// rendering `HoloLocalization.renderTemplate` performs, which is also the
-  /// path the plugin's own golden snapshots were captured through.
+  /// An unknown id renders as itself (a legacy `holoui.preview.*` id first
+  /// tries its `gloss.preview.*` twin), arguments past the last placeholder
+  /// go unused, and a placeholder no argument reached stays literal — the
+  /// lenient rendering `GlossLocalization.renderTemplate` performs, which is
+  /// also the path the plugin's own golden snapshots were captured through.
   String render(String key, List<Object?> args) {
-    final String template = messages[key] ?? key;
+    final String template = _resolvedTemplate(key) ?? key;
     if (args.isEmpty) return template;
     final List<String> names = orderedPlaceholders(template);
     final Map<String, String> bound = <String, String>{};

lib/logic/preview_sim.dart

@@ -1,11 +1,12 @@
 /// Mirror of the static half of Gloss `TablistService.java`: which format a
 /// player's list name uses, and how tokens substitute into it.
 ///
-/// `chooseListName` (`TablistService.java:54-66`) resolves in this order:
-/// an operator takes `_op` when it exists; a non-blank primary group takes
-/// its own entry; `default` catches the rest (keeping the player's group
-/// name for `$group`); and with no `default` the literal `$player` fallback
-/// applies. `substituteTokens` (`TablistService.java:46-52`) then replaces
+/// `chooseListName` (`TablistService.java`) resolves in this order: an
+/// operator takes `_op` when it exists; a non-blank primary group takes its
+/// own entry, looked up trimmed and lowercased the way `TablistDoc.copyFormats`
+/// normalizes the keys; `default` catches the rest (keeping the player's
+/// group name for `$group`); and with no `default` the literal `$player`
+/// fallback applies. `substituteTokens` (`TablistService.java:46-52`) then replaces
 /// `$player` and `$group`. A blank chosen template makes the plugin RESET
 /// the list name to vanilla rather than applying an empty one
 /// (`TablistService.applyListName`).
@@ -30,10 +31,11 @@ GlossTablistChoice glossTablistChooseListName(
       groupName: glossTablistOpGroupKey,
     );
   }
-  if (primaryGroup != null &&
-      primaryGroup.trim().isNotEmpty &&
-      nameFormats.containsKey(primaryGroup)) {
-    return (template: nameFormats[primaryGroup]!, groupName: primaryGroup);
+  if (primaryGroup != null && primaryGroup.trim().isNotEmpty) {
+    final String groupKey = primaryGroup.trim().toLowerCase();
+    if (nameFormats.containsKey(groupKey)) {
+      return (template: nameFormats[groupKey]!, groupName: primaryGroup);
+    }
   }
   if (nameFormats.containsKey(glossTablistDefaultGroupKey)) {
     return (

lib/logic/tablist_selection.dart

@@ -85,7 +85,9 @@ final class GlossEmojiDoc extends GlossDoc {
   String emoji;
 
   /// A disabled emoji stays listed but is never substituted
-  /// (`EmojiReplacer` constructor filters on `enabled`).
+  /// (`EmojiReplacer` constructor filters on `enabled`). A file that omits
+  /// the key is ENABLED — `EmojiDoc.java` defaults a null wrapper to TRUE in
+  /// its compact constructor.
   bool enabled;
 
   Map<String, dynamic> extras;
@@ -103,7 +105,7 @@ final class GlossEmojiDoc extends GlossDoc {
       revision: glossReadRevision(map),
       trigger: huiReadString(map, 'trigger'),
       emoji: huiReadString(map, 'emoji'),
-      enabled: huiReadBool(map, 'enabled'),
+      enabled: map['enabled'] == null ? true : huiReadBool(map, 'enabled'),
       extras: huiCollectExtras(map, _docKnown),
       absentKeys: <String>{
         if (map['revision'] == null) 'revision',
@@ -122,7 +124,7 @@ final class GlossEmojiDoc extends GlossDoc {
       if (!absentKeys.contains('trigger') || trigger.isNotEmpty)
         'trigger': trigger,
       if (!absentKeys.contains('emoji') || emoji.isNotEmpty) 'emoji': emoji,
-      if (!absentKeys.contains('enabled') || enabled) 'enabled': enabled,
+      if (!absentKeys.contains('enabled') || !enabled) 'enabled': enabled,
     };
     return huiMergeExtras(out, extras);
   }

lib/model/gloss_emoji.dart

@@ -1,5 +1,5 @@
-/// The BubbleLines port: `§`-only colour stripping, the VolmLib soft wrap as
-/// it actually behaves (quirk included), and the blank-line drop.
+/// The BubbleLines port: `§`-only colour stripping, the VolmLib soft wrap,
+/// and the blank-line drop.
 library;
 
 import 'package:gloss_editor/logic/bubble_lines.dart';
@@ -23,18 +23,21 @@ void main() {
       expect(glossFormWrapWords('', 32), '');
     });
 
-    test('wraps on spaces within the window — quirk included', () {
-      // First window ("one two th") wraps at its LAST space, absolute. The
-      // second window ("three four") holds a single space, which the shipped
-      // VolmLib records window-relative (5) and then compares against the
-      // absolute offset (8) — so the wrap point is "missed" and the window
-      // hard-cuts. Java behavior is the contract; the port replays it.
+    test('wraps at the actual space instead of hard-cutting mid-word', () {
       expect(
         glossFormWrapWords('one two three four', 9),
-        'one two\nthree fou\nr',
+        'one two\nthree\nfour',
       );
     });
 
+    test('breaks a single-space pair at the space', () {
+      expect(glossFormWrapWords('hello world', 5), 'hello\nworld');
+    });
+
+    test('breaks exact-width words at every space', () {
+      expect(glossFormWrapWords('aaa bbb ccc', 3), 'aaa\nbbb\nccc');
+    });
+
     test('hard-cuts a word longer than the window (soft mode)', () {
       expect(glossFormWrapWords('abcdefghij', 4), 'abcd\nefgh\nij');
     });
@@ -46,11 +49,9 @@ void main() {
 
   group('glossBubbleSplit', () {
     test('strips, wraps at the style width and drops blank lines', () {
-      // "wonderful wor" + "ld" is the shipped wrap's own answer — the
-      // single-space window quirk again (see the wrap test above).
       expect(
         glossBubbleSplit('§dhello there wonderful world', 13),
-        <String>['hello there', 'wonderful wor', 'ld'],
+        <String>['hello there', 'wonderful', 'world'],
       );
     });