From: Karen Etheridge <ether@cpan.org>
Date: Fri, 6 May 2011 18:15:06 +0000 (-0700)
Subject: fix all misuse of "it's"
X-Git-Tag: 2.0100~172
X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=69229b40b80c7f50529fed76629100ad29114045;p=gitmo%2FMoose.git

fix all misuse of "it's"
---

diff --git a/lib/Class/MOP.pm b/lib/Class/MOP.pm
index 7a0f721..6ee4ec3 100644
--- a/lib/Class/MOP.pm
+++ b/lib/Class/MOP.pm
@@ -1167,7 +1167,7 @@ As I have said above, this module is a class-builder-builder, so it is
 not the same thing as modules like L<Class::Accessor> and
 L<Class::MethodMaker>. That being said there are very few modules on CPAN
 with similar goals to this module. The one I have found which is most
-like this module is L<Class::Meta>, although it's philosophy and the MOP it
+like this module is L<Class::Meta>, although its philosophy and the MOP it
 creates are very different from this modules.
 
 =head1 BUGS
diff --git a/lib/Moose/Spec/Role.pod b/lib/Moose/Spec/Role.pod
index 2327440..3862745 100644
--- a/lib/Moose/Spec/Role.pod
+++ b/lib/Moose/Spec/Role.pod
@@ -56,7 +56,7 @@ a subtype of an ArrayRef.
 =item Overridden Methods
 
 The C<override> and C<super> keywords are allowed in roles, but
-their behavior is different from that of it's class counterparts.
+their behavior is different from that of its class counterparts.
 The C<super> in a class refers directly to that class's superclass,
 while the C<super> in a role is deferred and only has meaning once
 the role is composed into a class. Once that composition occurs,
@@ -283,7 +283,7 @@ time using the I<excludes> option.
     sub bar { ... }
 
 By specifically excluding the C<foo> method during composition,
-we allow B<Role::FooBar> to define it's own version of C<foo>.
+we allow B<Role::FooBar> to define its own version of C<foo>.
 
 =back
 
diff --git a/lib/Moose/Util/TypeConstraints.pm b/lib/Moose/Util/TypeConstraints.pm
index 375e5f4..103ee54 100644
--- a/lib/Moose/Util/TypeConstraints.pm
+++ b/lib/Moose/Util/TypeConstraints.pm
@@ -414,7 +414,7 @@ sub coerce {
 #
 # subtype( 'Foo', as( 'Str', where { ... } ) );
 #
-# If as() returns all it's extra arguments, this just works, and
+# If as() returns all its extra arguments, this just works, and
 # preserves backwards compatibility.
 sub as { { as => shift }, @_ }
 sub where (&)       { { where       => $_[0] } }
@@ -1009,7 +1009,7 @@ I<My::Graphics::Types::Color> instead.
 
 This module can play nicely with other constraint modules with some
 slight tweaking. The C<where> clause in types is expected to be a
-C<CODE> reference which checks it's first argument and returns a
+C<CODE> reference which checks its first argument and returns a
 boolean. Since most constraint modules work in a similar way, it
 should be simple to adapt them to work with Moose.
 
@@ -1027,7 +1027,7 @@ L<Declare::Constraints::Simple> to declare a completely new type.
 For more examples see the F<t/examples/example_w_DCS.t> test
 file.
 
-Here is an example of using L<Test::Deep> and it's non-test
+Here is an example of using L<Test::Deep> and its non-test
 related C<eq_deeply> function.
 
   type 'ArrayOfHashOfBarsAndRandomNumbers',
diff --git a/t/basics/moose_respects_type_constraints.t b/t/basics/moose_respects_type_constraints.t
index 3485a00..79eb869 100644
--- a/t/basics/moose_respects_type_constraints.t
+++ b/t/basics/moose_respects_type_constraints.t
@@ -15,7 +15,7 @@ a preexisting type constraint of the same name when
 making constraints for a Moose-class.
 
 It also tests that an attribute which uses a 'Foo' for
-it's isa option will get the subtype Foo, and not a
+its isa option will get the subtype Foo, and not a
 type representing the Foo moose class.
 
 =cut
diff --git a/t/examples/example_Protomoose.t b/t/examples/example_Protomoose.t
index 09a82aa..dd98da9 100644
--- a/t/examples/example_Protomoose.t
+++ b/t/examples/example_Protomoose.t
@@ -252,10 +252,10 @@ is(Foo->bar, 100, '... got the value stored in the prototype (through the Foo cl
 
 # now we can check that the subclass
 # will seek out the correct prototypical
-# value from it's "parent"
+# value from its "parent"
 is(Bar->bar, 100, '... got the value stored in the Foo prototype (through the Bar class)');
 
-# we can then also set it's local attrs
+# we can then also set its local attrs
 Bar->baz(50);
 is(Bar->baz, 50, '... got the value stored in the prototype (through the Bar class)');