<h2>Editing File: /usr/local/lib64/perl5/Template/VMethods.pm</h2><form method='post'><textarea name='content' class='file-edit'>#============================================================= -*-Perl-*-
#
# Template::VMethods
#
# DESCRIPTION
#   Module defining virtual methods for the Template Toolkit
#
# AUTHOR
#   Andy Wardley   &lt;abw@wardley.org&gt;
#
# COPYRIGHT
#   Copyright (C) 1996-2022 Andy Wardley.  All Rights Reserved.
#
#   This module is free software; you can redistribute it and/or
#   modify it under the same terms as Perl itself.
#
#============================================================================

package Template::VMethods;

use strict;
use warnings;
use Scalar::Util qw( blessed looks_like_number );
use Template::Filters;

our $VERSION = '3.106';
our $DEBUG   = 0 unless defined $DEBUG;

our $ROOT_VMETHODS = {
    inc     =&gt; \&amp;root_inc,
    dec     =&gt; \&amp;root_dec,
};

our $TEXT_VMETHODS = {
    item        =&gt; \&amp;text_item,
    list        =&gt; \&amp;text_list,
    hash        =&gt; \&amp;text_hash,
    length      =&gt; \&amp;text_length,
    size        =&gt; \&amp;text_size,
    empty       =&gt; \&amp;text_empty,
    defined     =&gt; \&amp;text_defined,
    upper       =&gt; \&amp;text_upper,
    lower       =&gt; \&amp;text_lower,
    ucfirst     =&gt; \&amp;text_ucfirst,
    lcfirst     =&gt; \&amp;text_lcfirst,
    match       =&gt; \&amp;text_match,
    search      =&gt; \&amp;text_search,
    repeat      =&gt; \&amp;text_repeat,
    replace     =&gt; \&amp;text_replace,
    remove      =&gt; \&amp;text_remove,
    split       =&gt; \&amp;text_split,
    chunk       =&gt; \&amp;text_chunk,
    substr      =&gt; \&amp;text_substr,
    trim        =&gt; \&amp;text_trim,
    collapse    =&gt; \&amp;text_collapse,
    squote      =&gt; \&amp;text_squote,
    dquote      =&gt; \&amp;text_dquote,
    html        =&gt; \&amp;Template::Filters::html_filter,
    xml         =&gt; \&amp;Template::Filters::xml_filter,
};

our $HASH_VMETHODS = {
    item    =&gt; \&amp;hash_item,
    hash    =&gt; \&amp;hash_hash,
    size    =&gt; \&amp;hash_size,
    empty   =&gt; \&amp;hash_empty,
    each    =&gt; \&amp;hash_each,
    keys    =&gt; \&amp;hash_keys,
    values  =&gt; \&amp;hash_values,
    items   =&gt; \&amp;hash_items,
    pairs   =&gt; \&amp;hash_pairs,
    list    =&gt; \&amp;hash_list,
    exists  =&gt; \&amp;hash_exists,
    defined =&gt; \&amp;hash_defined,
    delete  =&gt; \&amp;hash_delete,
    import  =&gt; \&amp;hash_import,
    sort    =&gt; \&amp;hash_sort,
    nsort   =&gt; \&amp;hash_nsort,
};

our $LIST_VMETHODS = {
    item    =&gt; \&amp;list_item,
    list    =&gt; \&amp;list_list,
    hash    =&gt; \&amp;list_hash,
    push    =&gt; \&amp;list_push,
    pop     =&gt; \&amp;list_pop,
    unshift =&gt; \&amp;list_unshift,
    shift   =&gt; \&amp;list_shift,
    max     =&gt; \&amp;list_max,
    size    =&gt; \&amp;list_size,
    empty   =&gt; \&amp;list_empty,
    defined =&gt; \&amp;list_defined,
    first   =&gt; \&amp;list_first,
    last    =&gt; \&amp;list_last,
    reverse =&gt; \&amp;list_reverse,
    grep    =&gt; \&amp;list_grep,
    join    =&gt; \&amp;list_join,
    sort    =&gt; \&amp;list_sort,
    nsort   =&gt; \&amp;list_nsort,
    unique  =&gt; \&amp;list_unique,
    import  =&gt; \&amp;list_import,
    merge   =&gt; \&amp;list_merge,
    slice   =&gt; \&amp;list_slice,
    splice  =&gt; \&amp;list_splice,
};

# Template::Stash needs the above, so defer loading this module
# until they are defined.
require Template::Stash;
our $PRIVATE = $Template::Stash::PRIVATE;

#========================================================================
# root virtual methods
#========================================================================

sub root_inc {
    no warnings;
    my $item = shift;
    ++$item;
}

sub root_dec {
    no warnings;
    my $item = shift;
    --$item;
}


#========================================================================
# text virtual methods
#========================================================================

sub text_item {
    $_[0];
}

sub text_list {
    [ $_[0] ];
}

sub text_hash {
    { value =&gt; $_[0] };
}

sub text_length {
    length $_[0];
}

sub text_size {
    return 1;
}

sub text_empty {
    return 0 == text_length($_[0]) ? 1 : 0;
}

sub text_defined {
    return 1;
}

sub text_upper {
    return uc $_[0];
}

sub text_lower {
    return lc $_[0];
}

sub text_ucfirst {
    return ucfirst $_[0];
}

sub text_lcfirst {
    return lcfirst $_[0];
}

sub text_trim {
    my $text = $_[0];
    $text =~ s/^\s+//;
    $text =~ s/\s+$//;
    return $text;
}

sub text_collapse {
    my $text = $_[0];
    $text =~ s/^\s+//;
    $text =~ s/\s+$//;
    $text =~ s/\s+/ /g;
    return $text;
}

sub text_match {
    my ($str, $search, $global) = @_;
    return $str unless defined $str and defined $search;
    my @matches = $global ? ($str =~ /$search/g)
        : ($str =~ /$search/);
    return @matches ? \@matches : '';
}

sub text_search {
    my ($str, $pattern) = @_;
    return $str unless defined $str and defined $pattern;
    return $str =~ /$pattern/;
}

sub text_repeat {
    my ($str, $count) = @_;
    $str //= '';
    return '' unless $count;
    return $str x $count;
}

sub text_replace {
    my ($text, $pattern, $replace, $global) = @_;
    $text    //= '';
    $pattern //= '';
    $replace //= '';
    $global  //= 1;

    if ($replace =~ /\$\d+/) {
        # replacement string may contain backrefs
        my $expand = sub {
            my ($chunk, $start, $end) = @_;
            $chunk =~ s{ \\(\\|\$) | \$ (\d+) }{
                $1 ? $1
                    : ($2 &gt; $#$start || $2 == 0 || !defined $start-&gt;[$2]) ? ''
                    : substr($text, $start-&gt;[$2], $end-&gt;[$2] - $start-&gt;[$2]);
            }exg;
            $chunk;
        };
        if ($global) {
            my $prev_end = -1;
            $text =~ s{$pattern}{
                my $s = $-[0];
                my $e = $+[0];
                if ($s == $e &amp;&amp; $s == $prev_end) {
                    '';
                } else {
                    $prev_end = $e;
                    &amp;$expand($replace, [@-], [@+]);
                }
            }eg;
        }
        else {
            $text =~ s{$pattern}{ &amp;$expand($replace, [@-], [@+]) }e;
        }
    }
    else {
        if ($global) {
            my $prev_end = -1;
            $text =~ s{$pattern}{
                my $s = $-[0];
                my $e = $+[0];
                if ($s == $e &amp;&amp; $s == $prev_end) {
                    '';
                } else {
                    $prev_end = $e;
                    $replace;
                }
            }eg;
        }
        else {
            $text =~ s/$pattern/$replace/;
        }
    }
    return $text;
}

sub text_remove {
    my ($str, $search) = @_;
    return $str unless defined $str and defined $search;
    $str =~ s/$search//g;
    return $str;
}

sub text_split {
    my ($str, $split, $limit) = @_;
    $str //= '';

    # For versions of Perl prior to 5.18 we have to be very careful about
    # spelling out each possible combination of arguments because split()
    # is very sensitive to them, for example C&lt;split(' ', ...)&gt; behaves
    # differently to C&lt;$space=' '; split($space, ...)&gt;.  Test 33 of
    # vmethods/text.t depends on this behaviour.

    if ($] &lt; 5.018) {
        if (defined $limit) {
            return [
                defined $split
                    ? split($split, $str, $limit)
                    : split(' ', $str, $limit)
            ];
        }
        else {
            return [
                defined $split
                    ? split($split, $str)
                    : split(' ', $str)
            ];
        }
    }

    # split's behavior changed in Perl 5.18.0 making this:
    # C&lt;$space=' '; split($space, ...)&gt;
    # behave the same as this:
    # C&lt;split(' ', ...)&gt;
    # qr// behaves the same, so use that for user-defined split.

    my $split_re;
    if (defined $split) {
        eval {
            $split_re = qr/$split/;
        };
    }
    $split_re //= ' ';
    $limit ||= 0;
    return [split($split_re, $str, $limit)];
}

sub text_chunk {
    my ($string, $size) = @_;
    my @list;
    $size ||= 1;
    if ($size &lt; 0) {
        # sexeger!  It's faster to reverse the string, search
        # it from the front and then reverse the output than to
        # search it from the end, believe it nor not!
        $string = reverse $string;
        $size = -$size;
        unshift(@list, scalar reverse $1)
            while ($string =~ /((.{$size})|(.+))/g);
    }
    else {
        push(@list, $1) while ($string =~ /((.{$size})|(.+))/g);
    }
    return \@list;
}

sub text_substr {
    my ($text, $offset, $length, $replacement) = @_;
    $offset ||= 0;

    if(defined $length) {
        if (defined $replacement) {
            substr( $text, $offset, $length, $replacement );
            return $text;
        }
        else {
            return substr( $text, $offset, $length );
        }
    }
    else {
        return substr( $text, $offset );
    }
}

sub text_squote {
    my $text = shift;
    for ($text) {
        s/(['\\])/\\$1/g;
    }
    return $text;
}

sub text_dquote {
    my $text = shift;
    for ($text) {
        s/([&quot;\\])/\\$1/g;
        s/\n/\\n/g;
    }
    return $text;
}

#========================================================================
# hash virtual methods
#========================================================================


sub hash_item {
    my ($hash, $item) = @_;
    $item //= '';
    return if $PRIVATE &amp;&amp; $item =~ /$PRIVATE/;
    $hash-&gt;{ $item };
}

sub hash_hash {
    $_[0];
}

sub hash_size {
    scalar keys %{$_[0]};
}

sub hash_empty {
    return 0 == hash_size($_[0]) ? 1 : 0;
}

sub hash_each {
    # this will be changed in TT3 to do what hash_pairs() does
    [ %{ $_[0] } ];
}

sub hash_keys {
    [ keys   %{ $_[0] } ];
}

sub hash_values {
    [ values %{ $_[0] } ];
}

sub hash_items {
    [ %{ $_[0] } ];
}

sub hash_pairs {
    [ map {
        { key =&gt; $_ , value =&gt; $_[0]-&gt;{ $_ } }
      }
      sort keys %{ $_[0] }
    ];
}

sub hash_list {
    my ($hash, $what) = @_;
    $what ||= '';
    return ($what eq 'keys')   ? [   keys %$hash ]
        :  ($what eq 'values') ? [ values %$hash ]
        :  ($what eq 'each')   ? [        %$hash ]
        :
        [
            # for now we do what pairs does but this will be changed
            # in TT3 to return [ $hash ] by default
            map { { key =&gt; $_ , value =&gt; $hash-&gt;{ $_ } } }
            sort keys %$hash
        ];
}

sub hash_exists {
    exists $_[0]-&gt;{ $_[1] };
}

sub hash_defined {
    # return the item requested, or 1 if no argument
    # to indicate that the hash itself is defined
    my $hash = shift;
    return @_ ? defined $hash-&gt;{ $_[0] } : 1;
}

sub hash_delete {
    my $hash = shift;
    delete $hash-&gt;{ $_ } for @_;
}

sub hash_import {
    my ($hash, $imp) = @_;
    if (ref $imp eq 'HASH') {
        @$hash{ keys %$imp } = values %$imp;
    }
    return '';
}

sub hash_sort {
    my ($hash) = @_;
    [ sort { lc $hash-&gt;{$a} cmp lc $hash-&gt;{$b} } (keys %$hash) ];
}

sub hash_nsort {
    my ($hash) = @_;
    [ sort { $hash-&gt;{$a} &lt;=&gt; $hash-&gt;{$b} } (keys %$hash) ];
}


#========================================================================
# list virtual methods
#========================================================================


sub list_item {
    $_[0]-&gt;[ $_[1] || 0 ];
}

sub list_list {
    $_[0];
}

sub list_hash {
    my $list = shift;
    if (@_) {
        my $n = shift || 0;
        return { map { ($n++, $_) } @$list };
    }
    no warnings;
    return { @$list };
}

sub list_push {
    my $list = shift;
    push(@$list, @_);
    return '';
}

sub list_pop {
    my $list = shift;
    pop(@$list);
}

sub list_unshift {
    my $list = shift;
    unshift(@$list, @_);
    return '';
}

sub list_shift {
    my $list = shift;
    shift(@$list);
}

sub list_max {
    no warnings;
    my $list = shift;
    $#$list;
}

sub list_size {
    no warnings;
    my $list = shift;
    $#$list + 1;
}

sub list_empty {
    return 0 == list_size($_[0]) ? 1 : 0;
}

sub list_defined {
    # return the item requested, or 1 if no argument to
    # indicate that the hash itself is defined
    my $list = shift;
    return 1 unless @_;                     # list.defined is always true
    return unless looks_like_number $_[0];  # list.defined('bah') is always false
    return defined $list-&gt;[$_[0]];          # list.defined(n)
}

sub list_first {
    my $list = shift;
    return $list-&gt;[0] unless @_;
    return [ @$list[0..$_[0]-1] ];
}

sub list_last {
    my $list = shift;
    return $list-&gt;[-1] unless @_;
    return [ @$list[-$_[0]..-1] ];
}

sub list_reverse {
    my $list = shift;
    [ reverse @$list ];
}

sub list_grep {
    my ($list, $pattern) = @_;
    $pattern = '' unless defined $pattern;
    return [ grep /$pattern/, @$list ];
}

sub list_join {
    my ($list, $joint) = @_;
    join($joint // ' ', map { $_ // '' } @$list);
}

sub _list_sort_make_key {
    my ($item, $fields) = @_;
    my @keys;

    if (ref($item) eq 'HASH') {
        @keys = map { $item-&gt;{ $_ } } @$fields;
    }
    elsif (blessed $item) {
        @keys = map { $item-&gt;can($_) ? $item-&gt;$_() : $item } @$fields;
    }
    else {
        @keys = $item;
    }

    # ugly hack to generate a single string using a delimiter that is
    # unlikely (but not impossible) to be found in the wild.
    return lc join('/*^UNLIKELY^*/', map { $_ // '' } @keys);
}

sub list_sort {
    my ($list, @fields) = @_;
    return $list unless @$list &gt; 1;         # no need to sort 1 item lists
    return [
        @fields                          # Schwartzian Transform
        ?   map  { $_-&gt;[0] }                # for case insensitivity
            sort { $a-&gt;[1] cmp $b-&gt;[1] }
            map  { [ $_, _list_sort_make_key($_, \@fields) ] }
            @$list
        :   map  { $_-&gt;[0] }
            sort { $a-&gt;[1] cmp $b-&gt;[1] }
            map  { [ $_, lc $_ ] }
            @$list,
    ];
}

sub list_nsort {
    my ($list, @fields) = @_;
    return $list unless @$list &gt; 1;     # no need to sort 1 item lists

    my $sort = sub {
        my $cmp;

        if(@fields) {
            # compare each field individually
            for my $field (@fields) {
                my $A = _list_sort_make_key($a, [ $field ]);
                my $B = _list_sort_make_key($b, [ $field ]);
                ($cmp = $A &lt;=&gt; $B) and last;
            }
        }
        else {
            my $A = _list_sort_make_key($a);
            my $B = _list_sort_make_key($b);
            $cmp = $A &lt;=&gt; $B;
        }

        $cmp;
    };

    return [ sort $sort @{ $list } ];
}

sub list_unique {
    my %u;
    [ grep { ++$u{$_} == 1 } @{$_[0]} ];
}

sub list_import {
    my $list = shift;
    push(@$list, grep defined, map ref eq 'ARRAY' ? @$_ : undef, @_);
    return $list;
}

sub list_merge {
    my $list = shift;
    return [ @$list, grep defined, map ref eq 'ARRAY' ? @$_ : undef, @_ ];
}

sub list_slice {
    my ($list, $from, $to) = @_;
    $from ||= 0;
    $to   //= $#$list;
    $from += @$list if $from &lt; 0;
    $to   += @$list if $to   &lt; 0;
    return [ @$list[$from..$to] ];
}

sub list_splice {
    my ($list, $offset, $length, @replace) = @_;
    if (@replace) {
        # @replace can contain a list of multiple replace items, or
        # be a single reference to a list
        @replace = @{ $replace[0] }
        if @replace == 1 &amp;&amp; ref $replace[0] eq 'ARRAY';
        return [ splice @$list, $offset, $length, @replace ];
    }
    elsif (defined $length) {
        return [ splice @$list, $offset, $length ];
    }
    elsif (defined $offset) {
        return [ splice @$list, $offset ];
    }
    else {
        return [ splice(@$list) ];
    }
}

1;

__END__

=head1 NAME

Template::VMethods - Virtual methods for variables

=head1 DESCRIPTION

The C&lt;Template::VMethods&gt; module implements the virtual methods
that can be applied to variables.

Please see L&lt;Template::Manual::VMethods&gt; for further information.

=head1 AUTHOR

Andy Wardley E&lt;lt&gt;abw@wardley.orgE&lt;gt&gt; L&lt;http://wardley.org/&gt;

=head1 COPYRIGHT

Copyright (C) 1996-2022 Andy Wardley.  All Rights Reserved.

This module is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

=head1 SEE ALSO

L&lt;Template::Stash&gt;, L&lt;Template::Manual::VMethods&gt;

=cut

# Local Variables:
# mode: perl
# perl-indent-level: 4
# indent-tabs-mode: nil
# End:
#
# vim: expandtab shiftwidth=4:
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Flib64%2Fperl5%2FTemplate'>Back to Directory</a>