From: Peter Rabbitson <ribasushi@cpan.org>
Date: Thu, 4 Jul 2013 03:46:56 +0000 (+0200)
Subject: Detabardize - standardize code/tests on 2-space indent
X-Git-Tag: Try-Tiny-0.13~6^2~11
X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=8d2ee8319218941658f8513f03e3f063da941def;p=p5sagit%2FTry-Tiny.git

Detabardize - standardize code/tests on 2-space indent

Zero functional changes (examine under git diff -w)
---

diff --git a/Changes b/Changes
index b81ae75..e26990e 100644
--- a/Changes
+++ b/Changes
@@ -18,27 +18,27 @@
   - pass the error, if any, to finally blocks when called
 
 0.06
-	- in t/given_when.t use a plan instead of done_testing for more backwards
-	  compatibility
+  - in t/given_when.t use a plan instead of done_testing for more backwards
+    compatibility
 
 0.05
-	- Documentation fixes and clarifications
+  - Documentation fixes and clarifications
 
 0.04
-	- Restore list context propagation for catch blocks
-	- Fix a bug where finally blocks weren't always invoked
+  - Restore list context propagation for catch blocks
+  - Fix a bug where finally blocks weren't always invoked
 
 0.03
-	- Support for 'finally' blocks (Andy Yates)
-	- More documentation and tests (many people)
-	- Sets $@ to the previous value at the beginning of the eval, to allow
-	  the capture of an error stack when calling die.
+  - Support for 'finally' blocks (Andy Yates)
+  - More documentation and tests (many people)
+  - Sets $@ to the previous value at the beginning of the eval, to allow
+    the capture of an error stack when calling die.
 
 0.02
-	- Doc fixes from chromatic
-	- Various minor fixes from Adam Kennedy
-	- Additional documentation and code clarifications
-	- 5.005_04 compatibility
+  - Doc fixes from chromatic
+  - Various minor fixes from Adam Kennedy
+  - Additional documentation and code clarifications
+  - 5.005_04 compatibility
 
 0.01
-	- Initial release
+  - Initial release
diff --git a/Makefile.PL b/Makefile.PL
index e4f2cf1..c4d2722 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -5,17 +5,17 @@ use ExtUtils::MakeMaker;
 require 5.005_04;
 
 WriteMakefile(
-	NAME         => 'Try::Tiny',
-	VERSION_FROM => 'lib/Try/Tiny.pm',
-	INSTALLDIRS  => 'site',
-	PL_FILES     => { },
-	PREREQ_PM    => {
-		'Test::More' => 0,
-	},
-	META_MERGE => {
-		resources => {
-			homepage => 'https://github.com/doy/try-tiny.git',
-			repository => 'git://github.com/doy/try-tiny.git',
-		},
-	},
+  NAME         => 'Try::Tiny',
+  VERSION_FROM => 'lib/Try/Tiny.pm',
+  INSTALLDIRS  => 'site',
+  PL_FILES     => { },
+  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 --git a/lib/Try/Tiny.pm b/lib/Try/Tiny.pm
index a8c22b9..6f892c6 100644
--- a/lib/Try/Tiny.pm
+++ b/lib/Try/Tiny.pm
@@ -6,8 +6,8 @@ use strict;
 use vars qw(@EXPORT @EXPORT_OK $VERSION @ISA);
 
 BEGIN {
-	require Exporter;
-	@ISA = qw(Exporter);
+  require Exporter;
+  @ISA = qw(Exporter);
 }
 
 $VERSION = "0.12";
@@ -23,110 +23,110 @@ $Carp::Internal{+__PACKAGE__}++;
 # context & not a scalar one
 
 sub try (&;@) {
-	my ( $try, @code_refs ) = @_;
-
-	# we need to save this here, the eval block will be in scalar context due
-	# to $failed
-	my $wantarray = wantarray;
-
-	my ( $catch, @finally );
-
-	# find labeled blocks in the argument list.
-	# catch and finally tag the blocks by blessing a scalar reference to them.
-	foreach my $code_ref (@code_refs) {
-		next unless $code_ref;
-
-		my $ref = ref($code_ref);
-
-		if ( $ref eq 'Try::Tiny::Catch' ) {
-			$catch = ${$code_ref};
-		} elsif ( $ref eq 'Try::Tiny::Finally' ) {
-			push @finally, ${$code_ref};
-		} else {
-			use Carp;
-			confess("Unknown code ref type given '${ref}'. Check your usage & try again");
-		}
-	}
-
-	# save the value of $@ so we can set $@ back to it in the beginning of the eval
-	my $prev_error = $@;
-
-	my ( @ret, $error, $failed );
-
-	# FIXME consider using local $SIG{__DIE__} to accumulate all errors. It's
-	# not perfect, but we could provide a list of additional errors for
-	# $catch->();
-
-	{
-		# localize $@ to prevent clobbering of previous value by a successful
-		# eval.
-		local $@;
-
-		# failed will be true if the eval dies, because 1 will not be returned
-		# from the eval body
-		$failed = not eval {
-			$@ = $prev_error;
-
-			# evaluate the try block in the correct context
-			if ( $wantarray ) {
-				@ret = $try->();
-			} elsif ( defined $wantarray ) {
-				$ret[0] = $try->();
-			} else {
-				$try->();
-			};
-
-			return 1; # properly set $fail to false
-		};
-
-		# copy $@ to $error; when we leave this scope, local $@ will revert $@
-		# back to its previous value
-		$error = $@;
-	}
-
-	# set up a scope guard to invoke the finally block at the end
-	my @guards =
+  my ( $try, @code_refs ) = @_;
+
+  # we need to save this here, the eval block will be in scalar context due
+  # to $failed
+  my $wantarray = wantarray;
+
+  my ( $catch, @finally );
+
+  # find labeled blocks in the argument list.
+  # catch and finally tag the blocks by blessing a scalar reference to them.
+  foreach my $code_ref (@code_refs) {
+    next unless $code_ref;
+
+    my $ref = ref($code_ref);
+
+    if ( $ref eq 'Try::Tiny::Catch' ) {
+      $catch = ${$code_ref};
+    } elsif ( $ref eq 'Try::Tiny::Finally' ) {
+      push @finally, ${$code_ref};
+    } else {
+      use Carp;
+      confess("Unknown code ref type given '${ref}'. Check your usage & try again");
+    }
+  }
+
+  # save the value of $@ so we can set $@ back to it in the beginning of the eval
+  my $prev_error = $@;
+
+  my ( @ret, $error, $failed );
+
+  # FIXME consider using local $SIG{__DIE__} to accumulate all errors. It's
+  # not perfect, but we could provide a list of additional errors for
+  # $catch->();
+
+  {
+    # localize $@ to prevent clobbering of previous value by a successful
+    # eval.
+    local $@;
+
+    # failed will be true if the eval dies, because 1 will not be returned
+    # from the eval body
+    $failed = not eval {
+      $@ = $prev_error;
+
+      # evaluate the try block in the correct context
+      if ( $wantarray ) {
+        @ret = $try->();
+      } elsif ( defined $wantarray ) {
+        $ret[0] = $try->();
+      } else {
+        $try->();
+      };
+
+      return 1; # properly set $fail to false
+    };
+
+    # copy $@ to $error; when we leave this scope, local $@ will revert $@
+    # back to its previous value
+    $error = $@;
+  }
+
+  # set up a scope guard to invoke the finally block at the end
+  my @guards =
     map { Try::Tiny::ScopeGuard->_new($_, $failed ? $error : ()) }
     @finally;
 
-	# at this point $failed contains a true value if the eval died, even if some
-	# destructor overwrote $@ as the eval was unwinding.
-	if ( $failed ) {
-		# if we got an error, invoke the catch block.
-		if ( $catch ) {
-			# This works like given($error), but is backwards compatible and
-			# sets $_ in the dynamic scope for the body of C<$catch>
-			for ($error) {
-				return $catch->($error);
-			}
-
-			# in case when() was used without an explicit return, the C<for>
-			# loop will be aborted and there's no useful return value
-		}
-
-		return;
-	} else {
-		# no failure, $@ is back to what it was, everything is fine
-		return $wantarray ? @ret : $ret[0];
-	}
+  # at this point $failed contains a true value if the eval died, even if some
+  # destructor overwrote $@ as the eval was unwinding.
+  if ( $failed ) {
+    # if we got an error, invoke the catch block.
+    if ( $catch ) {
+      # This works like given($error), but is backwards compatible and
+      # sets $_ in the dynamic scope for the body of C<$catch>
+      for ($error) {
+        return $catch->($error);
+      }
+
+      # in case when() was used without an explicit return, the C<for>
+      # loop will be aborted and there's no useful return value
+    }
+
+    return;
+  } else {
+    # no failure, $@ is back to what it was, everything is fine
+    return $wantarray ? @ret : $ret[0];
+  }
 }
 
 sub catch (&;@) {
-	my ( $block, @rest ) = @_;
+  my ( $block, @rest ) = @_;
 
-	return (
-		bless(\$block, 'Try::Tiny::Catch'),
-		@rest,
-	);
+  return (
+    bless(\$block, 'Try::Tiny::Catch'),
+    @rest,
+  );
 }
 
 sub finally (&;@) {
-	my ( $block, @rest ) = @_;
+  my ( $block, @rest ) = @_;
 
-	return (
-		bless(\$block, 'Try::Tiny::Finally'),
-		@rest,
-	);
+  return (
+    bless(\$block, 'Try::Tiny::Finally'),
+    @rest,
+  );
 }
 
 {
@@ -160,21 +160,21 @@ Try::Tiny - minimal try/catch with proper localization of $@
 You can use Try::Tiny's C<try> and C<catch> to expect and handle exceptional
 conditions, avoiding quirks in Perl and common mistakes:
 
-	# handle errors with a catch handler
-	try {
-		die "foo";
-	} catch {
-		warn "caught error: $_"; # not $@
-	};
+  # handle errors with a catch handler
+  try {
+    die "foo";
+  } catch {
+    warn "caught error: $_"; # not $@
+  };
 
 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:
 
-	# just silence errors
-	try {
-		die "foo";
-	};
+  # just silence errors
+  try {
+    die "foo";
+  };
 
 =head1 DESCRIPTION
 
@@ -201,17 +201,17 @@ 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 = try { die "foo" } catch { "bar" };
+  my $x = try { die "foo" } || { "bar" };
+  my $x = (try { die "foo" }) // { "bar" };
 
-	my $x = eval { die "foo" } || "bar";
+  my $x = eval { die "foo" } || "bar";
 
 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' };
+  my $x;
+  try { die 'foo' } finally { $x = 'bar' };
+  try { die 'foo' } catch { warn "Got a die: $_" } finally { $x = 'bar' };
 
 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
@@ -256,7 +256,7 @@ Returns a reference to the subroutine it was given but blessed as
 C<Try::Tiny::Catch> which allows try to decode correctly what to do
 with this code reference.
 
-	catch { ... }
+  catch { ... }
 
 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
@@ -266,7 +266,7 @@ idea to preserve it in an error stack.
 For code that captures C<$@> when throwing new errors (i.e.
 L<Class::Throwable>), you'll need to do:
 
-	local $@ = $_;
+  local $@ = $_;
 
 =item finally (&;$)
 
@@ -343,32 +343,32 @@ the localization) in the beginning of the C<eval> block.
 
 Inside an C<eval> block, C<die> behaves sort of like:
 
-	sub die {
-		$@ = $_[0];
-		return_undef_from_eval();
-	}
+  sub die {
+    $@ = $_[0];
+    return_undef_from_eval();
+  }
 
 This means that if you were polite and localized C<$@> you can't die in that
 scope, or your error will be discarded (printing "Something's wrong" instead).
 
 The workaround is very ugly:
 
-	my $error = do {
-		local $@;
-		eval { ... };
-		$@;
-	};
+  my $error = do {
+    local $@;
+    eval { ... };
+    $@;
+  };
 
-	...
-	die $error;
+  ...
+  die $error;
 
 =head2 $@ might not be a true value
 
 This code is wrong:
 
-	if ( $@ ) {
-		...
-	}
+  if ( $@ ) {
+    ...
+  }
 
 because due to the previous caveats it may have been unset.
 
@@ -377,19 +377,19 @@ that's asking for trouble anyway.
 
 The classic failure mode is:
 
-	sub Object::DESTROY {
-		eval { ... }
-	}
+  sub Object::DESTROY {
+    eval { ... }
+  }
 
-	eval {
-		my $obj = Object->new;
+  eval {
+    my $obj = Object->new;
 
-		die "foo";
-	};
+    die "foo";
+  };
 
-	if ( $@ ) {
+  if ( $@ ) {
 
-	}
+  }
 
 In this case since C<Object::DESTROY> is not localizing C<$@> but still uses
 C<eval>, it will set C<$@> to C<"">.
@@ -402,11 +402,11 @@ 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 C<eval> was aborted due to an error:
 
-	my $failed = not eval {
-		...
+  my $failed = not eval {
+    ...
 
-		return 1;
-	};
+    return 1;
+  };
 
 This is because an C<eval> that caught a C<die> will always return a false
 value.
@@ -422,12 +422,12 @@ blocks without an explicit C<return>.
 This is somewhat similar to Perl 6's C<CATCH> blocks. You can use it to
 concisely match errors:
 
-	try {
-		require Foo;
-	} catch {
-		when (/^Can't locate .*?\.pm in \@INC/) { } # ignore
-		default { die $_ }
-	};
+  try {
+    require Foo;
+  } catch {
+    when (/^Can't locate .*?\.pm in \@INC/) { } # ignore
+    default { die $_ }
+  };
 
 =head1 CAVEATS
 
@@ -439,18 +439,18 @@ C<@_> is not available within the C<try> block, so you need to copy your
 arglist. In case you want to work with argument values directly via C<@_>
 aliasing (i.e. allow C<$_[1] = "foo">), you need to pass C<@_> by reference:
 
-	sub foo {
-		my ( $self, @args ) = @_;
-		try { $self->bar(@args) }
-	}
+  sub foo {
+    my ( $self, @args ) = @_;
+    try { $self->bar(@args) }
+  }
 
 or
 
-	sub bar_in_place {
-		my $self = shift;
-		my $args = \@_;
-		try { $_ = $self->bar($_) for @$args }
-	}
+  sub bar_in_place {
+    my $self = shift;
+    my $args = \@_;
+    try { $_ = $self->bar($_) for @$args }
+  }
 
 =item *
 
@@ -458,26 +458,26 @@ C<return> returns from the C<try> block, not from the parent sub (note that
 this is also how C<eval> works, but not how L<TryCatch> works):
 
   sub parent_sub {
-      try {
-          die;
-      }
-      catch {
-          return;
-      };
+    try {
+      die;
+    }
+    catch {
+      return;
+    };
 
-      say "this text WILL be displayed, even though an exception is thrown";
+    say "this text WILL be displayed, even though an exception is thrown";
   }
 
 Instead, you should capture the return value:
 
   sub parent_sub {
-      my $success = try {
-          die;
-          1;
-      }
-      return unless $success;
+    my $success = try {
+      die;
+      1;
+    }
+    return unless $success;
 
-      say "This text WILL NEVER appear!";
+    say "This text WILL NEVER appear!";
   }
 
 Note that if you have a C<catch> block, it must return C<undef> for this to work,
@@ -503,15 +503,15 @@ The return value of the C<catch> block is not ignored, so if testing the result
 of the expression for truth on success, be sure to return a false value from
 the C<catch> block:
 
-	my $obj = try {
-		MightFail->new;
-	} catch {
-		...
+  my $obj = try {
+    MightFail->new;
+  } catch {
+    ...
 
-		return; # avoid returning a true value;
-	};
+    return; # avoid returning a true value;
+  };
 
-	return unless $obj;
+  return unless $obj;
 
 =item *
 
@@ -529,16 +529,16 @@ Lexical C<$_> may override the one set by C<catch>.
 For example Perl 5.10's C<given> form uses a lexical C<$_>, creating some
 confusing behavior:
 
-	given ($foo) {
-		when (...) {
-			try {
-				...
-			} catch {
-				warn $_; # will print $foo, not the error
-				warn $_[0]; # instead, get the error like this
-			}
-		}
-	}
+  given ($foo) {
+    when (...) {
+      try {
+        ...
+      } catch {
+        warn $_; # will print $foo, not the error
+        warn $_[0]; # instead, get the error like this
+      }
+    }
+  }
 
 =back
 
@@ -596,9 +596,9 @@ Yuval Kogman E<lt>nothingmuch@woobling.orgE<gt>
 
 =head1 COPYRIGHT
 
-	Copyright (c) 2009 Yuval Kogman. All rights reserved.
-	This program is free software; you can redistribute
-	it and/or modify it under the terms of the MIT license.
+  Copyright (c) 2009 Yuval Kogman. All rights reserved.
+  This program is free software; you can redistribute
+  it and/or modify it under the terms of the MIT license.
 
 =cut
 
diff --git a/t/basic.t b/t/basic.t
index 93e7b03..fea3c5c 100644
--- a/t/basic.t
+++ b/t/basic.t
@@ -8,68 +8,68 @@ use Test::More tests => 26;
 BEGIN { use_ok 'Try::Tiny' };
 
 sub _eval {
-	local $@;
-	local $Test::Builder::Level = $Test::Builder::Level + 2;
-	return ( scalar(eval { $_[0]->(); 1 }), $@ );
+  local $@;
+  local $Test::Builder::Level = $Test::Builder::Level + 2;
+  return ( scalar(eval { $_[0]->(); 1 }), $@ );
 }
 
 
 sub lives_ok (&$) {
-	my ( $code, $desc ) = @_;
-	local $Test::Builder::Level = $Test::Builder::Level + 1;
+  my ( $code, $desc ) = @_;
+  local $Test::Builder::Level = $Test::Builder::Level + 1;
 
-	my ( $ok, $error ) = _eval($code);
+  my ( $ok, $error ) = _eval($code);
 
-	ok($ok, $desc );
+  ok($ok, $desc );
 
-	diag "error: $@" unless $ok;
+  diag "error: $@" unless $ok;
 }
 
 sub throws_ok (&$$) {
-	my ( $code, $regex, $desc ) = @_;
-	local $Test::Builder::Level = $Test::Builder::Level + 1;
+  my ( $code, $regex, $desc ) = @_;
+  local $Test::Builder::Level = $Test::Builder::Level + 1;
 
-	my ( $ok, $error ) = _eval($code);
+  my ( $ok, $error ) = _eval($code);
 
-	if ( $ok ) {
-		fail($desc);
-	} else {
-		like($error || '', $regex, $desc );
-	}
+  if ( $ok ) {
+    fail($desc);
+  } else {
+    like($error || '', $regex, $desc );
+  }
 }
 
 
 my $prev;
 
 lives_ok {
-	try {
-		die "foo";
-	};
+  try {
+    die "foo";
+  };
 } "basic try";
 
 throws_ok {
-	try {
-		die "foo";
-	} catch { die $_ };
+  try {
+    die "foo";
+  } catch { die $_ };
 } qr/foo/, "rethrow";
 
 
 {
-	local $@ = "magic";
-	is( try { 42 }, 42, "try block evaluated" );
-	is( $@, "magic", '$@ untouched' );
+  local $@ = "magic";
+  is( try { 42 }, 42, "try block evaluated" );
+  is( $@, "magic", '$@ untouched' );
 }
 
 {
-	local $@ = "magic";
-	is( try { die "foo" }, undef, "try block died" );
-	is( $@, "magic", '$@ untouched' );
+  local $@ = "magic";
+  is( try { die "foo" }, undef, "try block died" );
+  is( $@, "magic", '$@ untouched' );
 }
 
 {
-	local $@ = "magic";
-	like( (try { die "foo" } catch { $_ }), qr/foo/, "catch block evaluated" );
-	is( $@, "magic", '$@ untouched' );
+  local $@ = "magic";
+  like( (try { die "foo" } catch { $_ }), qr/foo/, "catch block evaluated" );
+  is( $@, "magic", '$@ untouched' );
 }
 
 is( scalar(try { "foo", "bar", "gorch" }), "gorch", "scalar context try" );
@@ -80,87 +80,87 @@ is_deeply( [ try { die } catch {qw(foo bar gorch)} ], [qw(foo bar gorch)], "list
 
 
 {
-	my ($sub) = catch { my $a = $_; };
-	is(ref($sub), 'Try::Tiny::Catch', 'Checking catch subroutine scalar reference is correctly blessed');
+  my ($sub) = catch { my $a = $_; };
+  is(ref($sub), 'Try::Tiny::Catch', 'Checking catch subroutine scalar reference is correctly blessed');
 }
 
 {
-	my ($sub) = finally { my $a = $_; };
-	is(ref($sub), 'Try::Tiny::Finally', 'Checking finally subroutine scalar reference is correctly blessed');
+  my ($sub) = finally { my $a = $_; };
+  is(ref($sub), 'Try::Tiny::Finally', 'Checking finally subroutine scalar reference is correctly blessed');
 }
 
 lives_ok {
-	try {
-		die "foo";
-	} catch {
-		my $err = shift;
-
-		try {
-			like $err, qr/foo/;
-		} catch {
-			fail("shouldn't happen");
-		};
-
-		pass "got here";
-	}
+  try {
+    die "foo";
+  } catch {
+    my $err = shift;
+
+    try {
+      like $err, qr/foo/;
+    } catch {
+      fail("shouldn't happen");
+    };
+
+    pass "got here";
+  }
 } "try in try catch block";
 
 throws_ok {
-	try {
-		die "foo";
-	} catch {
-		my $err = shift;
+  try {
+    die "foo";
+  } catch {
+    my $err = shift;
 
-		try { } catch { };
+    try { } catch { };
 
-		die "rethrowing $err";
-	}
+    die "rethrowing $err";
+  }
 } qr/rethrowing foo/, "rethrow with try in catch block";
 
 
 sub Evil::DESTROY {
-	eval { "oh noes" };
+  eval { "oh noes" };
 }
 
 sub Evil::new { bless { }, $_[0] }
 
 {
-	local $@ = "magic";
-	local $_ = "other magic";
-
-	try {
-		my $object = Evil->new;
-		die "foo";
-	} catch {
-		pass("catch invoked");
-		local $TODO = "i don't think we can ever make this work sanely, maybe with SIG{__DIE__}" if $] < 5.014;
-		like($_, qr/foo/);
-	};
-
-	is( $@, "magic", '$@ untouched' );
-	is( $_, "other magic", '$_ untouched' );
+  local $@ = "magic";
+  local $_ = "other magic";
+
+  try {
+    my $object = Evil->new;
+    die "foo";
+  } catch {
+    pass("catch invoked");
+    local $TODO = "i don't think we can ever make this work sanely, maybe with SIG{__DIE__}" if $] < 5.014;
+    like($_, qr/foo/);
+  };
+
+  is( $@, "magic", '$@ untouched' );
+  is( $_, "other magic", '$_ untouched' );
 }
 
 {
-	my ( $caught, $prev );
+  my ( $caught, $prev );
 
-	{
-		local $@;
+  {
+    local $@;
 
-		eval { die "bar\n" };
+    eval { die "bar\n" };
 
-		is( $@, "bar\n", 'previous value of $@' );
+    is( $@, "bar\n", 'previous value of $@' );
 
-		try {
-			die {
-				prev => $@,
-			}
-		} catch {
-			$caught = $_;
-			$prev = $@;
-		}
-	}
+    try {
+      die {
+        prev => $@,
+      }
+    } catch {
+      $caught = $_;
+      $prev = $@;
+    }
+  }
 
-	is_deeply( $caught, { prev => "bar\n" }, 'previous value of $@ available for capture' );
-	is( $prev, "bar\n", 'previous value of $@ also available in catch block' );
+  is_deeply( $caught, { prev => "bar\n" }, 'previous value of $@ available for capture' );
+  is( $prev, "bar\n", 'previous value of $@ also available in catch block' );
 }
diff --git a/t/finally.t b/t/finally.t
index abfb9cb..bbc4e0e 100644
--- a/t/finally.t
+++ b/t/finally.t
@@ -8,34 +8,34 @@ use Test::More tests => 24;
 BEGIN { use_ok 'Try::Tiny' };
 
 try {
-	my $a = 1+1;
+  my $a = 1+1;
 } catch {
-	fail('Cannot go into catch block because we did not throw an exception')
+  fail('Cannot go into catch block because we did not throw an exception')
 } finally {
-	pass('Moved into finally from try');
+  pass('Moved into finally from try');
 };
 
 try {
-	die('Die');
+  die('Die');
 } catch {
-	ok($_ =~ /Die/, 'Error text as expected');
-	pass('Into catch block as we died in try');
+  ok($_ =~ /Die/, 'Error text as expected');
+  pass('Into catch block as we died in try');
 } finally {
-	pass('Moved into finally from catch');
+  pass('Moved into finally from catch');
 };
 
 try {
-	die('Die');
+  die('Die');
 } finally {
-	pass('Moved into finally from catch');
+  pass('Moved into finally from catch');
 } catch {
-	ok($_ =~ /Die/, 'Error text as expected');
+  ok($_ =~ /Die/, 'Error text as expected');
 };
 
 try {
-	die('Die');
+  die('Die');
 } finally {
-	pass('Moved into finally block when try throws an exception and we have no catch block');
+  pass('Moved into finally block when try throws an exception and we have no catch block');
 };
 
 try {
@@ -63,42 +63,42 @@ try {
 };
 
 try {
-    try {
-        die "foo";
-    }
-    catch {
-        die "bar";
-    }
-    finally {
-        pass("finally called");
-    };
+  try {
+    die "foo";
+  }
+  catch {
+    die "bar";
+  }
+  finally {
+    pass("finally called");
+  };
 };
 
 $_ = "foo";
 try {
-    is($_, "foo", "not localized in try");
+  is($_, "foo", "not localized in try");
 }
 catch {
 }
 finally {
-    is(scalar(@_), 0, "nothing in \@_ (finally)");
-    is($_, "foo", "\$_ not localized (finally)");
+  is(scalar(@_), 0, "nothing in \@_ (finally)");
+  is($_, "foo", "\$_ not localized (finally)");
 };
 is($_, "foo", "same afterwards");
 
 $_ = "foo";
 try {
-    is($_, "foo", "not localized in try");
-    die "bar\n";
+  is($_, "foo", "not localized in try");
+  die "bar\n";
 }
 catch {
-    is($_[0], "bar\n", "error in \@_ (catch)");
-    is($_, "bar\n", "error in \$_ (catch)");
+  is($_[0], "bar\n", "error in \@_ (catch)");
+  is($_, "bar\n", "error in \$_ (catch)");
 }
 finally {
-    is(scalar(@_), 1, "error in \@_ (finally)");
-    is($_[0], "bar\n", "error in \@_ (finally)");
-    is($_, "foo", "\$_ not localized (finally)");
+  is(scalar(@_), 1, "error in \@_ (finally)");
+  is($_[0], "bar\n", "error in \@_ (finally)");
+  is($_, "foo", "\$_ not localized (finally)");
 };
 is($_, "foo", "same afterwards");
 1;
diff --git a/t/given_when.t b/t/given_when.t
index dce86bb..4ae9baa 100644
--- a/t/given_when.t
+++ b/t/given_when.t
@@ -6,9 +6,9 @@ use warnings;
 use Test::More;
 
 BEGIN {
-    plan skip_all => "Perl 5.10 is required" unless eval { require 5.010 };
-    plan tests => 3;
-    use_ok("Try::Tiny");
+  plan skip_all => "Perl 5.10 is required" unless eval { require 5.010 };
+  plan tests => 3;
+  use_ok("Try::Tiny");
 }
 
 use 5.010;
@@ -16,21 +16,21 @@ use 5.010;
 my ( $error, $topic );
 
 given ("foo") {
-    when (qr/./) {
-        try {
-            die "blah\n";
-        } catch {
-            $topic = $_;
-            $error = $_[0];
-        }
-    };
+  when (qr/./) {
+    try {
+      die "blah\n";
+    } catch {
+      $topic = $_;
+      $error = $_[0];
+    }
+  };
 }
 
 is( $error, "blah\n", "error caught" );
 
 {
-    local $TODO = "perhaps a workaround can be found";
-    is( $topic, $error, 'error is also in $_' );
+  local $TODO = "perhaps a workaround can be found";
+  is( $topic, $error, 'error is also in $_' );
 }
 
 # ex: set sw=4 et:
diff --git a/t/when.t b/t/when.t
index e6d64e6..ea5b772 100644
--- a/t/when.t
+++ b/t/when.t
@@ -6,8 +6,8 @@ use strict;
 use Test::More;
 
 BEGIN {
-	plan skip_all => "Perl 5.10 required" unless eval { require 5.010; 1 };
-	plan tests => 6;
+  plan skip_all => "Perl 5.10 required" unless eval { require 5.010; 1 };
+  plan tests => 6;
 }
 
 
@@ -20,14 +20,14 @@ my ( $foo, $bar, $other );
 $_ = "magic";
 
 try {
-	die "foo";
+  die "foo";
 } catch {
 
-	like( $_, qr/foo/ );
+  like( $_, qr/foo/ );
 
-	when (/bar/) { $bar++ };
-	when (/foo/) { $foo++ };
-	default { $other++ };
+  when (/bar/) { $bar++ };
+  when (/foo/) { $foo++ };
+  default { $other++ };
 };
 
 is( $_, "magic", '$_ not clobbered' );