Index: /lang/perl/Data-Decycle/trunk/t/scratch.pl =================================================================== --- /lang/perl/Data-Decycle/trunk/t/scratch.pl (revision 38338) +++ /lang/perl/Data-Decycle/trunk/t/scratch.pl (revision 38338) @@ -0,0 +1,52 @@ +# +# $Id$ +# +use strict; +use warnings; +use Scalar::Util qw/isweak/; +use Data::Decycle; + +local $Data::Decycle::DEBUG = 2; + +{ + package Dummy; + sub DESTROY { + warn "($_[0]) is being DESTROY()ed"; + } +} + +{ + my $guard = Data::Decycle->new; + add $guard my $cyclic_sref = bless \my $dummy, 'Dummy'; + $cyclic_sref = \$cyclic_sref; + add $guard my $cyclic_aref = bless [], 'Dummy'; + $cyclic_aref->[0] = $cyclic_aref; + add $guard my $cyclic_href = bless {}, 'Dummy'; + $cyclic_href->{cyclic} = $cyclic_href; +} + +{ + my $guard = Data::Decycle->new( + my $cyclic_sref = ( bless \my $dummy, 'Dummy' ), + my $cyclic_aref = ( bless [], 'Dummy' ), + my $cyclic_href = ( bless {}, 'Dummy' ) + ); + $cyclic_sref = \$cyclic_sref; + $cyclic_aref->[0] = $cyclic_aref; + $cyclic_href->{cyclic} = $cyclic_href; +} + +__END__ +{ + my $guard = Data::Decycle->new; + $guard->add(my $cyclic_sref = bless \my $dummy, 'Dummy'); + $cyclic_sref = \$cyclic_sref; + $guard->add(my $cyclic_aref = bless [], 'Dummy'); + $cyclic_aref->[0] = $cyclic_aref; + $guard->add(my $cyclic_href = bless {}, 'Dummy'); + $cyclic_href->{cyclic} = $cyclic_href; +} + + + +__END__ Index: /lang/perl/Data-Decycle/trunk/t/pod.t =================================================================== --- /lang/perl/Data-Decycle/trunk/t/pod.t (revision 38338) +++ /lang/perl/Data-Decycle/trunk/t/pod.t (revision 38338) @@ -0,0 +1,12 @@ +#!perl -T + +use strict; +use warnings; +use Test::More; + +# Ensure a recent version of Test::Pod +my $min_tp = 1.22; +eval "use Test::Pod $min_tp"; +plan skip_all => "Test::Pod $min_tp required for testing POD" if $@; + +all_pod_files_ok(); Index: /lang/perl/Data-Decycle/trunk/t/04-may_leak.t =================================================================== --- /lang/perl/Data-Decycle/trunk/t/04-may_leak.t (revision 38338) +++ /lang/perl/Data-Decycle/trunk/t/04-may_leak.t (revision 38338) @@ -0,0 +1,45 @@ +# +# $Id$ +# +use strict; +use warnings; +use Test::More; +use Data::Decycle qw/may_leak weaken_deeply recsub $CALLEE/; + +plan tests => 13; + +my $sref = 'scalar'; +ok !may_leak($sref), "'$sref' may not leak"; +$sref = \$sref; +ok may_leak($sref), "'$sref' is leak"; +weaken_deeply($sref); +ok !may_leak($sref), "'$sref' may not leak"; + +my $aref = [0]; +ok !may_leak($aref), "'$aref' may not leak"; +$aref->[1] = $aref; +weaken_deeply($aref); +ok !may_leak($aref), "'$aref' may not leak"; + +my $href = {foo => 0}; +ok !may_leak($href), "'$href' may not leak"; +$href->{cycle} = $href; +ok may_leak($href), "'$href' may leak"; +weaken_deeply($href); +ok !may_leak($href), "'$href' may not leak"; + +SKIP:{ + skip 'PadWalker not installed', 5 unless Data::Decycle::HAS_PADWALKER; + my $cref; + $cref = sub{ $_[0] <= 1 ? 1 : $_[0] * $cref->($_[0] - 1) }; + ok may_leak($cref), "'$cref' may leak"; + weaken_deeply($cref); + ok may_leak($cref), "'$cref' may STILL leak"; + is $cref->(10), 3628800, "($cref)->(10) is 3628800"; + + $cref = sub{ shift }; + ok !may_leak($cref), "'$cref' may not leak"; + $cref = recsub { $_[0] <= 1 ? 1 : $_[0] * $CALLEE->($_[0]-1) }; + ok !may_leak($cref), "'$cref' may not leak"; +} + Index: /lang/perl/Data-Decycle/trunk/t/manifest.t =================================================================== --- /lang/perl/Data-Decycle/trunk/t/manifest.t (revision 38338) +++ /lang/perl/Data-Decycle/trunk/t/manifest.t (revision 38338) @@ -0,0 +1,13 @@ +#!perl -T + +use strict; +use warnings; +use Test::More; + +unless ( $ENV{RELEASE_TESTING} ) { + plan( skip_all => "Author tests not required for installation" ); +} + +eval "use Test::CheckManifest 0.9"; +plan skip_all => "Test::CheckManifest 0.9 required" if $@; +ok_manifest(); Index: /lang/perl/Data-Decycle/trunk/t/02-decycle_deeply.t =================================================================== --- /lang/perl/Data-Decycle/trunk/t/02-decycle_deeply.t (revision 38338) +++ /lang/perl/Data-Decycle/trunk/t/02-decycle_deeply.t (revision 38338) @@ -0,0 +1,50 @@ +# +# $Id$ +# +use strict; +use warnings; +use Test::More; +use Data::Decycle qw/has_cyclic_ref decycle_deeply recsub $CALLEE/; + +plan tests => 14; + +my $sref = 'scalar'; +ok !has_cyclic_ref($sref), "'$sref' isn't cyclic"; +$sref = \$sref; +ok has_cyclic_ref($sref), "'$sref' is cyclic"; +{ + no warnings 'uninitialized'; + decycle_deeply($sref); + ok !has_cyclic_ref($sref), "'$sref' isn't cyclic"; +} + +my $aref = [0]; +ok !has_cyclic_ref($aref), "'$aref' isn't cyclic"; +$aref->[1] = $aref; +ok has_cyclic_ref($aref), "'$aref' is cyclic"; +decycle_deeply($aref); +ok !has_cyclic_ref($aref), "'$aref' isn't cyclic"; + +my $href = {foo => 0}; +ok !has_cyclic_ref($href), "'$href' isn't cyclic"; +$href->{cycle} = $href; +ok has_cyclic_ref($href), "'$href' is cyclic"; +decycle_deeply($href); +ok !has_cyclic_ref($sref), "'$href' isn't cyclic"; + +SKIP:{ + skip 'PadWalker not installed', 5 unless Data::Decycle::HAS_PADWALKER; + my $cref; + $cref = sub{ $_[0] <= 1 ? 1 : $_[0] * $cref->($_[0] - 1) }; + ok has_cyclic_ref($cref), "'$cref' is cyclic"; + is $cref->(10), 3628800, "($cref)->(10) is 3628800"; + { + no warnings 'uninitialized'; + decycle_deeply($cref); + ok !has_cyclic_ref($cref), "'$sref' isn't cyclic"; + } + $cref = sub{ shift }; + ok !has_cyclic_ref($cref), "'$cref' isn't cyclic"; + $cref = recsub { $_[0] <= 1 ? 1 : $_[0] * $CALLEE->($_[0]-1) }; + ok !has_cyclic_ref($cref), "'$cref' isn't cyclic"; +} Index: /lang/perl/Data-Decycle/trunk/t/01-has_scalar_ref.t =================================================================== --- /lang/perl/Data-Decycle/trunk/t/01-has_scalar_ref.t (revision 38338) +++ /lang/perl/Data-Decycle/trunk/t/01-has_scalar_ref.t (revision 38338) @@ -0,0 +1,42 @@ +# +# $Id$ +# +use strict; +use warnings; +use Test::More; +use Data::Decycle qw/has_cyclic_ref recsub $CALLEE/; + +plan tests => 11; + +my $sref = 'scalar'; +ok !has_cyclic_ref($sref), "'$sref' isn't cyclic"; +$sref = \$sref; +ok has_cyclic_ref($sref), "'$sref' is cyclic"; + +my $aref = [0]; +ok !has_cyclic_ref($aref), "'$aref' isn't cyclic"; +$aref->[1] = $aref; +ok has_cyclic_ref($aref), "'$aref' is cyclic"; + +my $href = {foo => 0}; +ok !has_cyclic_ref($href), "'$href' isn't cyclic"; +$href->{cycle} = $href; +ok has_cyclic_ref($href), "'$href' is cyclic"; + +bless $aref, 'Dummy'; +ok has_cyclic_ref($aref), "'$aref' is cyclic"; + +bless $href, 'Dummy'; +ok has_cyclic_ref($href), "'$href' is cyclic"; + +SKIP:{ + skip 'PadWalker not installed', 3 unless Data::Decycle::HAS_PADWALKER; + my $cref; + $cref = sub{ $_[0] <= 1 ? 1 : $_[0] * $cref->($_[0] - 1) }; + ok has_cyclic_ref($cref), "'$cref' is cyclic"; + $cref = sub{ shift }; + ok !has_cyclic_ref($cref), "'$cref' isn't cyclic"; + $cref = recsub { $_[0] <= 1 ? 1 : $_[0] * $CALLEE->($_[0]-1) }; + ok !has_cyclic_ref($cref), "'$cref' isn't cyclic"; +} + Index: /lang/perl/Data-Decycle/trunk/t/pod-coverage.t =================================================================== --- /lang/perl/Data-Decycle/trunk/t/pod-coverage.t (revision 38338) +++ /lang/perl/Data-Decycle/trunk/t/pod-coverage.t (revision 38338) @@ -0,0 +1,18 @@ +use strict; +use warnings; +use Test::More; + +# Ensure a recent version of Test::Pod::Coverage +my $min_tpc = 1.08; +eval "use Test::Pod::Coverage $min_tpc"; +plan skip_all => "Test::Pod::Coverage $min_tpc required for testing POD coverage" + if $@; + +# Test::Pod::Coverage doesn't require a minimum Pod::Coverage version, +# but older versions don't recognize some common documentation styles +my $min_pc = 0.18; +eval "use Pod::Coverage $min_pc"; +plan skip_all => "Pod::Coverage $min_pc required for testing POD coverage" + if $@; + +all_pod_coverage_ok(); Index: /lang/perl/Data-Decycle/trunk/t/00-load.t =================================================================== --- /lang/perl/Data-Decycle/trunk/t/00-load.t (revision 38338) +++ /lang/perl/Data-Decycle/trunk/t/00-load.t (revision 38338) @@ -0,0 +1,10 @@ +#!perl -T + +use Test::More tests => 1; + +BEGIN { + use_ok( 'Data::Decycle' ) || print "Bail out! +"; +} + +diag( "Testing Data::Decycle $Data::Decycle::VERSION, Perl $], $^X" ); Index: /lang/perl/Data-Decycle/trunk/t/03-weaken_deeply.t =================================================================== --- /lang/perl/Data-Decycle/trunk/t/03-weaken_deeply.t (revision 38338) +++ /lang/perl/Data-Decycle/trunk/t/03-weaken_deeply.t (revision 38338) @@ -0,0 +1,33 @@ +# +# $Id$ +# +use strict; +use warnings; +use Test::More; +use Scalar::Util qw/isweak/; +use Data::Decycle qw/weaken_deeply/; + +plan tests => 6; + +{ + my $sref; + $sref = \$sref; + bless $sref, 'Dummy'; + ok !isweak($sref), "$sref is not a weak reference"; + weaken_deeply($sref); + ok isweak($sref), "$sref is a weak reference now"; +} +{ + my $aref = bless [], 'Dummy'; + $aref->[0] = $aref; + ok !isweak($aref->[0]), "($aref)->[0] is not a weak reference"; + weaken_deeply($aref); + ok isweak($aref->[0]), "($aref)->[0] is a weak reference now"; +} +{ + my $href = bless {}, 'Dummy'; + $href->{cyclic} = $href; + ok !isweak($href->{cyclic}), "($href)->{cyclic} is not a weak reference"; + weaken_deeply($href); + ok isweak($href->{cyclic}), "($href)->{cyclic} is a weak reference now"; +} Index: /lang/perl/Data-Decycle/trunk/MANIFEST =================================================================== --- /lang/perl/Data-Decycle/trunk/MANIFEST (revision 38338) +++ /lang/perl/Data-Decycle/trunk/MANIFEST (revision 38338) @@ -0,0 +1,13 @@ +Changes +lib/Data/Decycle.pm +MANIFEST This list of files +MANIFEST.skip +README +t/00-load.t +t/01-has_scalar_ref.t +t/02-decycle_deeply.t +t/03-weaken_deeply.t +t/04-may_leak.t +t/manifest.t +t/pod-coverage.t +t/pod.t Index: /lang/perl/Data-Decycle/trunk/lib/Data/Decycle.pm =================================================================== --- /lang/perl/Data-Decycle/trunk/lib/Data/Decycle.pm (revision 38338) +++ /lang/perl/Data-Decycle/trunk/lib/Data/Decycle.pm (revision 38338) @@ -0,0 +1,385 @@ +# +# $Id$ +# +package Data::Decycle; +use 5.00801; +use warnings; +use strict; +use Carp; +use Scalar::Util qw/refaddr weaken isweak/; + +our $VERSION = sprintf "%d.%02d", q$Revision: 0.1 $ =~ /(\d+)/g; +our $DEBUG = 0; + +use base 'Exporter'; +our @EXPORT = (); +our @EXPORT_OK = qw(recsub $CALLEE + may_leak has_cyclic_ref decycle_deeply weaken_deeply +); +our %EXPORT_TAGS = ( all => [ @EXPORT, @EXPORT_OK ], ); + +BEGIN { + require constant; + constant->import( + HAS_PADWALKER => eval { + require PadWalker; + $PadWalker::VERSION >= 1.0; + } + ); +} + +sub new { + my $class = shift; + my $self = bless [], $class; + $self->add(@_); +} + +sub add { + my $self = shift; + for (@_){ + croak "$_ is not a reference" unless ref $_; + push @{$self}, $_; + } + $self; +} + +sub DESTROY { + my $self = shift; + if ($DEBUG > 1){ + require Data::Dumper and Data::Dumper->import; + print Dumper($self); + } + for (@{$self}){ + next unless ref $_; + carp "decyling ($_)" if $DEBUG; + decycle_deeply($_); + } +} + +our $CALLEE; + +sub recsub(&) { + my $code = shift; + sub { + local *CALLEE = \$code; + $code->(@_); + } +} + +sub _mkfinder(&) { + my $cb = shift; + return recsub { + return unless ref $_[0]; + no warnings 'uninitialized'; + return $cb->( $_[0] ) if $_[1]->{ refaddr $_[0] }++; + if ( UNIVERSAL::isa( $_[0], 'HASH' ) ) { + for ( values %{ $_[0] } ) { + next unless ref $_; + return 1 if $CALLEE->( $_, $_[1] ); + } + } + elsif ( UNIVERSAL::isa( $_[0], 'ARRAY' ) ) { + for ( @{ $_[0] } ) { + next unless ref $_; + return 1 if $CALLEE->( $_, $_[1] ); + } + } + elsif (UNIVERSAL::isa( $_[0], 'SCALAR' ) + || UNIVERSAL::isa( $_[0], 'REF' ) ) + { + return $CALLEE->( ${ $_[0] }, $_[1] ); + } + elsif ( HAS_PADWALKER && UNIVERSAL::isa( $_[0], 'CODE' ) ) { + my $r = PadWalker::closed_over( $_[0] ); + return unless keys %$r; + $CALLEE->( $r, $_[1] ) && return 1; + } + return; + } +} + +*_has_cyclic_ref = _mkfinder { 1 }; +sub has_cyclic_ref($){ _has_cyclic_ref($_[0], {}) } + +*_may_leak = _mkfinder { !isweak($_[0]) }; +sub may_leak($){ _may_leak($_[0], {}) } + +sub _mkwalker(&){ + my $cb = shift; + return recsub { + return unless ref $_[0]; + no warnings 'uninitialized'; + return $cb->( $_[0] ) if $_[1]->{ refaddr $_[0] }++; + if ( UNIVERSAL::isa( $_[0], 'HASH' ) ) { + $CALLEE->( $_, $_[1] ) for values %{ $_[0] }; + } + elsif ( UNIVERSAL::isa( $_[0], 'ARRAY' ) ) { + $CALLEE->( $_, $_[1] ) for @{ $_[0] }; + } + elsif (UNIVERSAL::isa( $_[0], 'SCALAR' ) + || UNIVERSAL::isa( $_[0], 'REF' ) ) + { + $CALLEE->( ${ $_[0] }, $_[1] ); + } + elsif ( HAS_PADWALKER && UNIVERSAL::isa( $_[0], 'CODE' ) ) { + my $r = PadWalker::closed_over( $_[0] ); + return unless keys %$r; + $CALLEE->( $r, $_[1] ); + } + return; + }; +} + +*_decycle_deeply = _mkwalker { undef $_[0] }; +sub decycle_deeply($) { _decycle_deeply( $_[0], {} ) } + +*_weaken_deeply = _mkwalker { + weaken $_[0] unless UNIVERSAL::isa( $_[0], 'CODE' ) +}; +sub weaken_deeply($) { _weaken_deeply( $_[0], {} ) } + +1; # End of Data::Decycle + +__END__ +=head1 NAME + +Data::Decycle - (Cyclic|Circular) reference decycler + +=head1 VERSION + +$Id$ + +=head1 SYNOPSIS + + use Data::Decycle; + + # none of them leak + { + my $guard = Data::Decycle->new; + add $guard my $cyclic_sref = \my $dummy; + $cyclic_sref = \$cyclic_sref; + add $guard my $cyclic_aref = []; + $cyclic_aref->[0] = $cyclic_aref; + add $guard my $cyclic_href = {}; + $cyclic_href->{cyclic} = $cyclic_href; + } + + # or register all at once + { + my $guard = Data::Decycle->new( + my $cyclic_sref = \my $dummy, + my $cyclic_aref = [], + my $cyclic_href = {} + ); + $cyclic_sref = \$cyclic_sref; + $cyclic_aref->[0] = $cyclic_aref; + $cyclic_href->{cyclic} = $cyclic_href; + } + + # if you have PadWalker, you can decycle closures, too. + { + my $guard = Data::Decycle->new; + my $cref; + $cref = sub{ $_[0] <= 1 ? 1 : $_[0] * $cref->($_[0] - 1) }; + $guard->add($cref); + print $cref->(10); + } + + # you can also cope with circular references explicitly + use Data::Decycle ':all'; + my $obj = bless {}, 'Dummy'; + $obj->{me} = $obj; + print may_leak($obj); # true + weaken_deeply($obj); + print may_leak($obj); # false + print has_cyclic_ref($obj); # true + decycle_deeply($obj); + print $obj->{me} == undef; # true + +=head1 DESCRIPTION + +Perl programmers love to hate cyclic References, or circular +references. It easly leaks out of perl's reference-counter based +garbage collection and stays there until perl exits. + +Even with the introduction of weak references in Perl 5.8, you still +have to tell perl explicitly to weaken references and which reference +to weaken is tricky. + + use Devel::Peek; + use Scalar::Util qw/weaken/; + my $obj = {you => $ENV{USER}}; + $obj->{me} = $obj; + + weaken($obj); # wrong + weaken($obj->{me}) # right; + +In addition to that, weak references do not work with code references. + + my $cref; + $cref = sub { $_[0] <= 1 ? 1 : $_[0] * $cref->( $_[0] - 1 ) }; + print $cref->(10); + weaken($cref); # does undef($cref) + print $cref->(10); # goodbye + +This module offers something easier than that. + +=head2 HOW DOES IT WORK? + +See the source :-p + +Okay, I'll be nicer. Consider the code below again. + + { + my $guard = Data::Decycle->new( + my $cyclic_sref = \my $dummy, + my $cyclic_aref = [], + my $cyclic_href = {} + ); + $cyclic_sref = \$cyclic_sref; + $cyclic_aref->[0] = $cyclic_aref; + $cyclic_href->{cyclic} = $cyclic_href; + } + +What happens when it reaches out of the block? $guard will surely be +DESTROY()'ed. So it is guaranteed to trigger $guard->DESTROY. And in +there it applys C to each reference registered. + +Simple, huh? + +=head1 DEPENDENCY + +None except for core modules. + +To handle code references correctly, you need to have L installed. + +=head1 EXPORT + +None by default. Please import explicitly. + +=head1 METHODS + +=over 4 + +=item new + +=item add + +see L + +=back + +=head1 SUBROUTINES + +=head2 may_leak($obj) + +checks if C<$obj> may leak. That is, contains a circular reference +that is not weak. + +=head2 has_cyclic_ref($obj) + +checks if cyclic reference exists in C<$obj>. + +=head2 decycle_deeply($obj) + +Cs all duplicate references in C<$obj> thus breaks all cyclic +reference. Unlike C, it decycles even code +references. You shouldn't call it yourself; let C take care +of it. + +=head2 weaken_deeply($obj) + +weaken all duplicate references in C<$obj>. Unlike C +it leaves code references intact. So you can safely call it but you +are at your own if C<$obj> contains a code reference that cycles. + +=head2 recsub { } + +Consider the code below: + + my $fact; + $fact = sub { $_[0] <= 1 ? 1 : $_[0] * $fact->($_[0]-1) }; + +This leaks since $fact is now a cyclic reference. +with the combination of C and C<$CALLEE>, you can rewrite the code as: + + my $fact = recsub { $_[0] <= 1 ? 1 : $_[0] * $CALLEE->($_[0]-1) }; + +To use this feature, you should import both C and C<$CALLEE> as: + + use Data::Decycle qw(recsub $CALLEE); + +or import just C and define your own C<$CALLEE>: + + use Data::Decycle qw(recsub); + our $CALLEE; + +Unlike the previous example, this one dow not leak. See +L for more complicated examples such as mutually +recursive subrefs. + +=head1 AUTHOR + +Dan Kogai, C<< >> + +=head1 BUGS + +Please report any bugs or feature requests to C, or through +the web interface at L. I will be notified, and then you'll +automatically be notified of progress on your bug as I make changes. + +=head1 SUPPORT + +You can find documentation for this module with the perldoc command. + + perldoc Data::Decycle + +You can also look for information at: + +=over 4 + +=item * RT: CPAN's request tracker + +L + +=item * AnnoCPAN: Annotated CPAN documentation + +L + +=item * CPAN Ratings + +L + +=item * Search CPAN + +L + +=back + +=head1 ACKNOWLEDGEMENTS + +=over 4 + +=item L + +You need this if you want to handle code references properly. When +you don't have one this module simply does nothing when it encounters +them. + +=item L + +Good for inspection -- rather overkill. Decycling features missing. + +=back + +=head1 LICENSE AND COPYRIGHT + +Copyright 2010 Dan Kogai. + +This program is free software; you can redistribute it and/or modify it +under the terms of either: the GNU General Public License as published +by the Free Software Foundation; or the Artistic License. + +See http://dev.perl.org/licenses/ for more information. + +=cut Index: /lang/perl/Data-Decycle/trunk/Makefile.PL =================================================================== --- /lang/perl/Data-Decycle/trunk/Makefile.PL (revision 38338) +++ /lang/perl/Data-Decycle/trunk/Makefile.PL (revision 38338) @@ -0,0 +1,24 @@ +# +# $Id$ +# +use 5.00801; +use strict; +use warnings; +use ExtUtils::MakeMaker; + +WriteMakefile( + NAME => 'Data::Decycle', + AUTHOR => q{Dan Kogai }, + VERSION_FROM => 'lib/Data/Decycle.pm', + ABSTRACT_FROM => 'lib/Data/Decycle.pm', + ($ExtUtils::MakeMaker::VERSION >= 6.3002 + ? ('LICENSE'=> 'perl') + : ()), + PL_FILES => {}, + PREREQ_PM => { + 'Test::More' => 0, + # 'PadWalker' => 0, + }, + dist => { COMPRESS => 'gzip -9f', SUFFIX => 'gz', }, + clean => { FILES => 'Data-Decycle-*' }, +); Index: /lang/perl/Data-Decycle/trunk/Changes =================================================================== --- /lang/perl/Data-Decycle/trunk/Changes (revision 38338) +++ /lang/perl/Data-Decycle/trunk/Changes (revision 38338) @@ -0,0 +1,7 @@ +# +# $Id$ +# + +$Revision$ $Date$ ++ * + First release. Index: /lang/perl/Data-Decycle/trunk/MANIFEST.skip =================================================================== --- /lang/perl/Data-Decycle/trunk/MANIFEST.skip (revision 38338) +++ /lang/perl/Data-Decycle/trunk/MANIFEST.skip (revision 38338) @@ -0,0 +1,14 @@ +.*\.bak +blib.* +Makefile +Makefile.old +Build +Build\.bat +_build\.* +pm_to_blib.* +.*\.tar\.gz +.lwpcookies +cover_db +pod2htm.*.tmp +Data-Decycle-.* +t/.*\.pl Index: /lang/perl/Data-Decycle/trunk/README =================================================================== --- /lang/perl/Data-Decycle/trunk/README (revision 38338) +++ /lang/perl/Data-Decycle/trunk/README (revision 38338) @@ -0,0 +1,55 @@ +Data-Decycle + +The README is used to introduce the module and provide instructions on +how to install the module, any machine dependencies it may have (for +example C compilers and installed libraries) and any other information +that should be provided before the module is installed. + +A README file is required for CPAN modules since CPAN extracts the README +file from a module distribution so that people browsing the archive +can use it to get an idea of the module's uses. It is usually a good idea +to provide version information here so that people can decide whether +fixes for the module are worth downloading. + + +INSTALLATION + +To install this module, run the following commands: + + perl Makefile.PL + make + make test + make install + +SUPPORT AND DOCUMENTATION + +After installing, you can find documentation for this module with the +perldoc command. + + perldoc Data::Decycle + +You can also look for information at: + + RT, CPAN's request tracker + http://rt.cpan.org/NoAuth/Bugs.html?Dist=Data-Decycle + + AnnoCPAN, Annotated CPAN documentation + http://annocpan.org/dist/Data-Decycle + + CPAN Ratings + http://cpanratings.perl.org/d/Data-Decycle + + Search CPAN + http://search.cpan.org/dist/Data-Decycle/ + + +LICENSE AND COPYRIGHT + +Copyright (C) 2010 Dan Kogai + +This program is free software; you can redistribute it and/or modify it +under the terms of either: the GNU General Public License as published +by the Free Software Foundation; or the Artistic License. + +See http://dev.perl.org/licenses/ for more information. +