]> Lady’s Gitweb - Pisces/commitdiff
Rename Ascii‐related functions in string.js
authorLady <redacted>
Sat, 11 Nov 2023 03:36:51 +0000 (22:36 -0500)
committerLady <redacted>
Fri, 17 Nov 2023 02:24:03 +0000 (21:24 -0500)
Treating Ascii as a pronouncable acronym, not an unpronouncable one.

string.js
string.test.js

index 0c603acbfa47b70c051c1c452ab3bbce582a88c7..6d4d2290d59582e07c1d342f043305723f124761 100644 (file)
--- 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];
 
 /**
index e98a040bdd1f080697f8c094c41498b4678a3075..1adcd08421987ae3c5f28cda7a7a541e39ceae94 100644 (file)
@@ -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",
       );
     });
   });
This page took 0.032158 seconds and 4 git commands to generate.