[libtest2-perl] 06/06: add spelling.patch
gregor herrmann
gregoa at debian.org
Sat Feb 6 17:22:28 UTC 2016
This is an automated email from the git hooks/post-receive script.
gregoa pushed a commit to branch master
in repository libtest2-perl.
commit 574bb955e510d63c32aabab4229c12df912cb21d
Author: gregor herrmann <gregoa at debian.org>
Date: Sat Feb 6 18:22:14 2016 +0100
add spelling.patch
---
debian/patches/series | 1 +
debian/patches/spelling.patch | 484 ++++++++++++++++++++++++++++++++++++++++++
2 files changed, 485 insertions(+)
diff --git a/debian/patches/series b/debian/patches/series
new file mode 100644
index 0000000..5299247
--- /dev/null
+++ b/debian/patches/series
@@ -0,0 +1 @@
+spelling.patch
diff --git a/debian/patches/spelling.patch b/debian/patches/spelling.patch
new file mode 100644
index 0000000..e2b1c91
--- /dev/null
+++ b/debian/patches/spelling.patch
@@ -0,0 +1,484 @@
+Description: fix spelling, in POD and also function names
+Origin: vendor
+Author: gregor herrmann <gregoa at debian.org>
+Last-Update: 2016-02-06
+
+--- a/Changes
++++ b/Changes
+@@ -9,7 +9,7 @@
+ 0.000023 2016-01-28 20:34:09-08:00 America/Los_Angeles
+
+ - Add context_do()
+- - Add context_aquire hooks
++ - Add context_acquire hooks
+ - Documentation updates
+ - Typo fixes (thanks rjbs)
+ - Minor enhancement to test tools
+--- a/lib/Test2/API.pm
++++ b/lib/Test2/API.pm
+@@ -42,12 +42,12 @@
+ test2_stack
+ test2_no_wait
+
+- test2_add_callback_context_aquire
++ test2_add_callback_context_acquire
+ test2_add_callback_context_init
+ test2_add_callback_context_release
+ test2_add_callback_exit
+ test2_add_callback_post_load
+- test2_list_context_aquire_callbacks
++ test2_list_context_acquire_callbacks
+ test2_list_context_init_callbacks
+ test2_list_context_release_callbacks
+ test2_list_exit_callbacks
+@@ -89,10 +89,10 @@
+ goto &import;
+ }
+
+-my $STACK = $INST->stack;
+-my $CONTEXTS = $INST->contexts;
+-my $INIT_CBS = $INST->context_init_callbacks;
+-my $AQUIRE_CBS = $INST->context_aquire_callbacks;
++my $STACK = $INST->stack;
++my $CONTEXTS = $INST->contexts;
++my $INIT_CBS = $INST->context_init_callbacks;
++my $ACQUIRE_CBS = $INST->context_acquire_callbacks;
+
+ sub test2_init_done { $INST->finalized }
+ sub test2_load_done { $INST->loaded }
+@@ -105,12 +105,12 @@
+ $INST->no_wait;
+ }
+
+-sub test2_add_callback_context_aquire { $INST->add_context_aquire_callback(@_) }
++sub test2_add_callback_context_acquire { $INST->add_context_acquire_callback(@_) }
+ sub test2_add_callback_context_init { $INST->add_context_init_callback(@_) }
+ sub test2_add_callback_context_release { $INST->add_context_release_callback(@_) }
+ sub test2_add_callback_exit { $INST->add_exit_callback(@_) }
+ sub test2_add_callback_post_load { $INST->add_post_load_callback(@_) }
+-sub test2_list_context_aquire_callbacks { @{$INST->context_aquire_callbacks} }
++sub test2_list_context_acquire_callbacks { @{$INST->context_acquire_callbacks} }
+ sub test2_list_context_init_callbacks { @{$INST->context_init_callbacks} }
+ sub test2_list_context_release_callbacks { @{$INST->context_release_callbacks} }
+ sub test2_list_exit_callbacks { @{$INST->exit_callbacks} }
+@@ -138,7 +138,7 @@
+
+ # Private, for use in Test2::API::Context
+ sub _contexts_ref { $INST->contexts }
+-sub _context_aquire_callbacks_ref { $INST->context_aquire_callbacks }
++sub _context_acquire_callbacks_ref { $INST->context_acquire_callbacks }
+ sub _context_init_callbacks_ref { $INST->context_init_callbacks }
+ sub _context_release_callbacks_ref { $INST->context_release_callbacks }
+
+@@ -207,8 +207,8 @@
+ my $hid = $hub->{hid};
+ my $current = $CONTEXTS->{$hid};
+
+- $_->(\%params) for @$AQUIRE_CBS;
+- map $_->(\%params), @{$hub->{_context_aquire}} if $hub->{_context_aquire};
++ $_->(\%params) for @$ACQUIRE_CBS;
++ map $_->(\%params), @{$hub->{_context_acquire}} if $hub->{_context_acquire};
+
+ my $level = 1 + $params{level};
+ my ($pkg, $file, $line, $sub) = caller($level);
+@@ -772,7 +772,7 @@
+ }
+
+ Using this inside your test tool takes care of a lot of boilerplate for you. It
+-will ensure a context is aquired. It will capture and rethrow any exception. It
++will ensure a context is acquired. It will capture and rethrow any exception. It
+ will insure the context is released when you are done. It preserves the
+ subroutine call context (array, scalar, void).
+
+@@ -809,9 +809,9 @@
+ =back
+
+ This tool will hide a context for the provided block of code. This means any
+-tools run inside the block will get a completely new context if they aquire
++tools run inside the block will get a completely new context if they acquire
+ one. The new context will be inherited by tools nested below the one that
+-aquired it.
++acquired it.
+
+ This will normally hide the current context for the top hub. If you need to
+ hide the context for a different hub you can pass in the optional C<$hid>
+@@ -861,7 +861,7 @@
+ =item $BUFFERED
+
+ If this is true then the subtest will be buffered. In a buffered subtest the
+-child events are hidden from the formatter, the formatter will only recieve the
++child events are hidden from the formatter, the formatter will only receive the
+ final L<Test2:Event::Subtest> event. In an unbuffered subtest the formatter
+ will see all events as they happen, as well as the final one.
+
+@@ -950,37 +950,37 @@
+ means the callback will be run once, the first time a context is obtained.
+ If Test2 has already finished loading then the callback will be run immedietly.
+
+-=item test2_add_callback_context_aquire(sub { ... })
++=item test2_add_callback_context_acquire(sub { ... })
+
+-Add a callback that will be called every time someone tries to aquire a
++Add a callback that will be called every time someone tries to acquire a
+ context. This will be called on EVERY call to C<context()>. It gets a single
+ argument, a reference the the hash of parameters being used the construct the
+ context. This is your chance to change the parameters by directly altering the
+ hash.
+
+- test2_add_callback_context_aquire(sub {
++ test2_add_callback_context_acquire(sub {
+ my $params = shift;
+ $params->{level}++;
+ });
+
+ This is a very scary API function. Please do not use this unless you need to.
+-This is here for L<Test::Builder> and backwards compatability. This has you
++This is here for L<Test::Builder> and backwards compatibility. This has you
+ directly manipulate the hash instead of returning a new one for performance
+ reasons.
+
+ =item test2_add_callback_context_init(sub { ... })
+
+ Add a callback that will be called every time a new context is created. The
+-callback will recieve the newly created context as its only argument.
++callback will receive the newly created context as its only argument.
+
+ =item test2_add_callback_context_release(sub { ... })
+
+ Add a callback that will be called every time a context is released. The
+-callback will recieve the released context as its only argument.
++callback will receive the released context as its only argument.
+
+-=item @list = test2_list_context_aquire_callbacks()
++=item @list = test2_list_context_acquire_callbacks()
+
+-Return all the context aquire callback references.
++Return all the context acquire callback references.
+
+ =item @list = test2_list_context_init_callbacks()
+
+--- a/lib/Test2/API/Context.pm
++++ b/lib/Test2/API/Context.pm
+@@ -464,7 +464,7 @@
+ hooks. It will also restore C<$!>, C<$?>, and C<$@> to what they were when the
+ context was created.
+
+-B<Note:> If a context is aquired more than once an internal refcount is kept.
++B<Note:> If a context is acquired more than once an internal refcount is kept.
+ C<release()> decrements the ref count, none of the other actions of
+ C<release()> will occur unless the refcount hits 0. This means only the last
+ call to C<release()> will reset C<$?>, C<$!>, C<$@>,and run the cleanup tasks.
+--- a/lib/Test2/API/Instance.pm
++++ b/lib/Test2/API/Instance.pm
+@@ -27,7 +27,7 @@
+
+ exit_callbacks
+ post_load_callbacks
+- context_aquire_callbacks
++ context_acquire_callbacks
+ context_init_callbacks
+ context_release_callbacks
+ };
+@@ -78,7 +78,7 @@
+
+ $self->{+EXIT_CALLBACKS} = [];
+ $self->{+POST_LOAD_CALLBACKS} = [];
+- $self->{+CONTEXT_AQUIRE_CALLBACKS} = [];
++ $self->{+CONTEXT_ACQUIRE_CALLBACKS} = [];
+ $self->{+CONTEXT_INIT_CALLBACKS} = [];
+ $self->{+CONTEXT_RELEASE_CALLBACKS} = [];
+
+@@ -162,16 +162,16 @@
+ carp "Formatter $formatter loaded too late to be used as the global formatter";
+ }
+
+-sub add_context_aquire_callback {
++sub add_context_acquire_callback {
+ my $self = shift;
+ my ($code) = @_;
+
+ my $rtype = reftype($code) || "";
+
+- confess "Context-aquire callbacks must be coderefs"
++ confess "Context-acquire callbacks must be coderefs"
+ unless $code && $rtype eq 'CODE';
+
+- push @{$self->{+CONTEXT_AQUIRE_CALLBACKS}} => $code;
++ push @{$self->{+CONTEXT_ACQUIRE_CALLBACKS}} => $code;
+ }
+
+ sub add_context_init_callback {
+@@ -500,9 +500,9 @@
+
+ Get a hashref of all active contexts keyed by hub id.
+
+-=item $arrayref = $obj->context_aquire_callbacks
++=item $arrayref = $obj->context_acquire_callbacks
+
+-Get all context aquire callbacks.
++Get all context acquire callbacks.
+
+ =item $arrayref = $obj->context_init_callbacks
+
+@@ -574,7 +574,7 @@
+
+ Add an IPC driver to the list. The most recently added IPC driver will become
+ the global one during initialization. If a driver is added after initialization
+-has occured a warning will be generated:
++has occurred a warning will be generated:
+
+ "IPC driver $driver loaded too late to be used as the global ipc driver"
+
+@@ -635,7 +635,7 @@
+ =item $obj->add_formatter($obj)
+
+ Add a formatter. The most recently added formatter will become the global one
+-during initialization. If a formatter is added after initialization has occured
++during initialization. If a formatter is added after initialization has occurred
+ a warning will be generated:
+
+ "Formatter $formatter loaded too late to be used as the global formatter"
+--- a/lib/Test2/Hub.pm
++++ b/lib/Test2/Hub.pm
+@@ -16,7 +16,7 @@
+ _listeners
+ _follow_ups
+ _formatter
+- _context_aquire
++ _context_acquire
+ _context_init
+ _context_release
+
+@@ -180,22 +180,22 @@
+ push @{$self->{+_FOLLOW_UPS}} => $sub;
+ }
+
+-sub add_context_aquire {
++sub add_context_acquire {
+ my $self = shift;
+ my ($sub) = @_;
+
+- croak "add_context_aquire only takes coderefs for arguments, got '$sub'"
++ croak "add_context_acquire only takes coderefs for arguments, got '$sub'"
+ unless ref $sub && ref $sub eq 'CODE';
+
+- push @{$self->{+_CONTEXT_AQUIRE}} => $sub;
++ push @{$self->{+_CONTEXT_ACQUIRE}} => $sub;
+
+ $sub; # Intentional return.
+ }
+
+-sub remove_context_aquire {
++sub remove_context_acquire {
+ my $self = shift;
+ my %subs = map {$_ => $_} @_;
+- @{$self->{+_CONTEXT_AQUIRE}} = grep { !$subs{$_} == $_ } @{$self->{+_CONTEXT_AQUIRE}};
++ @{$self->{+_CONTEXT_ACQUIRE}} = grep { !$subs{$_} == $_ } @{$self->{+_CONTEXT_ACQUIRE}};
+ }
+
+ sub add_context_init {
+@@ -632,20 +632,20 @@
+ follow_up subs are called only once, ether when done_testing is called, or in
+ an END block.
+
+-=item $sub = $hub->add_context_aquire(sub { ... });
++=item $sub = $hub->add_context_acquire(sub { ... });
+
+-Add a callback that will be called every time someone tries to aquire a
++Add a callback that will be called every time someone tries to acquire a
+ context. It gets a single argument, a reference the the hash of parameters
+ being used the construct the context. This is your chance to change the
+ parameters by directly altering the hash.
+
+- test2_add_callback_context_aquire(sub {
++ test2_add_callback_context_acquire(sub {
+ my $params = shift;
+ $params->{level}++;
+ });
+
+ This is a very scary API function. Please do not use this unless you need to.
+-This is here for L<Test::Builder> and backwards compatability. This has you
++This is here for L<Test::Builder> and backwards compatibility. This has you
+ directly manipulate the hash instead of returning a new one for performance
+ reasons.
+
+@@ -653,9 +653,9 @@
+
+ The coderef you provide is returned and can be used to remove the hook later.
+
+-=item $hub->remove_context_aquire($sub);
++=item $hub->remove_context_acquire($sub);
+
+-This can be used to remove a context aquire hook.
++This can be used to remove a context acquire hook.
+
+ =item $sub = $hub->add_context_init(sub { ... });
+
+@@ -737,7 +737,7 @@
+ =item $bool = $hub->ended
+
+ True if the testing has ended. This MAY return the stack frame of the tool that
+-ended the test, but that is not guarenteed.
++ended the test, but that is not guaranteed.
+
+ =item $bool = $hub->is_passing
+
+--- a/lib/Test2/IPC/Driver.pm
++++ b/lib/Test2/IPC/Driver.pm
+@@ -250,7 +250,7 @@
+
+ =item $bites = $ipc->shm_size()
+
+-Use this to customize the size of the shm space. There are no guarentees about
++Use this to customize the size of the shm space. There are no guarantees about
+ what the size will be if you do not implement this.
+
+ =back
+--- a/lib/Test2/IPC/Driver/Files.pm
++++ b/lib/Test2/IPC/Driver/Files.pm
+@@ -303,7 +303,7 @@
+
+ This is the default, and fallback concurrency model for L<Test2>. This
+ sends events between processes and threads using serialized files in a
+-temporary directory. This is not particularily fast, but it works everywhere.
++temporary directory. This is not particularly fast, but it works everywhere.
+
+ =head1 SYNOPSIS
+
+--- a/lib/Test2/Util/HashBase.pm
++++ b/lib/Test2/Util/HashBase.pm
+@@ -210,7 +210,7 @@
+
+ =item FOO()
+
+-Constant, returs the field C<foo>'s key into the class hashref. Subclasses will
++Constant, returns the field C<foo>'s key into the class hashref. Subclasses will
+ also get this function as a constant, not simply a method, that means it is
+ copied into the subclass namespace.
+
+--- a/t/modules/API.t
++++ b/t/modules/API.t
+@@ -238,25 +238,25 @@
+
+ my $sub = sub { };
+
+-Test2::API::test2_add_callback_context_aquire($sub);
++Test2::API::test2_add_callback_context_acquire($sub);
+ Test2::API::test2_add_callback_context_init($sub);
+ Test2::API::test2_add_callback_context_release($sub);
+ Test2::API::test2_add_callback_exit($sub);
+ Test2::API::test2_add_callback_post_load($sub);
+
+-is((grep { $_ == $sub } Test2::API::test2_list_context_aquire_callbacks()), 1, "got the one instance of the hook");
++is((grep { $_ == $sub } Test2::API::test2_list_context_acquire_callbacks()), 1, "got the one instance of the hook");
+ is((grep { $_ == $sub } Test2::API::test2_list_context_init_callbacks()), 1, "got the one instance of the hook");
+ is((grep { $_ == $sub } Test2::API::test2_list_context_release_callbacks()), 1, "got the one instance of the hook");
+ is((grep { $_ == $sub } Test2::API::test2_list_exit_callbacks()), 1, "got the one instance of the hook");
+ is((grep { $_ == $sub } Test2::API::test2_list_post_load_callbacks()), 1, "got the one instance of the hook");
+
+-Test2::API::test2_add_callback_context_aquire($sub);
++Test2::API::test2_add_callback_context_acquire($sub);
+ Test2::API::test2_add_callback_context_init($sub);
+ Test2::API::test2_add_callback_context_release($sub);
+ Test2::API::test2_add_callback_exit($sub);
+ Test2::API::test2_add_callback_post_load($sub);
+
+-is((grep { $_ == $sub } Test2::API::test2_list_context_aquire_callbacks()), 2, "got the two instances of the hook");
++is((grep { $_ == $sub } Test2::API::test2_list_context_acquire_callbacks()), 2, "got the two instances of the hook");
+ is((grep { $_ == $sub } Test2::API::test2_list_context_init_callbacks()), 2, "got the two instances of the hook");
+ is((grep { $_ == $sub } Test2::API::test2_list_context_release_callbacks()), 2, "got the two instances of the hook");
+ is((grep { $_ == $sub } Test2::API::test2_list_exit_callbacks()), 2, "got the two instances of the hook");
+--- a/t/modules/API/Context.t
++++ b/t/modules/API/Context.t
+@@ -6,7 +6,7 @@
+ use Test2::API qw{
+ context intercept
+ test2_stack
+- test2_add_callback_context_aquire
++ test2_add_callback_context_acquire
+ test2_add_callback_context_init
+ test2_add_callback_context_release
+ };
+@@ -160,8 +160,8 @@
+ test2_add_callback_context_init(sub { die "Bad Arg" unless ref($_[0]) eq 'Test2::API::Context'; push @hooks => 'global_init' });
+ test2_add_callback_context_release(sub { die "Bad Arg" unless ref($_[0]) eq 'Test2::API::Context'; push @hooks => 'global_release' });
+
+-my $ref3 = $hub->add_context_aquire(sub { die "Bad Arg" unless ref($_[0]) eq 'HASH'; push @hooks => 'hub_aquire' });
+-test2_add_callback_context_aquire(sub { die "Bad Arg" unless ref($_[0]) eq 'HASH'; push @hooks => 'global_aquire' });
++my $ref3 = $hub->add_context_acquire(sub { die "Bad Arg" unless ref($_[0]) eq 'HASH'; push @hooks => 'hub_acquire' });
++test2_add_callback_context_acquire(sub { die "Bad Arg" unless ref($_[0]) eq 'HASH'; push @hooks => 'global_acquire' });
+
+ sub {
+ push @hooks => 'start';
+@@ -185,23 +185,23 @@
+
+ $hub->remove_context_init($ref1);
+ $hub->remove_context_release($ref2);
+-$hub->remove_context_aquire($ref3);
++$hub->remove_context_acquire($ref3);
+ @{Test2::API::_context_init_callbacks_ref()} = ();
+ @{Test2::API::_context_release_callbacks_ref()} = ();
+-@{Test2::API::_context_aquire_callbacks_ref()} = ();
++@{Test2::API::_context_acquire_callbacks_ref()} = ();
+
+ is_deeply(
+ \@hooks,
+ [qw{
+ start
+- global_aquire
+- hub_aquire
++ global_acquire
++ hub_acquire
+ global_init
+ hub_init
+ ctx_init
+ deep
+- global_aquire
+- hub_aquire
++ global_acquire
++ hub_acquire
+ release_deep
+ release_parent
+ ctx_release_deep
+@@ -210,8 +210,8 @@
+ global_release
+ released_all
+ new
+- global_aquire
+- hub_aquire
++ global_acquire
++ hub_acquire
+ global_init
+ hub_init
+ ctx_init2
+--- a/t/modules/API/Instance.t
++++ b/t/modules/API/Instance.t
+@@ -29,7 +29,7 @@
+
+ exit_callbacks => [],
+ post_load_callbacks => [],
+- context_aquire_callbacks => [],
++ context_acquire_callbacks => [],
+ context_init_callbacks => [],
+ context_release_callbacks => [],
+
+@@ -63,7 +63,7 @@
+
+ exit_callbacks => [],
+ post_load_callbacks => [],
+- context_aquire_callbacks => [],
++ context_acquire_callbacks => [],
+ context_init_callbacks => [],
+ context_release_callbacks => [],
+
+--- a/lib/Test2/Formatter/TAP.pm
++++ b/lib/Test2/Formatter/TAP.pm
+@@ -367,7 +367,7 @@
+
+ =head2 EVENT METHODS
+
+-All these methods require the event itself. Optinally they can all except a
++All these methods require the event itself. Optionally they can all except a
+ test number.
+
+ All methods return a list of array-refs. Each array-ref will have 2 items, the
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-perl/packages/libtest2-perl.git
More information about the Pkg-perl-cvs-commits
mailing list