0.0.32

Author: lizmat

Changes

@@ -2,6 +2,10 @@ Revision history for String-Utils
 
 {{$NEXT}}
 
+0.0.32  2024-12-16T17:13:30+01:00
+    - Add support for "abbrev", inspired by Text::Abbrev by
+      Kamila Borowska
+
 0.0.31  2024-12-03T22:36:38+01:00
     - Make "word-at" also return the ordinal number of the word in
       string, and return Empty if not found (instead of Nil)

META6.json

@@ -30,5 +30,5 @@
   ],
   "test-depends": [
   ],
-  "version": "0.0.31"
+  "version": "0.0.32"
 }

README.md

@@ -77,6 +77,8 @@ dd expand-tab("a\tbb\tccc",4);         # "a   bb  ccc"
 
 say word-at("foo bar baz", 5);         # (4 3)
 
+say abbrev(<yes no>).keys.sort;        # (n no y ye yes)
+
 use String::Utils <before after>;  # only import "before" and "after"
 ```
 
@@ -448,6 +450,19 @@ Returns a `List` with the start position, the number of characters of the word,
 
 Returns `Empty` if no word could be found at the given position, or the position was out of range.
 
+abbrev
+------
+
+```raku
+say abbrev(<yes no>).keys.sort;       # (n no y ye yes)
+
+say abbrev(<foo bar baz>).keys.sort;  # (bar baz f fo foo)
+```
+
+Takes 0 or more strings as arguments, and returns a `Map` with all shortest possible unambigious versions of the given strings as keys, and their associated original string as the value.
+
+Inspired by Text::Abbrev module by KamilaBorowska.
+
 AUTHOR
 ======
 

doc/String-Utils.rakudoc

@@ -76,6 +76,8 @@ dd expand-tab("a\tbb\tccc",4);         # "a   bb  ccc"
 
 say word-at("foo bar baz", 5);         # (4 3)
 
+say abbrev(<yes no>).keys.sort;        # (n no y ye yes)
+
 use String::Utils <before after>;  # only import "before" and "after"
 
 =end code
@@ -538,6 +540,22 @@ at the given position, or directly before it (using C<.words> semantics).
 Returns C<Empty> if no word could be found at the given position, or the
 position was out of range.
 
+=head2 abbrev
+
+=begin code :lang<raku>
+
+say abbrev(<yes no>).keys.sort;       # (n no y ye yes)
+
+say abbrev(<foo bar baz>).keys.sort;  # (bar baz f fo foo)
+
+=end code
+
+Takes 0 or more strings as arguments, and returns a C<Map> with all
+shortest possible unambigious versions of the given strings as keys,
+and their associated original string as the value.
+
+Inspired by Text::Abbrev module by KamilaBorowska.
+
 =head1 AUTHOR
 
 Elizabeth Mattijsen <[email protected]>

lib/String/Utils.rakumod

@@ -570,6 +570,38 @@ my sub word-at(str $string, int $cursor) {
     }
 }
 
+my proto sub abbrev(|) {*}
+my multi sub abbrev() { BEGIN Map.new }
+my multi sub abbrev(*@words) { abbrev(@words) }
+my multi sub abbrev(@words) {
+    my $result := Map.new;
+    my $seen   := nqp::getattr($result,Map,'$!storage');
+    for @words -> str $word {
+        nqp::bindkey($seen,$word,$word);
+
+        my int $chars = nqp::chars($word);
+        nqp::while(
+          --$chars > 0,
+          nqp::stmts(
+            (my str $needle = nqp::substr($word,0,$chars)),
+            nqp::if(
+              nqp::existskey($seen,$needle),
+              nqp::stmts(
+                nqp::deletekey($seen,$needle),
+                nqp::while(
+                  --$chars,
+                  nqp::deletekey($seen,nqp::substr($word,0,$chars))
+                )
+              ),
+              nqp::bindkey($seen,$needle,$word)
+            )
+          )
+        );
+    }
+
+    $result
+}
+
 my sub EXPORT(*@names) {
     Map.new: @names
       ?? @names.map: {

t/01-basic.rakutest

@@ -1,7 +1,7 @@
 use Test;
 use String::Utils;
 
-plan 109;
+plan 111;
 
 is after("foobar","foo"),       "bar", 'after(foo) ok?';
 is "foobar".&after("foo"),      "bar", '.&after(foo) ok?';
@@ -135,6 +135,11 @@ is-deeply word-at($string, $_), ( 1,3,0), "'foo' at $_" for 1 .. 4;
 is-deeply word-at($string, $_), ( 6,3,1), "'bar' at $_" for 6 .. 9;
 is-deeply word-at($string, $_), (10,3,2), "'baz' at $_" for 10 .. 13;
 
-is paragraphs($*PROGRAM.lines).elems, 32, 'reading from file lazily';
+is-deeply abbrev(<yes no>), <n no no no y yes ye yes yes yes>.Map,
+  "did yes/no abbreviate correctly";
+is-deeply abbrev(<foo bar baz>), <bar bar baz baz f foo fo foo foo foo>.Map,
+  "did foo/bar/baz abbreviate correctly";
+
+is paragraphs($*PROGRAM.lines).elems, 33, 'reading from file lazily';
 
 # vim: expandtab shiftwidth=4

t/02-selective-importing.rakutest

@@ -1,10 +1,10 @@
 use Test;
 
 my constant @subs = <
-  after all-same around before between between-included chomp-needle
-  consists-of expand-tab has-marks is-sha1 is-lowercase is-uppercase
-  is-whitespace leading-whitespace leaf letters ngram non-word
-  regexify root stem trailing-whitespace word-at
+  abbrev after all-same around before between between-included
+  chomp-needle consists-of expand-tab has-marks is-sha1 is-lowercase
+  is-uppercase is-whitespace leading-whitespace leaf letters ngram
+  non-word regexify root stem trailing-whitespace word-at
 >;
 
 plan @subs + 2;