Hello community, here is the log from the commit of package perl-Try-Tiny for openSUSE:Factory checked in at 2013-06-06 14:00:55 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/perl-Try-Tiny (Old) and /work/SRC/openSUSE:Factory/.perl-Try-Tiny.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "perl-Try-Tiny" Changes: -------- --- /work/SRC/openSUSE:Factory/perl-Try-Tiny/perl-Try-Tiny.changes 2011-09-23 12:39:21.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.perl-Try-Tiny.new/perl-Try-Tiny.changes 2013-06-06 14:00:58.000000000 +0200 @@ -1,0 +2,6 @@ +Tue Jun 4 15:25:34 UTC 2013 - [email protected] + +- updated to 0.12 + - doc fixes + +------------------------------------------------------------------- Old: ---- Try-Tiny-0.11.tar.gz New: ---- Try-Tiny-0.12.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ perl-Try-Tiny.spec ++++++ --- /var/tmp/diff_new_pack.h0ZtL4/_old 2013-06-06 14:00:59.000000000 +0200 +++ /var/tmp/diff_new_pack.h0ZtL4/_new 2013-06-06 14:00:59.000000000 +0200 @@ -1,7 +1,7 @@ # # spec file for package perl-Try-Tiny # -# Copyright (c) 2011 SUSE LINUX Products GmbH, Nuernberg, Germany. +# Copyright (c) 2013 SUSE LINUX Products GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -16,15 +16,14 @@ # - Name: perl-Try-Tiny -Version: 0.11 -Release: 1 -License: MIT +Version: 0.12 +Release: 0 %define cpan_name Try-Tiny Summary: Minimal try/catch with proper localization of $@ -Url: http://search.cpan.org/dist/Try-Tiny/ +License: MIT Group: Development/Libraries/Perl +Url: http://search.cpan.org/dist/Try-Tiny/ Source: http://www.cpan.org/authors/id/D/DO/DOY/%{cpan_name}-%{version}.tar.gz BuildArch: noarch BuildRoot: %{_tmppath}/%{name}-%{version}-build @@ -37,9 +36,9 @@ designed to minimize common mistakes with eval blocks, and NOTHING else. This is unlike the TryCatch manpage which provides a nice syntax and avoids -adding another call stack layer, and supports calling 'return' from the try -block to return from the parent subroutine. These extra features come at a -cost of a few dependencies, namely the Devel::Declare manpage and the +adding another call stack layer, and supports calling 'return' from the +'try' block to return from the parent subroutine. These extra features come +at a cost of a few dependencies, namely the Devel::Declare manpage and the Scope::Upper manpage which are occasionally problematic, and the additional catch filtering uses the Moose manpage type constraints which may not be desirable either. @@ -50,28 +49,30 @@ boilerplate each time. It's designed to work as correctly as possible in light of the various -pathological edge cases (see the BACKGROUND manpage) and to be compatible +pathological edge cases (see the /BACKGROUND manpage) and to be compatible with any style of error values (simple strings, references, objects, overloaded objects, etc). -If the try block dies, it returns the value of the last statement executed -in the catch block, if there is one. Otherwise, it returns 'undef' in -scalar context or the empty list in list context. The following two -examples both assign '"bar"' to '$x'. +If the 'try' block dies, it returns the value of the last statement +executed in the 'catch' block, if there is one. Otherwise, it returns +'undef' in scalar context or the empty list in list context. The following +examples all assign '"bar"' to '$x': my $x = try { die "foo" } catch { "bar" }; + my $x = try { die "foo" } || { "bar" }; + my $x = (try { die "foo" }) // { "bar" }; my $x = eval { die "foo" } || "bar"; -You can add finally blocks making the following true. +You can add 'finally' blocks, yielding the following: my $x; try { die 'foo' } finally { $x = 'bar' }; try { die 'foo' } catch { warn "Got a die: $_" } finally { $x = 'bar' }; -Finally blocks are always executed making them suitable for cleanup code -which cannot be handled using local. You can add as many finally blocks to -a given try block as you like. +'finally' blocks are always executed making them suitable for cleanup code +which cannot be handled using local. You can add as many 'finally' blocks +to a given 'try' block as you like. %prep %setup -q -n %{cpan_name}-%{version} ++++++ Try-Tiny-0.11.tar.gz -> Try-Tiny-0.12.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Try-Tiny-0.11/Changes new/Try-Tiny-0.12/Changes --- old/Try-Tiny-0.11/Changes 2011-08-30 17:50:00.000000000 +0200 +++ new/Try-Tiny-0.12/Changes 2013-01-02 17:27:56.000000000 +0100 @@ -1,3 +1,6 @@ +0.12 + - doc fixes + 0.11 - fix broken dist diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Try-Tiny-0.11/MANIFEST new/Try-Tiny-0.12/MANIFEST --- old/Try-Tiny-0.11/MANIFEST 2011-08-30 17:50:50.000000000 +0200 +++ new/Try-Tiny-0.12/MANIFEST 2013-01-02 17:29:12.000000000 +0100 @@ -8,4 +8,5 @@ t/finally.t t/given_when.t t/when.t -META.yml Module meta-data (added by MakeMaker) +META.yml Module YAML meta-data (added by MakeMaker) +META.json Module JSON meta-data (added by MakeMaker) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Try-Tiny-0.11/MANIFEST.SKIP new/Try-Tiny-0.12/MANIFEST.SKIP --- old/Try-Tiny-0.11/MANIFEST.SKIP 2011-04-27 23:54:57.000000000 +0200 +++ new/Try-Tiny-0.12/MANIFEST.SKIP 2013-01-02 17:23:41.000000000 +0100 @@ -44,3 +44,5 @@ \.(?:bs|c|o)$ \.gitignore$ + +MYMETA diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Try-Tiny-0.11/META.json new/Try-Tiny-0.12/META.json --- old/Try-Tiny-0.11/META.json 1970-01-01 01:00:00.000000000 +0100 +++ new/Try-Tiny-0.12/META.json 2013-01-02 17:29:12.000000000 +0100 @@ -0,0 +1,47 @@ +{ + "abstract" : "unknown", + "author" : [ + "unknown" + ], + "dynamic_config" : 1, + "generated_by" : "ExtUtils::MakeMaker version 6.6302, CPAN::Meta::Converter version 2.120921", + "license" : [ + "unknown" + ], + "meta-spec" : { + "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec";, + "version" : "2" + }, + "name" : "Try-Tiny", + "no_index" : { + "directory" : [ + "t", + "inc" + ] + }, + "prereqs" : { + "build" : { + "requires" : { + "ExtUtils::MakeMaker" : "0" + } + }, + "configure" : { + "requires" : { + "ExtUtils::MakeMaker" : "0" + } + }, + "runtime" : { + "requires" : { + "Test::More" : "0" + } + } + }, + "release_status" : "stable", + "resources" : { + "homepage" : "https://github.com/doy/try-tiny.git";, + "repository" : { + "url" : "git://github.com/doy/try-tiny.git" + } + }, + "version" : "0.12" +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Try-Tiny-0.11/META.yml new/Try-Tiny-0.12/META.yml --- old/Try-Tiny-0.11/META.yml 2011-08-30 17:50:50.000000000 +0200 +++ new/Try-Tiny-0.12/META.yml 2013-01-02 17:29:12.000000000 +0100 @@ -1,21 +1,25 @@ ---- #YAML:1.0 -name: Try-Tiny -version: 0.11 -abstract: ~ -author: [] -license: unknown -distribution_type: module -configure_requires: - ExtUtils::MakeMaker: 0 +--- +abstract: unknown +author: + - unknown build_requires: - ExtUtils::MakeMaker: 0 -requires: - Test::More: 0 -no_index: - directory: - - t - - inc -generated_by: ExtUtils::MakeMaker version 6.56 + ExtUtils::MakeMaker: 0 +configure_requires: + ExtUtils::MakeMaker: 0 +dynamic_config: 1 +generated_by: 'ExtUtils::MakeMaker version 6.6302, CPAN::Meta::Converter version 2.120921' +license: unknown meta-spec: - url: http://module-build.sourceforge.net/META-spec-v1.4.html - version: 1.4 + url: http://module-build.sourceforge.net/META-spec-v1.4.html + version: 1.4 +name: Try-Tiny +no_index: + directory: + - t + - inc +requires: + Test::More: 0 +resources: + homepage: https://github.com/doy/try-tiny.git + repository: git://github.com/doy/try-tiny.git +version: 0.12 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Try-Tiny-0.11/Makefile.PL new/Try-Tiny-0.12/Makefile.PL --- old/Try-Tiny-0.11/Makefile.PL 2011-04-27 23:54:57.000000000 +0200 +++ new/Try-Tiny-0.12/Makefile.PL 2013-01-02 17:22:30.000000000 +0100 @@ -12,4 +12,10 @@ PREREQ_PM => { 'Test::More' => 0, }, + META_MERGE => { + resources => { + homepage => 'https://github.com/doy/try-tiny.git', + repository => 'git://github.com/doy/try-tiny.git', + }, + }, ); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Try-Tiny-0.11/lib/Try/Tiny.pm new/Try-Tiny-0.12/lib/Try/Tiny.pm --- old/Try-Tiny-0.11/lib/Try/Tiny.pm 2011-08-30 17:50:14.000000000 +0200 +++ new/Try-Tiny-0.12/lib/Try/Tiny.pm 2013-01-02 17:28:17.000000000 +0100 @@ -10,7 +10,7 @@ @ISA = qw(Exporter); } -$VERSION = "0.11"; +$VERSION = "0.12"; $VERSION = eval $VERSION; @@ -167,7 +167,7 @@ warn "caught error: $_"; # not $@ }; -You can also use it like a stanalone C<eval> to catch and ignore any error +You can also use it like a standalone C<eval> to catch and ignore any error conditions. Obviously, this is an extreme measure not to be undertaken lightly: @@ -182,7 +182,7 @@ minimize common mistakes with eval blocks, and NOTHING else. This is unlike L<TryCatch> which provides a nice syntax and avoids adding -another call stack layer, and supports calling C<return> from the try block to +another call stack layer, and supports calling C<return> from the C<try> block to return from the parent subroutine. These extra features come at a cost of a few dependencies, namely L<Devel::Declare> and L<Scope::Upper> which are occasionally problematic, and the additional catch filtering uses L<Moose> @@ -193,27 +193,29 @@ write correct C<eval> blocks without 5 lines of boilerplate each time. It's designed to work as correctly as possible in light of the various -pathological edge cases (see L<BACKGROUND>) and to be compatible with any style +pathological edge cases (see L</BACKGROUND>) and to be compatible with any style of error values (simple strings, references, objects, overloaded objects, etc). -If the try block dies, it returns the value of the last statement executed in -the catch block, if there is one. Otherwise, it returns C<undef> in scalar -context or the empty list in list context. The following two examples both -assign C<"bar"> to C<$x>. +If the C<try> block dies, it returns the value of the last statement executed in +the C<catch> block, if there is one. Otherwise, it returns C<undef> in scalar +context or the empty list in list context. The following examples all +assign C<"bar"> to C<$x>: my $x = try { die "foo" } catch { "bar" }; + my $x = try { die "foo" } || { "bar" }; + my $x = (try { die "foo" }) // { "bar" }; my $x = eval { die "foo" } || "bar"; -You can add finally blocks making the following true. +You can add C<finally> blocks, yielding the following: my $x; try { die 'foo' } finally { $x = 'bar' }; try { die 'foo' } catch { warn "Got a die: $_" } finally { $x = 'bar' }; -Finally blocks are always executed making them suitable for cleanup code -which cannot be handled using local. You can add as many finally blocks to a -given try block as you like. +C<finally> blocks are always executed making them suitable for cleanup code +which cannot be handled using local. You can add as many C<finally> blocks to a +given C<try> block as you like. =head1 EXPORTS @@ -226,7 +228,7 @@ =item try (&;@) -Takes one mandatory try subroutine, an optional catch subroutine & finally +Takes one mandatory C<try> subroutine, an optional C<catch> subroutine and C<finally> subroutine. The mandatory subroutine is evaluated in the context of an C<eval> block. @@ -244,7 +246,7 @@ Note that the error may be false, but if that happens the C<catch> block will still be invoked. -Once all execution is finished then the finally block if given will execute. +Once all execution is finished then the C<finally> block, if given, will execute. =item catch (&;$) @@ -256,7 +258,7 @@ catch { ... } -Inside the catch block the caught error is stored in C<$_>, while previous +Inside the C<catch> block the caught error is stored in C<$_>, while previous value of C<$@> is still available for use. This value may or may not be meaningful depending on what happened before the C<try>, but it might be a good idea to preserve it in an error stack. @@ -283,14 +285,14 @@ finally { ... } catch { ... }; -Intended to be the second or third element of C<try>. Finally blocks are always +Intended to be the second or third element of C<try>. C<finally> blocks are always executed in the event of a successful C<try> or if C<catch> is run. This allows you to locate cleanup code which cannot be done via C<local()> e.g. closing a file handle. -When invoked, the finally block is passed the error that was caught. If no -error was caught, it is passed nothing. (Note that the finally block does not -localize C<$_> with the error, since unlike in a catch block, there is no way +When invoked, the C<finally> block is passed the error that was caught. If no +error was caught, it is passed nothing. (Note that the C<finally> block does not +localize C<$_> with the error, since unlike in a C<catch> block, there is no way to know if C<$_ == undef> implies that there were no errors.) In other words, the following code does just what you would expect: @@ -306,7 +308,7 @@ } }; -B<You must always do your own error handling in the finally block>. C<Try::Tiny> will +B<You must always do your own error handling in the C<finally> block>. C<Try::Tiny> will not do anything about handling possible errors coming from code located in these blocks. @@ -321,7 +323,7 @@ =head2 Clobbering $@ -When you run an eval block and it succeeds, C<$@> will be cleared, potentially +When you run an C<eval> block and it succeeds, C<$@> will be cleared, potentially clobbering an error that is currently being caught. This causes action at a distance, clearing previous errors your caller may have @@ -339,7 +341,7 @@ =head2 Localizing $@ silently masks errors -Inside an eval block C<die> behaves sort of like: +Inside an C<eval> block, C<die> behaves sort of like: sub die { $@ = $_[0]; @@ -398,7 +400,7 @@ The workaround for this is even uglier than the previous ones. Even though we can't save the value of C<$@> from code that doesn't localize, we can at least -be sure the eval was aborted due to an error: +be sure the C<eval> was aborted due to an error: my $failed = not eval { ... @@ -478,8 +480,8 @@ say "This text WILL NEVER appear!"; } -Note that if you have a catch block, it must return undef for this to work, -since if a catch block exists, its return value is returned in place of undef +Note that if you have a C<catch> block, it must return C<undef> for this to work, +since if a C<catch> block exists, its return value is returned in place of C<undef> when an exception is thrown. =item * diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Try-Tiny-0.11/t/basic.t new/Try-Tiny-0.12/t/basic.t --- old/Try-Tiny-0.11/t/basic.t 2011-04-27 23:54:57.000000000 +0200 +++ new/Try-Tiny-0.12/t/basic.t 2013-01-02 17:27:00.000000000 +0100 @@ -133,7 +133,7 @@ die "foo"; } catch { pass("catch invoked"); - local $TODO = "i don't think we can ever make this work sanely, maybe with SIG{__DIE__}"; + local $TODO = "i don't think we can ever make this work sanely, maybe with SIG{__DIE__}" if $] < 5.014; like($_, qr/foo/); }; -- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
