File Coverage

blib/lib/Trim.pm

Criterion	Covered	Total	%
statement	66	66	100.0
branch	36	44	81.8
condition			n/a
subroutine	9	9	100.0
pod	1	2	50.0
total	112	121	92.5

#!/usr/bin/perl
#-------------------------------------------------------------------------------
# Trim various things by removing leading and trailing whitespace.
# Philip R Brenan at appaapps dot com, Appa Apps Ltd Inc., 2021
#-------------------------------------------------------------------------------
# podDocumentation
package Trim;
our $VERSION = "20210401";
use warnings FATAL => qw(all);
use strict;
use feature qw(say current_sub);

#D1 Trim                                                                        # Trim strings, arrays, hashes in situ and clones thereof.

sub trim(@)                                                                     # Trim somethings.
 {my (@things) = @_;                                                            # Things to be trimmed

  if (@_ == 0)                                                                  # Trim $_ as no argument specified
   {if (!defined(wantarray))                                                    # Void context - trim in place
     {if (!ref)                                                                 # Scalar string in $_ in void context
       {s/\A\s+|\s+\Z//gs;
       }
      elsif (ref eq q(ARRAY))                                                   # Array referenced from $_ in void context
       {for my $i(keys @$_)
         {$$_[$i] = __SUB__->($$_[$i]);
         }
       }
      elsif (ref eq q(HASH))                                                    # Hash referenced from $_ in void context
       {for my $k(keys %$_)
         {$$_{$k} = __SUB__->($$_{$k});
         }
       }
     }
    else                                                                        # Not void context - caller wants something back
     {if (!ref)                                                                 # Scalar string in $_ in non void context
       {return __SUB__->($_);
       }
      elsif (ref eq q(ARRAY))                                                   # Array referenced from $_ in non void context
       {return [__SUB__->(@$_)];
       }
      elsif (ref eq q(HASH))                                                    # Hash referenced from $_ in non void context
       {return {__SUB__->(%$_)};
       }
     }
   }
  else                                                                          # Arguments specified
   {if (!defined(wantarray))                                                    # Void context - trim in place
     {for my $i(keys @_)
       {if (!ref $_[$i])                                                        # Trim scalar in void context
         {$_[$i] = __SUB__->($_[$i]);
         }
        elsif (ref($_[$i]) eq q(ARRAY))                                         # Trim array reference in void context
         {for my $j(keys $_[$i]->@*)
           {$_[$i][$j] = __SUB__->($_[$i][$j]);
           }
         }
        elsif (ref($_[$i]) eq q(HASH))                                          # Trim hash reference  in void context
         {for my $k(keys $_[$i]->%*)
           {$_[$i]{$k} = __SUB__->($_[$i]{$k});
           }
         }
       }
     }
    else                                                                        # Want something back
     {my @r;
      for my $i(keys @_)
       {if (  !ref $_[$i])                                                      # Trim clone of scalar and return cloned value
         {push @r, $_[$i] =~ s/\A\s+|\s+\Z//gsr;
          return $r[0] if @_ == 1;
         }
        elsif (ref($_[$i]) eq q(ARRAY))                                         # Trim clone of array reference and return cloned value
         {my @a;
          for my $j(keys $_[$i]->@*)
           {push @a, __SUB__->($_[$i][$j]);
           }
          push @r, [@a];
          return $r[0] if @_ == 1;
         }
        elsif (ref($_[$i]) eq q(HASH))                                          # Trim clone of hash reference and return cloned value
         {my @a;
          for my $k(keys $_[$i]->%*)
           {push @a, (__SUB__->($k), __SUB__->($_[$i]{$k}));
           }
          push @r, {@a};
          return $r[0] if @_ == 1;
         }
       }
      return wantarray ? @r : @_ == $r[-1];                                     # Return array if requested else last element trimmed
     }
   }
 }

#d
#-------------------------------------------------------------------------------
# Export - eeee
#-------------------------------------------------------------------------------

use Exporter qw(import);

use vars qw(@ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);

@ISA          = qw(Exporter);
@EXPORT       = qw(trim);
@EXPORT_OK    = qw();
%EXPORT_TAGS = (all=>[@EXPORT, @EXPORT_OK]);

# podDocumentation
=pod

=encoding utf-8

=head1 Name

Trim - Trim various things by removing leading and trailing whitespace

=head1 Synopsis

Trim nested structures in situ referenced from $_:

  {$_ = [" a ", " b ", {" c " => {" d\n ", " e "}}];
   trim;
   is_deeply $_, ["a", "b", { c => { d => "e" } }];
  }

Trim nested structures in situ:

  {my $a = [" a ", " b ", {" c " => {" d\n ", " e "}}];
   trim $a;
   is_deeply $a, ["a", "b", { c => { d => "e" } }];
  }

Trim cloned nested structures:

  {my $a = [" a ", " b ", {" c " => {" d\n ", " e "}}];
   my $b = trim $a;
   is_deeply $b, ["a", "b", { c => { d => "e" } }];
  }

=head1 Description

Trim various things by removing leading and trailing whitespace


Version "20210401".


The following sections describe the methods in each functional area of this
module.  For an alphabetic listing of all methods by name see L.



=head1 Trim

Trim strings, arrays, hashes in situ and clones thereof.

=head2 trim(@things)

Trim somethings.

     Parameter  Description
  1  @things    Things to be trimmed

B


    $_ = [" a ", " b ", {" c " => {" d ", " e "}}];                               # Trim nested structures in situ referenced from $_

    trim;  # 𝗘𝘅𝗮𝗺𝗽𝗹𝗲

    is_deeply $_, ["a", "b", { c => { d => "e" } }];
  }

  {my $a = [" a ", " b ", {" c " => {" d ", " e "}}];                             # Trim nested structures in situ

   trim $a;  # 𝗘𝘅𝗮𝗺𝗽𝗹𝗲

   is_deeply $a, ["a", "b", { c => { d => "e" } }];
  }

  {my $a = [" a ", " b ", {" c " => {" d ", " e "}}];                             # Trim cloned nested structures

   my $b = trim $a;  # 𝗘𝘅𝗮𝗺𝗽𝗹𝗲

   is_deeply $b, ["a", "b", { c => { d => "e" } }];



=head1 Index


1 L - Trim somethings.

=head1 Installation

This module is written in 100% Pure Perl and, thus, it is easy to read,
comprehend, use, modify and install via B:

  sudo cpan install Trim

=head1 Author

L

L

=head1 Copyright

Copyright (c) 2016-2021 Philip R Brenan.

This module is free software. It may be used, redistributed and/or modified
under the same terms as Perl itself.

=cut



# Tests and documentation

sub test
 {my $p = __PACKAGE__;
  binmode($_, ":utf8") for *STDOUT, *STDERR;
  return if eval "eof(${p}::DATA)";
  my $s = eval "join('', <${p}::DATA>)";
  $@ and die $@;
  eval $s;
  $@ and die $@;
  1
 }

test unless caller;

1;
# podDocumentation
__DATA__