From: Lady <redacted>
Date: Sat, 11 Nov 2023 03:36:51 +0000 (-0500)
Subject: Rename Ascii‐related functions in string.js
X-Git-Url: https://git.ladys.computer/Pisces/commitdiff_plain/31c8b17d21df315e62587419c88bee178b2b44f0?ds=inline

Rename Ascii‐related functions in string.js

Treating Ascii as a pronouncable acronym, not an unpronouncable one.
---

diff --git a/string.js b/string.js
index 0c603ac..6d4d229 100644
--- a/string.js
+++ b/string.js
@@ -529,19 +529,19 @@ export const stringFromCodepoints = createArrowFunction(
 );
 
 /**
- * Returns the result of splitting the provided value on A·S·C·I·I
+ * Returns the result of splitting the provided value on Ascii
  * whitespace.
  */
-export const splitOnASCIIWhitespace = ($) =>
-  stringSplit(stripAndCollapseASCIIWhitespace($), " ");
+export const splitOnAsciiWhitespace = ($) =>
+  stringSplit(stripAndCollapseAsciiWhitespace($), " ");
 
 /**
  * Returns the result of splitting the provided value on commas,
- * trimming A·S·C·I·I whitespace from the resulting tokens.
+ * trimming Ascii whitespace from the resulting tokens.
  */
 export const splitOnCommas = ($) =>
   stringSplit(
-    stripLeadingAndTrailingASCIIWhitespace(
+    stripLeadingAndTrailingAsciiWhitespace(
       stringReplaceAll(
         `${$}`,
         /[\n\r\t\f ]*,[\n\r\t\f ]*/gu,
@@ -703,12 +703,12 @@ export const stringValue = createCallableFunction(
 );
 
 /**
- * Returns the result of stripping leading and trailing A·S·C·I·I
- * whitespace from the provided value and collapsing other A·S·C·I·I
+ * Returns the result of stripping leading and trailing Ascii
+ * whitespace from the provided value and collapsing other Ascii
  * whitespace in the string representation of the provided value.
  */
-export const stripAndCollapseASCIIWhitespace = ($) =>
-  stripLeadingAndTrailingASCIIWhitespace(
+export const stripAndCollapseAsciiWhitespace = ($) =>
+  stripLeadingAndTrailingAsciiWhitespace(
     stringReplaceAll(
       `${$}`,
       /[\n\r\t\f ]+/gu,
@@ -717,10 +717,10 @@ export const stripAndCollapseASCIIWhitespace = ($) =>
   );
 
 /**
- * Returns the result of stripping leading and trailing A·S·C·I·I
+ * Returns the result of stripping leading and trailing Ascii
  * whitespace from the string representation of the provided value.
  */
-export const stripLeadingAndTrailingASCIIWhitespace = ($) =>
+export const stripLeadingAndTrailingAsciiWhitespace = ($) =>
   call(reExec, /^[\n\r\t\f ]*([^]*?)[\n\r\t\f ]*$/u, [$])[1];
 
 /**
diff --git a/string.test.js b/string.test.js
index e98a040..1adcd08 100644
--- a/string.test.js
+++ b/string.test.js
@@ -32,7 +32,7 @@ import {
   Matcher,
   rawString,
   scalarValues,
-  splitOnASCIIWhitespace,
+  splitOnAsciiWhitespace,
   splitOnCommas,
   stringCatenate,
   stringEndsWith,
@@ -52,8 +52,8 @@ import {
   stringSplit,
   stringStartsWith,
   stringValue,
-  stripAndCollapseASCIIWhitespace,
-  stripLeadingAndTrailingASCIIWhitespace,
+  stripAndCollapseAsciiWhitespace,
+  stripLeadingAndTrailingAsciiWhitespace,
   substring,
   toScalarValueString,
   toString,
@@ -986,67 +986,67 @@ describe("scalarValues", () => {
   });
 });
 
-describe("splitOnASCIIWhitespace", () => {
+describe("splitOnAsciiWhitespace", () => {
   it("[[Call]] splits on sequences of spaces", () => {
     assertEquals(
-      splitOnASCIIWhitespace("🅰️   🅱️ 🆎  🅾️"),
+      splitOnAsciiWhitespace("🅰️   🅱️ 🆎  🅾️"),
       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] splits on sequences of tabs", () => {
     assertEquals(
-      splitOnASCIIWhitespace("🅰️\t\t\t🅱️\t🆎\t\t🅾️"),
+      splitOnAsciiWhitespace("🅰️\t\t\t🅱️\t🆎\t\t🅾️"),
       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] splits on sequences of carriage returns", () => {
     assertEquals(
-      splitOnASCIIWhitespace("🅰️\r\r\r🅱️\r🆎\r\r🅾️"),
+      splitOnAsciiWhitespace("🅰️\r\r\r🅱️\r🆎\r\r🅾️"),
       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] splits on sequences of newlines", () => {
     assertEquals(
-      splitOnASCIIWhitespace("🅰️\r\r\r🅱️\r🆎\r\r🅾️"),
+      splitOnAsciiWhitespace("🅰️\r\r\r🅱️\r🆎\r\r🅾️"),
       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] splits on sequences of form feeds", () => {
     assertEquals(
-      splitOnASCIIWhitespace("🅰️\f\f\f🅱️\f🆎\f\f🅾️"),
+      splitOnAsciiWhitespace("🅰️\f\f\f🅱️\f🆎\f\f🅾️"),
       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] splits on mixed whitespace", () => {
     assertEquals(
-      splitOnASCIIWhitespace("🅰️\f \t\n🅱️\r\n\r🆎\n\f🅾️"),
+      splitOnAsciiWhitespace("🅰️\f \t\n🅱️\r\n\r🆎\n\f🅾️"),
       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] returns an array of just the empty string for the empty string", () => {
-    assertEquals(splitOnASCIIWhitespace(""), [""]);
+    assertEquals(splitOnAsciiWhitespace(""), [""]);
   });
 
   it("[[Call]] returns a single token if there are no spaces", () => {
-    assertEquals(splitOnASCIIWhitespace("abcd"), ["abcd"]);
+    assertEquals(splitOnAsciiWhitespace("abcd"), ["abcd"]);
   });
 
   it("[[Call]] does not split on other kinds of whitespace", () => {
     assertEquals(
-      splitOnASCIIWhitespace("a\u202F\u205F\xa0\v\0\bb"),
+      splitOnAsciiWhitespace("a\u202F\u205F\xa0\v\0\bb"),
       ["a\u202F\u205F\xa0\v\0\bb"],
     );
   });
 
   it("[[Call]] trims leading and trailing whitespace", () => {
     assertEquals(
-      splitOnASCIIWhitespace(
+      splitOnAsciiWhitespace(
         "\f\r\n\r\n \n\t🅰️\f \t\n🅱️\r🆎\n\f🅾️\n\f",
       ),
       ["🅰️", "🅱️", "🆎", "🅾️"],
@@ -1054,20 +1054,20 @@ describe("splitOnASCIIWhitespace", () => {
   });
 
   it("[[Construct]] throws an error", () => {
-    assertThrows(() => new splitOnASCIIWhitespace(""));
+    assertThrows(() => new splitOnAsciiWhitespace(""));
   });
 
   describe(".length", () => {
     it("[[Get]] returns the correct length", () => {
-      assertStrictEquals(splitOnASCIIWhitespace.length, 1);
+      assertStrictEquals(splitOnAsciiWhitespace.length, 1);
     });
   });
 
   describe(".name", () => {
     it("[[Get]] returns the correct name", () => {
       assertStrictEquals(
-        splitOnASCIIWhitespace.name,
-        "splitOnASCIIWhitespace",
+        splitOnAsciiWhitespace.name,
+        "splitOnAsciiWhitespace",
       );
     });
   });
@@ -1753,17 +1753,17 @@ describe("stringStartsWith", () => {
   });
 });
 
-describe("stripAndCollapseASCIIWhitespace", () => {
+describe("stripAndCollapseAsciiWhitespace", () => {
   it("[[Call]] collapses mixed inner whitespace", () => {
     assertEquals(
-      stripAndCollapseASCIIWhitespace("🅰️\f \t\n🅱️\r\n\r🆎\n\f🅾️"),
+      stripAndCollapseAsciiWhitespace("🅰️\f \t\n🅱️\r\n\r🆎\n\f🅾️"),
       "🅰️ 🅱️ 🆎 🅾️",
     );
   });
 
   it("[[Call]] trims leading and trailing whitespace", () => {
     assertStrictEquals(
-      stripAndCollapseASCIIWhitespace(
+      stripAndCollapseAsciiWhitespace(
         "\f\r\n\r\n \n\t\f 🅰️\f \t\n🅱️\r\n\r🆎\n\f🅾️\n\f",
       ),
       "🅰️ 🅱️ 🆎 🅾️",
@@ -1772,42 +1772,42 @@ describe("stripAndCollapseASCIIWhitespace", () => {
 
   it("[[Call]] returns the empty string for strings of whitespace", () => {
     assertStrictEquals(
-      stripAndCollapseASCIIWhitespace("\f\r\n\r\n \n\t\f \n\f"),
+      stripAndCollapseAsciiWhitespace("\f\r\n\r\n \n\t\f \n\f"),
       "",
     );
   });
 
   it("[[Call]] does not collapse other kinds of whitespace", () => {
     assertEquals(
-      stripAndCollapseASCIIWhitespace("a\u202F\u205F\xa0\v\0\bb"),
+      stripAndCollapseAsciiWhitespace("a\u202F\u205F\xa0\v\0\bb"),
       "a\u202F\u205F\xa0\v\0\bb",
     );
   });
 
   it("[[Construct]] throws an error", () => {
-    assertThrows(() => new stripAndCollapseASCIIWhitespace(""));
+    assertThrows(() => new stripAndCollapseAsciiWhitespace(""));
   });
 
   describe(".length", () => {
     it("[[Get]] returns the correct length", () => {
-      assertStrictEquals(stripAndCollapseASCIIWhitespace.length, 1);
+      assertStrictEquals(stripAndCollapseAsciiWhitespace.length, 1);
     });
   });
 
   describe(".name", () => {
     it("[[Get]] returns the correct name", () => {
       assertStrictEquals(
-        stripAndCollapseASCIIWhitespace.name,
-        "stripAndCollapseASCIIWhitespace",
+        stripAndCollapseAsciiWhitespace.name,
+        "stripAndCollapseAsciiWhitespace",
       );
     });
   });
 });
 
-describe("stripLeadingAndTrailingASCIIWhitespace", () => {
+describe("stripLeadingAndTrailingAsciiWhitespace", () => {
   it("[[Call]] trims leading and trailing whitespace", () => {
     assertStrictEquals(
-      stripLeadingAndTrailingASCIIWhitespace(
+      stripLeadingAndTrailingAsciiWhitespace(
         "\f\r\n\r\n \n\t\f 🅰️🅱️🆎🅾️\n\f",
       ),
       "🅰️🅱️🆎🅾️",
@@ -1816,14 +1816,14 @@ describe("stripLeadingAndTrailingASCIIWhitespace", () => {
 
   it("[[Call]] returns the empty string for strings of whitespace", () => {
     assertStrictEquals(
-      stripLeadingAndTrailingASCIIWhitespace("\f\r\n\r\n \n\t\f \n\f"),
+      stripLeadingAndTrailingAsciiWhitespace("\f\r\n\r\n \n\t\f \n\f"),
       "",
     );
   });
 
   it("[[Call]] does not trim other kinds of whitespace", () => {
     assertEquals(
-      stripLeadingAndTrailingASCIIWhitespace(
+      stripLeadingAndTrailingAsciiWhitespace(
         "\v\u202F\u205Fx\0\b\xa0",
       ),
       "\v\u202F\u205Fx\0\b\xa0",
@@ -1832,19 +1832,19 @@ describe("stripLeadingAndTrailingASCIIWhitespace", () => {
 
   it("[[Call]] does not adjust inner whitespace", () => {
     assertEquals(
-      stripLeadingAndTrailingASCIIWhitespace("a   b"),
+      stripLeadingAndTrailingAsciiWhitespace("a   b"),
       "a   b",
     );
   });
 
   it("[[Construct]] throws an error", () => {
-    assertThrows(() => new stripLeadingAndTrailingASCIIWhitespace(""));
+    assertThrows(() => new stripLeadingAndTrailingAsciiWhitespace(""));
   });
 
   describe(".length", () => {
     it("[[Get]] returns the correct length", () => {
       assertStrictEquals(
-        stripLeadingAndTrailingASCIIWhitespace.length,
+        stripLeadingAndTrailingAsciiWhitespace.length,
         1,
       );
     });
@@ -1853,8 +1853,8 @@ describe("stripLeadingAndTrailingASCIIWhitespace", () => {
   describe(".name", () => {
     it("[[Get]] returns the correct name", () => {
       assertStrictEquals(
-        stripLeadingAndTrailingASCIIWhitespace.name,
-        "stripLeadingAndTrailingASCIIWhitespace",
+        stripLeadingAndTrailingAsciiWhitespace.name,
+        "stripLeadingAndTrailingAsciiWhitespace",
       );
     });
   });