CI test prior to release

Author: lizmat

Changes

@@ -1,6 +1,8 @@
 Revision history for String-Utils
 
 {{$NEXT}}
+    - Added support for "text-from-url"
+    - Tightened up coverage testing to 96%
 
 0.0.34  2025-07-23T12:51:51+02:00
     - Ordered code alphabetically for better maintainability

README.md

@@ -79,6 +79,8 @@ say sha1("foo bar baz";                # C7567E8B39E...
 say stem "foo.tar.gz";                 # foo
 say stem "foo.tar.gz", 1;              # foo.tar
 
+say text-from-url $url, :verbose;      # ...
+
 dd trailing-whitespace("bar \t ");     # " \t "
 
 say word-at("foo bar baz", 5);         # (4 3 1)
@@ -454,6 +456,17 @@ say stem "foo.tar.gz", *;  # foo
 
 Return the stem of a string with all of its extensions removed. Optionally accepts a second argument indicating the number of extensions to be removed. This may be `*` (aka `Whatever`) to indicate to remove all extensions.
 
+text-from-url
+-------------
+
+```raku
+my $text = text-from-url $url, :verbose;
+```
+
+Returns the text found at the given URL, or `Nil` if the fetch of the text failed for some reason. Takes an optional `:verbose` named argument: if specified with a trueish value, will show any error output that was received on `STDERR`: defaults to False, to quietly just return `Nil` on error.
+
+Assumes the `curl` command-line program is installed and a network connection is available.
+
 trailing-whitespace
 -------------------
 

doc/String-Utils.rakudoc

@@ -77,6 +77,8 @@ say sha1("foo bar baz";                # C7567E8B39E...
 say stem "foo.tar.gz";                 # foo
 say stem "foo.tar.gz", 1;              # foo.tar
 
+say text-from-url $url, :verbose;      # ...
+
 dd trailing-whitespace("bar \t ");     # " \t "
 
 say word-at("foo bar baz", 5);         # (4 3 1)
@@ -477,6 +479,21 @@ Optionally accepts a second argument indicating the number of extensions
 to be removed.  This may be C<*> (aka C<Whatever>) to indicate to
 remove all extensions.
 
+=head2 text-from-url
+
+=begin code :lang<raku>
+my $text = text-from-url $url, :verbose;
+=end code
+
+Returns the text found at the given URL, or C<Nil> if the fetch of the
+text failed for some reason.  Takes an optional C<:verbose> named
+argument: if specified with a trueish value, will show any error output
+that was received on C<STDERR>: defaults to False, to quietly just
+return C<Nil> on error.
+
+Assumes the C<curl> command-line program is installed and a network
+connection is available.
+
 =head2 trailing-whitespace
 
 =begin code :lang<raku>

lib/String/Utils.rakumod

@@ -184,10 +184,10 @@ my sub expand-tab(str $spec, int $size) {
               nqp::islt_i(++$i,$end),
               nqp::stmts(
                 (my str $part = nqp::atpos_s(@parts,$i)),
-                ($width = $width + nqp::chars($part)),
-                (my int $add = $size - nqp::mod_i($width,$size)),
-                nqp::bindpos_s(@parts,$i,nqp::concat($part,nqp::x(' ',$add))),
-                ($width = $width + $add)
+                ($width = $width + nqp::chars($part)),  # UNCOVERABLE
+                (my int $add = $size - nqp::mod_i($width,$size)),  # UNCOVERABLE
+                nqp::bindpos_s(@parts,$i,nqp::concat($part,nqp::x(' ',$add))),  # UNCOVERABLE
+                ($width = $width + $add)  # UNCOVERABLE
               )
             );
             nqp::join('',@parts)
@@ -218,7 +218,7 @@ my sub is-sha1(str $needle) {
     if nqp::chars($needle) == 40 {
         my $map := BEGIN {
             my int @map;
-            @map[.ord] = 1 for "0123456789ABCDEF".comb;
+            @map[.ord] = 1 for "0123456789ABCDEF".comb;  # UNCOVERABLE
             @map;
         }
 
@@ -243,7 +243,7 @@ my sub is-whitespace(str $string) {
 }
 
 #- leading-whitespace ----------------------------------------------------------
-my sub leading-whitespace(str $string) {
+my sub leading-whitespace(str $string) {  # UNCOVERABLE
     nqp::substr($string,0,nqp::findnotcclass(
       nqp::const::CCLASS_WHITESPACE,$string,0,nqp::chars($string)
     ))
@@ -322,17 +322,17 @@ my class NGrams does PredictiveIterator {
     has int $!pos;
     has int $!todo;
     method !SET-SELF($string, $size, $limit, $step, $partial) {
-        $!str   = $string;
+        $!str   = $string;  # UNCOVERABLE
         $!what := $string.WHAT;
         $!size  = $size < 1 ?? 1 !! $size;
         $!step  = $step < 1 ?? 1 !! $step;
         $!pos   = -$step;
-        $!todo = (
+        $!todo = (  # UNCOVERABLE
           nqp::chars($!str) + $!step - ($partial ?? 1 !! $!size)
         ) div $!step;
         $!todo  = $limit
           unless nqp::istype($limit,Whatever) || $limit > $!todo;
-        $!todo  = $!todo + 1;
+        $!todo  = $!todo + 1;  # UNCOVERABLE
         self
     }
     method new($string, $size, $limit, $step, $partial) {
@@ -341,7 +341,7 @@ my class NGrams does PredictiveIterator {
           !! Rakudo::Iterator.Empty
     }
     method pull-one() {
-        --$!todo
+        --$!todo  # UNCOVERABLE
           ?? nqp::box_s(
                nqp::substr($!str,($!pos = $!pos + $!step),$!size),
                $!what
@@ -430,7 +430,7 @@ my sub nomark(str $string) {
 }
 
 #- non-word --------------------------------------------------------------------
-my sub non-word(str $string) {
+my sub non-word(str $string) {  # UNCOVERABLE
     nqp::hllbool(
       nqp::islt_i(
         nqp::findnotcclass(
@@ -475,8 +475,8 @@ my multi sub paragraphs(@source, Int:D $initial = 0, :$Pair = Pair) {
             }
 
             my sub paragraph(str $next) {
-               $!line = $line;
-               $!next = $next;
+               $!line = $line;  # UNCOVERABLE
+               $!next = $next;  # UNCOVERABLE
 
                $!Pair.new(
                   $line - nqp::elems($collected),
@@ -506,14 +506,14 @@ my multi sub paragraphs(@source, Int:D $initial = 0, :$Pair = Pair) {
 
             # Single line after last paraghraph
             if $!next {
-                $!iterator := nqp::null;
+                $!iterator := nqp::null;  # UNCOVERABLE
                 $!next
             }
 
             # Still need to produce final paragraph
-            elsif nqp::elems($collected) {
-                $!iterator := nqp::null;
-                ++$line;
+            elsif nqp::elems($collected) {  # UNCOVERABLE
+                $!iterator := nqp::null;  # UNCOVERABLE
+                ++$line;  # UNCOVERABLE
                 paragraph("")
             }
 
@@ -580,7 +580,7 @@ my sub root(*@s) {
 }
 
 #- sha1 ------------------------------------------------------------------------
-my sub sha1(str $needle) { nqp::sha1($needle) }
+my sub sha1(str $needle) { nqp::sha1($needle) }  # UNCOVERABLE
 
 #- stem ------------------------------------------------------------------------
 my sub stem(str $basename, $parts = *) {
@@ -595,6 +595,18 @@ my sub stem(str $basename, $parts = *) {
       !! $basename
 }
 
+#- text-from-url ---------------------------------------------------------------
+my sub text-from-url(str $url, :$verbose) {
+    my $proc := run 'curl', '--fail', $url, :out, :err ;
+    if $proc.exitcode {
+        $*ERR.put: $proc.err.slurp if $verbose;
+        Nil
+    }
+    else {
+        $proc.out.slurp
+    }
+}
+
 #- trailing-whitespace ---------------------------------------------------------
 my sub trailing-whitespace(str $string) {
     nqp::substr($string,nqp::chars($string) - nqp::findnotcclass(
@@ -619,7 +631,7 @@ my sub word-at(str $string, int $cursor) {
           )) < $cursor,
           nqp::stmts(
             nqp::if($pos > $last, ++$index),
-            ($last  = $pos + 1)
+            ($last  = $pos + 1)  # UNCOVERABLE
           )
         );
         $last >= $length || $pos == $last

t/01-basic.rakutest

@@ -1,7 +1,7 @@
 use Test;
 use String::Utils;
 
-plan 115;
+plan 117;
 
 is after("foobar","foo"),       "bar", 'after(foo) ok?';
 is "foobar".&after("foo"),      "bar", '.&after(foo) ok?';
@@ -137,8 +137,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-deeply abbrev(<yes no>), <n no no no y yes ye yes yes yes>.Map,
-  "did yes/no abbreviate correctly";
+is-deeply abbrev(), Map.new, 'No arguments give an empty Map';
+for \(<yes no>), \("yes","no") -> \c {
+    is-deeply abbrev(|c), <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";
 

t/02-selective-importing.rakutest

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

xt/coverage.rakutest

@@ -2,9 +2,9 @@ use Test::Coverage;
 
 plan 2;
 
-coverage-at-least 79;
+coverage-at-least 96;
 
-uncovered-at-most 24;
+uncovered-at-most 4;
 
 report;
 

xt/networked.rakutest

@@ -0,0 +1,13 @@
+use Test;
+
+use String::Utils;
+
+plan 2;
+
+my $url := "https://360.zef.pm";
+
+ok text-from-url($url).chars >=  7480122, 'looks like a correct zef index';
+
+is-deeply text-from-url($url.chop), Nil, 'did we get a failure';
+
+# vim: expandtab shiftwidth=4