This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Update Tie-RefHash to CPAN version 1.40
authorKaren Etheridge <ether@cpan.org>
Sat, 10 Oct 2020 20:41:33 +0000 (13:41 -0700)
committerKaren Etheridge <ether@cpan.org>
Sat, 10 Oct 2020 20:42:24 +0000 (13:42 -0700)
  [DELTA]

1.40      2020-10-10 20:38:32Z
  - switch from "use vars" to "our", raising minimum perl to 5.6
  - tooling improvements

Porting/Maintainers.pl
cpan/Tie-RefHash/lib/Tie/RefHash.pm
cpan/Tie-RefHash/t/rebless.t
cpan/Tie-RefHash/t/refhash.t
cpan/Tie-RefHash/t/threaded.t

index 4129548..33e0ea0 100755 (executable)
@@ -1177,7 +1177,7 @@ use File::Glob qw(:case);
     },
 
     'Tie::RefHash' => {
-        'DISTRIBUTION' => 'FLORA/Tie-RefHash-1.39.tar.gz',
+        'DISTRIBUTION' => 'ETHER/Tie-RefHash-1.40.tar.gz',
         'FILES'        => q[cpan/Tie-RefHash],
     },
 
index ed72abc..896680f 100644 (file)
-package Tie::RefHash;
-
-use vars qw/$VERSION/;
-
-$VERSION = "1.39";
-
-use 5.005;
-
-=head1 NAME
-
-Tie::RefHash - use references as hash keys
-
-=head1 SYNOPSIS
-
-    require 5.004;
-    use Tie::RefHash;
-    tie HASHVARIABLE, 'Tie::RefHash', LIST;
-    tie HASHVARIABLE, 'Tie::RefHash::Nestable', LIST;
-
-    untie HASHVARIABLE;
-
-=head1 DESCRIPTION
-
-This module provides the ability to use references as hash keys if you
-first C<tie> the hash variable to this module.  Normally, only the
-keys of the tied hash itself are preserved as references; to use
-references as keys in hashes-of-hashes, use Tie::RefHash::Nestable,
-included as part of Tie::RefHash.
-
-It is implemented using the standard perl TIEHASH interface.  Please
-see the C<tie> entry in perlfunc(1) and perltie(1) for more information.
-
-The Nestable version works by looking for hash references being stored
-and converting them to tied hashes so that they too can have
-references as keys.  This will happen without warning whenever you
-store a reference to one of your own hashes in the tied hash.
-
-=head1 EXAMPLE
-
-    use Tie::RefHash;
-    tie %h, 'Tie::RefHash';
-    $a = [];
-    $b = {};
-    $c = \*main;
-    $d = \"gunk";
-    $e = sub { 'foo' };
-    %h = ($a => 1, $b => 2, $c => 3, $d => 4, $e => 5);
-    $a->[0] = 'foo';
-    $b->{foo} = 'bar';
-    for (keys %h) {
-       print ref($_), "\n";
-    }
-
-    tie %h, 'Tie::RefHash::Nestable';
-    $h{$a}->{$b} = 1;
-    for (keys %h, keys %{$h{$a}}) {
-       print ref($_), "\n";
-    }
-
-=head1 THREAD SUPPORT
-
-L<Tie::RefHash> fully supports threading using the C<CLONE> method.
-
-=head1 STORABLE SUPPORT
-
-L<Storable> hooks are provided for semantically correct serialization and
-cloning of tied refhashes.
-
-=head1 RELIC SUPPORT
-
-This version of Tie::RefHash seems to no longer work with 5.004. This has not
-been throughly investigated. Patches welcome ;-)
-
-=head1 LICENSE
-
-This program is free software; you can redistribute it and/or modify it under
-the same terms as Perl itself
-
-=head1 MAINTAINER
-
-Yuval Kogman E<lt>nothingmuch@woobling.orgE<gt>
-
-=head1 AUTHOR
-
-Gurusamy Sarathy        gsar@activestate.com
-
-'Nestable' by Ed Avis   ed@membled.com
-
-=head1 SEE ALSO
-
-perl(1), perlfunc(1), perltie(1)
-
-=cut
+package Tie::RefHash; # git description: Tie-RefHash-1.39-10-g2cfa4bd
+# ABSTRACT: Use references as hash keys
+
+our $VERSION = '1.40';
+
+#pod =head1 SYNOPSIS
+#pod
+#pod     require 5.004;
+#pod     use Tie::RefHash;
+#pod     tie HASHVARIABLE, 'Tie::RefHash', LIST;
+#pod     tie HASHVARIABLE, 'Tie::RefHash::Nestable', LIST;
+#pod
+#pod     untie HASHVARIABLE;
+#pod
+#pod =head1 DESCRIPTION
+#pod
+#pod This module provides the ability to use references as hash keys if you
+#pod first C<tie> the hash variable to this module.  Normally, only the
+#pod keys of the tied hash itself are preserved as references; to use
+#pod references as keys in hashes-of-hashes, use Tie::RefHash::Nestable,
+#pod included as part of Tie::RefHash.
+#pod
+#pod It is implemented using the standard perl TIEHASH interface.  Please
+#pod see the C<tie> entry in perlfunc(1) and perltie(1) for more information.
+#pod
+#pod The Nestable version works by looking for hash references being stored
+#pod and converting them to tied hashes so that they too can have
+#pod references as keys.  This will happen without warning whenever you
+#pod store a reference to one of your own hashes in the tied hash.
+#pod
+#pod =head1 EXAMPLE
+#pod
+#pod     use Tie::RefHash;
+#pod     tie %h, 'Tie::RefHash';
+#pod     $a = [];
+#pod     $b = {};
+#pod     $c = \*main;
+#pod     $d = \"gunk";
+#pod     $e = sub { 'foo' };
+#pod     %h = ($a => 1, $b => 2, $c => 3, $d => 4, $e => 5);
+#pod     $a->[0] = 'foo';
+#pod     $b->{foo} = 'bar';
+#pod     for (keys %h) {
+#pod        print ref($_), "\n";
+#pod     }
+#pod
+#pod     tie %h, 'Tie::RefHash::Nestable';
+#pod     $h{$a}->{$b} = 1;
+#pod     for (keys %h, keys %{$h{$a}}) {
+#pod        print ref($_), "\n";
+#pod     }
+#pod
+#pod =head1 THREAD SUPPORT
+#pod
+#pod L<Tie::RefHash> fully supports threading using the C<CLONE> method.
+#pod
+#pod =head1 STORABLE SUPPORT
+#pod
+#pod L<Storable> hooks are provided for semantically correct serialization and
+#pod cloning of tied refhashes.
+#pod
+#pod =head1 AUTHORS
+#pod
+#pod Gurusamy Sarathy <gsar@activestate.com>
+#pod
+#pod Tie::RefHash::Nestable by Ed Avis <ed@membled.com>
+#pod
+#pod =head1 SEE ALSO
+#pod
+#pod perl(1), perlfunc(1), perltie(1)
+#pod
+#pod =cut
 
 use Tie::Hash;
-use vars '@ISA';
-@ISA = qw(Tie::Hash);
+our @ISA = qw(Tie::Hash);
 use strict;
-use Carp qw/croak/;
+use Carp ();
 
 BEGIN {
   local $@;
@@ -114,7 +92,7 @@ BEGIN {
   local $@;
 
   if ( _HAS_SCALAR_UTIL ) {
-    Scalar::Util->import("refaddr");
+    *refaddr = sub { goto \&Scalar::Util::refaddr }
   } else {
     require overload;
 
@@ -148,7 +126,7 @@ sub TIEHASH {
 
       if ( ++$count > 1000 ) {
         # this ensures we don't fill up with a huge array dead weakrefs
-        @thread_object_registry = grep { defined } @thread_object_registry;
+        @thread_object_registry = grep defined, @thread_object_registry;
         $count = 0;
       }
     } else {
@@ -169,7 +147,7 @@ sub STORABLE_freeze {
 
 sub STORABLE_thaw {
   my ( $self, $is_cloning, $version, $refs, $reg ) = @_;
-  croak "incompatible versions of Tie::RefHash between freeze and thaw"
+  Carp::croak "incompatible versions of Tie::RefHash between freeze and thaw"
     unless $version eq $storable_format_version;
 
   @$self = ( {}, $reg );
@@ -185,20 +163,20 @@ sub CLONE {
 
   # when the thread has been cloned all the objects need to be updated.
   # dead weakrefs are undefined, so we filter them out
-  @thread_object_registry = grep { defined && do { $_->_reindex_keys; 1 } } @thread_object_registry;
+  @thread_object_registry = grep defined && do { $_->_reindex_keys; 1 }, @thread_object_registry;
   $count = 0; # we just cleaned up
 }
 
 sub _reindex_keys {
   my ( $self, $extra_keys ) = @_;
   # rehash all the ref keys based on their new StrVal
-  %{ $self->[0] } = map { refaddr($_->[0]) => $_ } (values(%{ $self->[0] }), @{ $extra_keys || [] });
+  %{ $self->[0] } = map +(Scalar::Util::refaddr($_->[0]) => $_), (values(%{ $self->[0] }), @{ $extra_keys || [] });
 }
 
 sub FETCH {
   my($s, $k) = @_;
   if (ref $k) {
-      my $kstr = refaddr($k);
+      my $kstr = Scalar::Util::refaddr($k);
       if (defined $s->[0]{$kstr}) {
         $s->[0]{$kstr}[1];
       }
@@ -214,7 +192,7 @@ sub FETCH {
 sub STORE {
   my($s, $k, $v) = @_;
   if (ref $k) {
-    $s->[0]{refaddr($k)} = [$k, $v];
+    $s->[0]{Scalar::Util::refaddr($k)} = [$k, $v];
   }
   else {
     $s->[1]{$k} = $v;
@@ -225,13 +203,13 @@ sub STORE {
 sub DELETE {
   my($s, $k) = @_;
   (ref $k)
-    ? (delete($s->[0]{refaddr($k)}) || [])->[1]
+    ? (delete($s->[0]{Scalar::Util::refaddr($k)}) || [])->[1]
     : delete($s->[1]{$k});
 }
 
 sub EXISTS {
   my($s, $k) = @_;
-  (ref $k) ? exists($s->[0]{refaddr($k)}) : exists($s->[1]{$k});
+  (ref $k) ? exists($s->[0]{Scalar::Util::refaddr($k)}) : exists($s->[1]{$k});
 }
 
 sub FIRSTKEY {
@@ -263,9 +241,9 @@ sub CLEAR {
   %{$s->[1]} = ();
 }
 
-package Tie::RefHash::Nestable;
-use vars '@ISA';
-@ISA = 'Tie::RefHash';
+package # hide from PAUSE
+  Tie::RefHash::Nestable;
+our @ISA = 'Tie::RefHash';
 
 sub STORE {
   my($s, $k, $v) = @_;
@@ -277,3 +255,121 @@ sub STORE {
 }
 
 1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Tie::RefHash - Use references as hash keys
+
+=head1 VERSION
+
+version 1.40
+
+=head1 SYNOPSIS
+
+    require 5.004;
+    use Tie::RefHash;
+    tie HASHVARIABLE, 'Tie::RefHash', LIST;
+    tie HASHVARIABLE, 'Tie::RefHash::Nestable', LIST;
+
+    untie HASHVARIABLE;
+
+=head1 DESCRIPTION
+
+This module provides the ability to use references as hash keys if you
+first C<tie> the hash variable to this module.  Normally, only the
+keys of the tied hash itself are preserved as references; to use
+references as keys in hashes-of-hashes, use Tie::RefHash::Nestable,
+included as part of Tie::RefHash.
+
+It is implemented using the standard perl TIEHASH interface.  Please
+see the C<tie> entry in perlfunc(1) and perltie(1) for more information.
+
+The Nestable version works by looking for hash references being stored
+and converting them to tied hashes so that they too can have
+references as keys.  This will happen without warning whenever you
+store a reference to one of your own hashes in the tied hash.
+
+=head1 EXAMPLE
+
+    use Tie::RefHash;
+    tie %h, 'Tie::RefHash';
+    $a = [];
+    $b = {};
+    $c = \*main;
+    $d = \"gunk";
+    $e = sub { 'foo' };
+    %h = ($a => 1, $b => 2, $c => 3, $d => 4, $e => 5);
+    $a->[0] = 'foo';
+    $b->{foo} = 'bar';
+    for (keys %h) {
+       print ref($_), "\n";
+    }
+
+    tie %h, 'Tie::RefHash::Nestable';
+    $h{$a}->{$b} = 1;
+    for (keys %h, keys %{$h{$a}}) {
+       print ref($_), "\n";
+    }
+
+=head1 THREAD SUPPORT
+
+L<Tie::RefHash> fully supports threading using the C<CLONE> method.
+
+=head1 STORABLE SUPPORT
+
+L<Storable> hooks are provided for semantically correct serialization and
+cloning of tied refhashes.
+
+=head1 SEE ALSO
+
+perl(1), perlfunc(1), perltie(1)
+
+=head1 SUPPORT
+
+Bugs may be submitted through L<the RT bug tracker|https://rt.cpan.org/Public/Dist/Display.html?Name=Tie-RefHash>
+(or L<bug-Tie-RefHash@rt.cpan.org|mailto:bug-Tie-RefHash@rt.cpan.org>).
+
+=head1 AUTHORS
+
+Gurusamy Sarathy <gsar@activestate.com>
+
+Tie::RefHash::Nestable by Ed Avis <ed@membled.com>
+
+=head1 CONTRIBUTORS
+
+=for stopwords Yuval Kogman Karen Etheridge Florian Ragwitz Jerry D. Hedden
+
+=over 4
+
+=item *
+
+Yuval Kogman <nothingmuch@woobling.org>
+
+=item *
+
+Karen Etheridge <ether@cpan.org>
+
+=item *
+
+Florian Ragwitz <rafl@debian.org>
+
+=item *
+
+Jerry D. Hedden <jdhedden@cpan.org>
+
+=back
+
+=head1 COPYRIGHT AND LICENCE
+
+This software is copyright (c) 2006 by יובל קוג'מן (Yuval Kogman) <nothingmuch@woobling.org>.
+
+This is free software; you can redistribute it and/or modify it under
+the same terms as the Perl 5 programming language system itself.
+
+=cut
index 4ae40f4..ec262a5 100644 (file)
@@ -16,8 +16,7 @@ use Tie::RefHash;
   sub new { bless { }, shift };
 
   package Elk;
-  use vars qw/@ISA/;
-  @ISA = "Moose";
+  our @ISA = "Moose";
 }
 
 $\ = "\n";
index d19f7d3..20ac870 100644 (file)
@@ -288,8 +288,8 @@ END
 
     # Test storing and removing under ordinary keys
     my @things = ('boink', 0, 1, '', undef);
-    foreach my $key (map { dumped($_) } @things) {
-        foreach my $value ((map { dumped($_) } @things), '$ref') {
+    foreach my $key (map dumped($_), @things) {
+        foreach my $value ((map dumped($_), @things), '$ref') {
             push @r, split /\n/, <<"END"
             \$h{$key} = $value;
             $STD_TESTS;
index 8767f97..30dfcf7 100644 (file)
@@ -20,12 +20,11 @@ BEGIN {
     exit 0;
   }
   if ( $Config{usethreads} and !$Config{use5005threads}
-      and defined(&Scalar::Util::weaken)
-      and eval { require threads; threads->import; 1 }
+      and eval { +require threads; threads->import; 1 }
   ) {
     print "1..14\n";
   } else {
-    print "1..0 # Skip -- threads aren't enabled in your perl, or Scalar::Util::weaken is missing\n";
+    print "1..0 # Skip -- threads aren't enabled in your perl";
     exit 0;
   }
 }