lucy-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mar...@apache.org
Subject svn commit: r887915 [2/2] - in /lucene/lucy/trunk/clownfish: lib/ lib/Clownfish/ lib/Clownfish/Binding/ lib/Clownfish/Binding/Core/ lib/Clownfish/Binding/Perl/ lib/Clownfish/Type/ t/
Date Mon, 07 Dec 2009 12:58:07 GMT
Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Integer.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Integer.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Integer.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Integer.pm Mon Dec  7 12:58:04 2009
@@ -1,9 +1,9 @@
 use strict;
 use warnings;
 
-package Boilerplater::Type::Integer;
-use base qw( Boilerplater::Type::Primitive );
-use Boilerplater::Util qw( verify_args );
+package Clownfish::Type::Integer;
+use base qw( Clownfish::Type::Primitive );
+use Clownfish::Util qw( verify_args );
 use Carp;
 use Config;
 
@@ -58,11 +58,11 @@
 
 =head1 NAME
 
-Boilerplater::Type::Integer - A primitive Type representing an integer.
+Clownfish::Type::Integer - A primitive Type representing an integer.
 
 =head1 DESCRIPTION
 
-Boilerplater::Type::Integer holds integer types of various widths and various
+Clownfish::Type::Integer holds integer types of various widths and various
 styles.  A few standard C integer types are supported:
 
     char
@@ -90,7 +90,7 @@
 
 =head2 new
 
-    my $type = Boilerplater::Type::Integer->new(
+    my $type = Clownfish::Type::Integer->new(
         const     => 1,       # default: undef
         specifier => 'char',  # required
     );

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Object.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Object.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Object.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Object.pm Mon Dec  7 12:58:04 2009
@@ -1,10 +1,10 @@
 use strict;
 use warnings;
 
-package Boilerplater::Type::Object;
-use base qw( Boilerplater::Type );
-use Boilerplater::Parcel;
-use Boilerplater::Util qw( verify_args );
+package Clownfish::Type::Object;
+use base qw( Clownfish::Type );
+use Clownfish::Parcel;
+use Clownfish::Util qw( verify_args );
 use Scalar::Util qw( blessed );
 use Carp;
 
@@ -28,7 +28,7 @@
     $self->{incremented} = $incremented;
     $self->{decremented} = $decremented;
     $self->{indirection} = $indirection;
-    $self->{parcel} ||= Boilerplater::Parcel->default_parcel;
+    $self->{parcel} ||= Clownfish::Parcel->default_parcel;
     my $prefix = $self->{parcel}->get_prefix;
 
     # Validate params.
@@ -76,11 +76,11 @@
 
 =head1 NAME
 
-Boilerplater::Type::Boilerplater - An object Type.
+Clownfish::Type::Clownfish - An object Type.
 
 =head1 DESCRIPTION
 
-Boilerplater::Type::Object supports object types for all classes.  The type's 
+Clownfish::Type::Object supports object types for all classes.  The type's 
 C<specifier> must match the last component of the class name -- i.e. for the
 class "Crustacean::Lobster" it must be "Lobster".
 
@@ -88,7 +88,7 @@
 
 =head2 new
 
-    my $type = Boilerplater::Type::Object->new(
+    my $type = Clownfish::Type::Object->new(
         specifier   => "Obj",     # required
         parcel      => "Boil",    # default: the default Parcel.
         const       => undef,     # default undef
@@ -100,9 +100,9 @@
 =over
 
 =item * B<specifier> - Required.  Must follow the rules for
-L<Boilerplater::Class> class name components.
+L<Clownfish::Class> class name components.
 
-=item * B<parcel> - A L<Boilerplater::Parcel> or a parcel name.
+=item * B<parcel> - A L<Clownfish::Parcel> or a parcel name.
 
 =item * B<const> - Should be true if the Type is const.  Note that this refers
 to the object itself and not the pointer.

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Primitive.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Primitive.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Primitive.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Primitive.pm Mon Dec  7 12:58:04 2009
@@ -1,9 +1,9 @@
 use strict;
 use warnings;
 
-package Boilerplater::Type::Primitive;
-use base qw( Boilerplater::Type );
-use Boilerplater::Util qw( verify_args );
+package Clownfish::Type::Primitive;
+use base qw( Clownfish::Type );
+use Clownfish::Util qw( verify_args );
 use Scalar::Util qw( blessed );
 use Carp;
 
@@ -40,13 +40,13 @@
 
 =head1 NAME
 
-Boilerplater::Type::Primitive - Abstract base class for primitive types.
+Clownfish::Type::Primitive - Abstract base class for primitive types.
 
 =head1 DESCRIPTION
 
-Boilerplater::Type::Primitive serves as a common parent class for primitive
-types including L<Boilerplater::Type::Integer> and
-L<Boilerplater::Type::Float>.
+Clownfish::Type::Primitive serves as a common parent class for primitive
+types including L<Clownfish::Type::Integer> and
+L<Clownfish::Type::Float>.
 
 =head1 METHODS
 
@@ -58,7 +58,7 @@
         c_string  => 'char',  # default: undef
     );
 
-Abstract constructor.  See L<Boilerplater::Type> for parameter definitions.
+Abstract constructor.  See L<Clownfish::Type> for parameter definitions.
 
 =head1 COPYRIGHT AND LICENSE
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Type/VAList.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Type/VAList.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Type/VAList.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Type/VAList.pm Mon Dec  7 12:58:04 2009
@@ -1,9 +1,9 @@
 use strict;
 use warnings;
 
-package Boilerplater::Type::VAList;
-use base qw( Boilerplater::Type );
-use Boilerplater::Util qw( verify_args );
+package Clownfish::Type::VAList;
+use base qw( Clownfish::Type );
+use Clownfish::Util qw( verify_args );
 use Scalar::Util qw( blessed );
 use Carp;
 
@@ -34,17 +34,17 @@
 
 =head1 NAME
 
-Boilerplater::Type::VAList - A Type to support C's va_list.
+Clownfish::Type::VAList - A Type to support C's va_list.
 
 =head1 DESCRIPTION
 
-Boilerplater::Type::VAList represents the C va_list type, from stdarg.h.
+Clownfish::Type::VAList represents the C va_list type, from stdarg.h.
 
 =head1 METHODS
 
 =head2 new
 
-    my $type = Boilerplater::Type::VAList->new(
+    my $type = Clownfish::Type::VAList->new(
         specifier => 'va_list',    # default: va_list
     );
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Void.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Void.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Void.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Void.pm Mon Dec  7 12:58:04 2009
@@ -1,9 +1,9 @@
 use strict;
 use warnings;
 
-package Boilerplater::Type::Void;
-use base qw( Boilerplater::Type );
-use Boilerplater::Util qw( verify_args );
+package Clownfish::Type::Void;
+use base qw( Clownfish::Type );
+use Clownfish::Util qw( verify_args );
 use Scalar::Util qw( blessed );
 use Carp;
 
@@ -39,19 +39,19 @@
 
 =head1 NAME
 
-Boilerplater::Type::Void - The void Type.
+Clownfish::Type::Void - The void Type.
 
 =head1 DESCRIPTION
 
-Boilerplater::Type::Void is used to represent a void return type.  It is also
-used in conjuction with with L<Boilerplater::Type::Composite> to support the
+Clownfish::Type::Void is used to represent a void return type.  It is also
+used in conjuction with with L<Clownfish::Type::Composite> to support the
 C<void*> opaque pointer type.
 
 =head1 METHODS
 
 =head2 new
 
-    my $type = Boilerplater::Type::Void->new(
+    my $type = Clownfish::Type::Void->new(
         specifier => 'void',    # default: void
         const     => 1,         # default: undef
     );

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Util.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Util.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Util.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Util.pm Mon Dec  7 12:58:04 2009
@@ -1,7 +1,7 @@
 use strict;
 use warnings;
 
-package Boilerplater::Util;
+package Clownfish::Util;
 use base qw( Exporter );
 use Scalar::Util qw( blessed );
 use Carp;
@@ -107,12 +107,12 @@
 
 =head1 NAME
 
-Boilerplater::Util - Miscellaneous helper functions.
+Clownfish::Util - Miscellaneous helper functions.
 
 =head1 DESCRIPTION
 
-Boilerplater::Util provides a few convenience functions used internally by
-other Boilerplater modules.
+Clownfish::Util provides a few convenience functions used internally by
+other Clownfish modules.
 
 =head1 FUNCTIONS
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Variable.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Variable.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Variable.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Variable.pm Mon Dec  7 12:58:04 2009
@@ -1,10 +1,10 @@
 use strict;
 use warnings;
 
-package Boilerplater::Variable;
-use base qw( Boilerplater::Symbol );
-use Boilerplater::Type;
-use Boilerplater::Util qw( verify_args a_isa_b );
+package Clownfish::Variable;
+use base qw( Clownfish::Symbol );
+use Clownfish::Type;
+use Clownfish::Util qw( verify_args a_isa_b );
 use Carp;
 
 our %new_PARAMS = (
@@ -21,7 +21,7 @@
     verify_args( \%new_PARAMS, @_ ) or confess $@;
     my $self = $either->SUPER::new( %new_PARAMS, @_ );
     confess "invalid type"
-        unless a_isa_b( $self->{type}, "Boilerplater::Type" );
+        unless a_isa_b( $self->{type}, "Clownfish::Type" );
     return $self;
 }
 
@@ -65,11 +65,11 @@
 
 =head1 NAME
 
-Boilerplater::Variable - A Boilerplater variable.
+Clownfish::Variable - A Clownfish variable.
 
 =head1 DESCRIPTION
 
-A variable, having a L<Type|Boilerplater::Type>, a micro_sym (i.e. name), an
+A variable, having a L<Type|Clownfish::Type>, a micro_sym (i.e. name), an
 exposure, and optionally, a location in the global namespace hierarchy.
 
 Variable objects which exist only within a local scope, e.g. those within
@@ -81,7 +81,7 @@
 
 =head2 new
 
-    my $var = Boilerplater::Variable->new(
+    my $var = Clownfish::Variable->new(
         parcel      => 'Boil',
         type        => $type,    # required
         micro_sym   => 'foo',    # required
@@ -92,15 +92,15 @@
 
 =over
 
-=item * B<type> - A L<Boilerplater::Type>.
+=item * B<type> - A L<Clownfish::Type>.
 
 =item * B<micro_sym> - The variable's name, without any namespacing prefixes.
 
-=item * B<exposure> - See L<Boilerplater::Symbol>.
+=item * B<exposure> - See L<Clownfish::Symbol>.
 
-=item * B<class_name> - See L<Boilerplater::Symbol>.
+=item * B<class_name> - See L<Clownfish::Symbol>.
 
-=item * B<class_cnick> - See L<Boilerplater::Symbol>.
+=item * B<class_cnick> - See L<Clownfish::Symbol>.
 
 =back
 

Modified: lucene/lucy/trunk/clownfish/t/000-load.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/000-load.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/000-load.t (original)
+++ lucene/lucy/trunk/clownfish/t/000-load.t Mon Dec  7 12:58:04 2009
@@ -16,7 +16,7 @@
     'lib'
 );
 for (@modules) {
-    s/^.*?Boilerplater/Boilerplater/;
+    s/^.*?Clownfish/Clownfish/;
     s/\.pm$//;
     s/\W+/::/g;
     use_ok($_);

Modified: lucene/lucy/trunk/clownfish/t/001-util.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/001-util.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/001-util.t (original)
+++ lucene/lucy/trunk/clownfish/t/001-util.t Mon Dec  7 12:58:04 2009
@@ -3,7 +3,7 @@
 
 use Test::More tests => 16;
 use File::stat qw( stat );
-use Boilerplater::Util qw(
+use Clownfish::Util qw(
     slurp_file
     current
     verify_args

Modified: lucene/lucy/trunk/clownfish/t/050-docucomment.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/050-docucomment.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/050-docucomment.t (original)
+++ lucene/lucy/trunk/clownfish/t/050-docucomment.t Mon Dec  7 12:58:04 2009
@@ -3,11 +3,11 @@
 
 use Test::More tests => 10;
 
-BEGIN { use_ok('Boilerplater::DocuComment') }
-use Boilerplater::Parser;
+BEGIN { use_ok('Clownfish::DocuComment') }
+use Clownfish::Parser;
 
-my $parser = Boilerplater::Parser->new;
-isa_ok( $parser->docucomment('/** foo. */'), "Boilerplater::DocuComment" );
+my $parser = Clownfish::Parser->new;
+isa_ok( $parser->docucomment('/** foo. */'), "Clownfish::DocuComment" );
 
 my $text = <<'END_COMMENT';
 /** 
@@ -23,7 +23,7 @@
  */
 END_COMMENT
 
-my $docucomment = Boilerplater::DocuComment->parse($text);
+my $docucomment = Clownfish::DocuComment->parse($text);
 
 like(
     $docucomment->get_description,

Modified: lucene/lucy/trunk/clownfish/t/051-symbol.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/051-symbol.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/051-symbol.t (original)
+++ lucene/lucy/trunk/clownfish/t/051-symbol.t Mon Dec  7 12:58:04 2009
@@ -2,7 +2,7 @@
 use warnings;
 
 package BoilingThing;
-use base qw( Boilerplater::Symbol );
+use base qw( Clownfish::Symbol );
 
 sub new {
     return shift->SUPER::new( micro_sym => 'sym', exposure => 'parcel', @_ );
@@ -39,7 +39,7 @@
     "different exposure spoils equals"
 );
 
-my $lucifer_parcel = Boilerplater::Parcel->singleton( name => 'Lucifer' );
+my $lucifer_parcel = Clownfish::Parcel->singleton( name => 'Lucifer' );
 my $lucifer = BoilingThing->new( parcel => 'Lucifer' );
 ok( $lucifer_parcel == $lucifer->get_parcel, "derive parcel" );
 is( $lucifer->get_prefix, "lucifer_", "get_prefix" );

Modified: lucene/lucy/trunk/clownfish/t/100-type.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/100-type.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/100-type.t (original)
+++ lucene/lucy/trunk/clownfish/t/100-type.t Mon Dec  7 12:58:04 2009
@@ -2,13 +2,13 @@
 use warnings;
 
 package MyType;
-use base qw( Boilerplater::Type );
+use base qw( Clownfish::Type );
 
 package main;
 use Test::More tests => 12;
-use Boilerplater::Parcel;
+use Clownfish::Parcel;
 
-my $boil_parcel = Boilerplater::Parcel->singleton( name => 'Boil' );
+my $boil_parcel = Clownfish::Parcel->singleton( name => 'Boil' );
 
 my $type = MyType->new( parcel => 'Boil', specifier => 'mytype_t' );
 is( $type->get_parcel, $boil_parcel,

Modified: lucene/lucy/trunk/clownfish/t/101-primitive_type.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/101-primitive_type.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/101-primitive_type.t (original)
+++ lucene/lucy/trunk/clownfish/t/101-primitive_type.t Mon Dec  7 12:58:04 2009
@@ -2,7 +2,7 @@
 use warnings;
 
 package MyPrimitiveType;
-use base qw( Boilerplater::Type::Primitive );
+use base qw( Clownfish::Type::Primitive );
 
 package main;
 use Test::More tests => 4;

Modified: lucene/lucy/trunk/clownfish/t/102-integer_type.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/102-integer_type.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/102-integer_type.t (original)
+++ lucene/lucy/trunk/clownfish/t/102-integer_type.t Mon Dec  7 12:58:04 2009
@@ -2,10 +2,10 @@
 use warnings;
 
 use Test::More tests => 60;
-use Boilerplater::Type::Integer;
-use Boilerplater::Parser;
+use Clownfish::Type::Integer;
+use Clownfish::Parser;
 
-my $integer_type = Boilerplater::Type::Integer->new(
+my $integer_type = Clownfish::Type::Integer->new(
     specifier => 'i32_t',
     const     => 1,
 );
@@ -15,7 +15,7 @@
     "prepend 'chy_' for C representation" );
 like( $integer_type->to_c, qr/const/, "'const' in C representation" );
 
-my $parser = Boilerplater::Parser->new;
+my $parser = Clownfish::Parser->new;
 
 my @chy_specifiers = qw(
     bool_t
@@ -40,9 +40,9 @@
     is( $parser->chy_integer_specifier($chy_specifier),
         $chy_specifier, "chy_integer_specifier: $chy_specifier" );
     isa_ok( $parser->chy_integer_type($chy_specifier),
-        "Boilerplater::Type::Integer" );
+        "Clownfish::Type::Integer" );
     isa_ok( $parser->chy_integer_type("const $chy_specifier"),
-        "Boilerplater::Type::Integer" );
+        "Clownfish::Type::Integer" );
     my $bogus = $chy_specifier . "oot_toot";
     ok( !$parser->chy_integer_specifier($bogus),
         "chy_integer_specifier guards against partial word matches" );
@@ -53,10 +53,10 @@
         $c_specifier, "c_integer_specifier: $c_specifier" );
     isa_ok(
         $parser->c_integer_type($c_specifier),
-        "Boilerplater::Type::Integer"
+        "Clownfish::Type::Integer"
     );
     isa_ok( $parser->c_integer_type("const $c_specifier"),
-        "Boilerplater::Type::Integer" );
+        "Clownfish::Type::Integer" );
     my $bogus = $c_specifier . "y";
     ok( !$parser->c_integer_specifier($bogus),
         "c_integer_specifier guards against partial word matches" );

Modified: lucene/lucy/trunk/clownfish/t/103-float_type.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/103-float_type.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/103-float_type.t (original)
+++ lucene/lucy/trunk/clownfish/t/103-float_type.t Mon Dec  7 12:58:04 2009
@@ -2,10 +2,10 @@
 use warnings;
 
 use Test::More tests => 11;
-use Boilerplater::Type::Float;
-use Boilerplater::Parser;
+use Clownfish::Type::Float;
+use Clownfish::Parser;
 
-my $float_type = Boilerplater::Type::Float->new(
+my $float_type = Clownfish::Type::Float->new(
     specifier => 'float',
     const     => 1,
 );
@@ -13,14 +13,14 @@
 is( $float_type->get_specifier, "float" );
 like( $float_type->to_c, qr/const/, "'const' in C representation" );
 
-my $parser = Boilerplater::Parser->new;
+my $parser = Clownfish::Parser->new;
 
 for my $specifier (qw( float double)) {
     is( $parser->c_float_specifier($specifier),
         $specifier, "c_float_specifier: $specifier" );
-    isa_ok( $parser->float_type($specifier), "Boilerplater::Type::Float" );
+    isa_ok( $parser->float_type($specifier), "Clownfish::Type::Float" );
     isa_ok( $parser->float_type("const $specifier"),
-        "Boilerplater::Type::Float" );
+        "Clownfish::Type::Float" );
     my $bogus = $specifier . "y";
     ok( !$parser->c_float_specifier($bogus),
         "c_float_specifier guards against partial word matches" );

Modified: lucene/lucy/trunk/clownfish/t/104-void_type.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/104-void_type.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/104-void_type.t (original)
+++ lucene/lucy/trunk/clownfish/t/104-void_type.t Mon Dec  7 12:58:04 2009
@@ -2,26 +2,26 @@
 use warnings;
 
 use Test::More tests => 9;
-use Boilerplater::Type::Void;
-use Boilerplater::Parser;
+use Clownfish::Type::Void;
+use Clownfish::Parser;
 
-my $void_type = Boilerplater::Type::Void->new;
+my $void_type = Clownfish::Type::Void->new;
 is( $void_type->get_specifier, "void", "specifier defaults to 'void'" );
 is( $void_type->to_c,          "void", "to_c" );
 ok( $void_type->is_void, "is_void" );
 
-$void_type = Boilerplater::Type::Void->new(
+$void_type = Clownfish::Type::Void->new(
     specifier => 'void',
     const     => 1,
 );
 ok( $void_type->const, "const" );
 like( $void_type->to_c, qr/const/, "'const' in C representation" );
 
-my $parser = Boilerplater::Parser->new;
+my $parser = Clownfish::Parser->new;
 
 is( $parser->void_type_specifier('void'), 'void', 'void_type_specifier' );
-isa_ok( $parser->void_type('void'),       "Boilerplater::Type::Void" );
-isa_ok( $parser->void_type('const void'), "Boilerplater::Type::Void" );
+isa_ok( $parser->void_type('void'),       "Clownfish::Type::Void" );
+isa_ok( $parser->void_type('const void'), "Clownfish::Type::Void" );
 ok( !$parser->void_type_specifier('voidable'),
     "void_type_specifier guards against partial word matches" );
 

Modified: lucene/lucy/trunk/clownfish/t/105-object_type.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/105-object_type.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/105-object_type.t (original)
+++ lucene/lucy/trunk/clownfish/t/105-object_type.t Mon Dec  7 12:58:04 2009
@@ -2,10 +2,10 @@
 use warnings;
 
 use Test::More tests => 49;
-use Boilerplater::Type::Object;
-use Boilerplater::Parser;
+use Clownfish::Type::Object;
+use Clownfish::Parser;
 
-my $parser = Boilerplater::Parser->new;
+my $parser = Clownfish::Parser->new;
 
 # Set and leave parcel.
 my $parcel = $parser->parcel_definition('parcel Boil;')
@@ -16,7 +16,7 @@
         "reject bad object_type_specifier $bad_specifier"
     );
     eval {
-        my $type = Boilerplater::Type::Object->new(
+        my $type = Clownfish::Type::Object->new(
             parcel    => 'Boil',
             specifier => $bad_specifier,
         );
@@ -29,21 +29,21 @@
     is( $parser->object_type_specifier($specifier),
         $specifier, "object_type_specifier: $specifier" );
     isa_ok( $parser->object_type("$specifier*"),
-        "Boilerplater::Type::Object", "$specifier*" );
+        "Clownfish::Type::Object", "$specifier*" );
     isa_ok( $parser->object_type("const $specifier*"),
-        "Boilerplater::Type::Object", "const $specifier*" );
+        "Clownfish::Type::Object", "const $specifier*" );
     isa_ok( $parser->object_type("incremented $specifier*"),
-        "Boilerplater::Type::Object", "incremented $specifier*" );
+        "Clownfish::Type::Object", "incremented $specifier*" );
     isa_ok( $parser->object_type("decremented $specifier*"),
-        "Boilerplater::Type::Object", "decremented $specifier*" );
+        "Clownfish::Type::Object", "decremented $specifier*" );
 }
 
-eval { my $type = Boilerplater::Type::Object->new };
+eval { my $type = Clownfish::Type::Object->new };
 like( $@, qr/specifier/i, "specifier required" );
 
 for ( 0, 2 ) {
     eval {
-        my $type = Boilerplater::Type::Object->new(
+        my $type = Clownfish::Type::Object->new(
             specifier   => 'Foo',
             indirection => $_,
         );
@@ -51,14 +51,14 @@
     like( $@, qr/indirection/i, "invalid indirection of $_" );
 }
 
-my $foo_type    = Boilerplater::Type::Object->new( specifier => 'Foo' );
-my $another_foo = Boilerplater::Type::Object->new( specifier => 'Foo' );
+my $foo_type    = Clownfish::Type::Object->new( specifier => 'Foo' );
+my $another_foo = Clownfish::Type::Object->new( specifier => 'Foo' );
 ok( $foo_type->equals($another_foo), "equals" );
 
-my $bar_type = Boilerplater::Type::Object->new( specifier => 'Bar' );
+my $bar_type = Clownfish::Type::Object->new( specifier => 'Bar' );
 ok( !$foo_type->equals($bar_type), "different specifier spoils equals" );
 
-my $foreign_foo = Boilerplater::Type::Object->new(
+my $foreign_foo = Clownfish::Type::Object->new(
     specifier => 'Foo',
     parcel    => 'Foreign',
 );
@@ -66,7 +66,7 @@
 is( $foreign_foo->get_specifier, "foreign_Foo",
     "prepend parcel prefix to specifier" );
 
-my $incremented_foo = Boilerplater::Type::Object->new(
+my $incremented_foo = Clownfish::Type::Object->new(
     specifier   => 'Foo',
     incremented => 1,
 );
@@ -76,7 +76,7 @@
     "different incremented spoils equals"
 );
 
-my $decremented_foo = Boilerplater::Type::Object->new(
+my $decremented_foo = Clownfish::Type::Object->new(
     specifier   => 'Foo',
     decremented => 1,
 );
@@ -86,14 +86,14 @@
     "different decremented spoils equals"
 );
 
-my $const_foo = Boilerplater::Type::Object->new(
+my $const_foo = Clownfish::Type::Object->new(
     specifier => 'Foo',
     const     => 1,
 );
 ok( !$foo_type->equals($const_foo), "different const spoils equals" );
 like( $const_foo->to_c, qr/const/, "const included in C representation" );
 
-my $string_type = Boilerplater::Type::Object->new( specifier => 'CharBuf', );
+my $string_type = Clownfish::Type::Object->new( specifier => 'CharBuf', );
 ok( !$foo_type->is_string_type,   "Not is_string_type" );
 ok( $string_type->is_string_type, "is_string_type" );
 

Modified: lucene/lucy/trunk/clownfish/t/106-va_list_type.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/106-va_list_type.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/106-va_list_type.t (original)
+++ lucene/lucy/trunk/clownfish/t/106-va_list_type.t Mon Dec  7 12:58:04 2009
@@ -2,19 +2,19 @@
 use warnings;
 
 use Test::More tests => 5;
-use Boilerplater::Type::VAList;
-use Boilerplater::Parser;
+use Clownfish::Type::VAList;
+use Clownfish::Parser;
 
-my $va_list_type = Boilerplater::Type::VAList->new;
+my $va_list_type = Clownfish::Type::VAList->new;
 is( $va_list_type->get_specifier,
     "va_list", "specifier defaults to 'va_list'" );
 is( $va_list_type->to_c, "va_list", "to_c" );
 
-my $parser = Boilerplater::Parser->new;
+my $parser = Clownfish::Parser->new;
 
 is( $parser->va_list_type_specifier('va_list'),
     'va_list', 'va_list_type_specifier' );
-isa_ok( $parser->va_list_type('va_list'), "Boilerplater::Type::VAList" );
+isa_ok( $parser->va_list_type('va_list'), "Clownfish::Type::VAList" );
 ok( !$parser->va_list_type_specifier('va_listable'),
     "va_list_type_specifier guards against partial word matches"
 );

Modified: lucene/lucy/trunk/clownfish/t/107-arbitrary_type.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/107-arbitrary_type.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/107-arbitrary_type.t (original)
+++ lucene/lucy/trunk/clownfish/t/107-arbitrary_type.t Mon Dec  7 12:58:04 2009
@@ -2,17 +2,17 @@
 use warnings;
 
 use Test::More tests => 12;
-use Boilerplater::Type::Arbitrary;
-use Boilerplater::Parser;
+use Clownfish::Type::Arbitrary;
+use Clownfish::Parser;
 
-my $foo_type = Boilerplater::Type::Arbitrary->new(
+my $foo_type = Clownfish::Type::Arbitrary->new(
     parcel    => 'Boil',
     specifier => "foo_t",
 );
 is( $foo_type->get_specifier, "foo_t", "get_specifier" );
 is( $foo_type->to_c,          "foo_t", "to_c" );
 
-my $compare_t_type = Boilerplater::Type::Arbitrary->new(
+my $compare_t_type = Clownfish::Type::Arbitrary->new(
     parcel    => 'Boil',
     specifier => "Sort_compare_t",
 );
@@ -20,7 +20,7 @@
     "boil_Sort_compare_t", "Prepend prefix to specifier" );
 is( $compare_t_type->to_c, "boil_Sort_compare_t", "to_c" );
 
-my $evil_twin = Boilerplater::Type::Arbitrary->new(
+my $evil_twin = Clownfish::Type::Arbitrary->new(
     parcel    => 'Boil',
     specifier => "foo_t",
 );
@@ -29,14 +29,14 @@
     "equals spoiled by different specifier"
 );
 
-my $parser = Boilerplater::Parser->new;
+my $parser = Clownfish::Parser->new;
 
 for my $specifier (qw( foo_t Sort_compare_t )) {
     is( $parser->arbitrary_type_specifier($specifier),
         $specifier, 'arbitrary_type_specifier' );
     isa_ok(
         $parser->arbitrary_type($specifier),
-        "Boilerplater::Type::Arbitrary"
+        "Clownfish::Type::Arbitrary"
     );
     ok( !$parser->arbitrary_type_specifier( $specifier . "_y_p_e" ),
         "arbitrary_type_specifier guards against partial word matches"

Modified: lucene/lucy/trunk/clownfish/t/108-composite_type.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/108-composite_type.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/108-composite_type.t (original)
+++ lucene/lucy/trunk/clownfish/t/108-composite_type.t Mon Dec  7 12:58:04 2009
@@ -2,10 +2,10 @@
 use warnings;
 
 use Test::More tests => 24;
-use Boilerplater::Type::Object;
-use Boilerplater::Parser;
+use Clownfish::Type::Object;
+use Clownfish::Parser;
 
-my $parser = Boilerplater::Parser->new;
+my $parser = Clownfish::Parser->new;
 
 is( $parser->type_postfix($_), $_, "postfix: $_" )
     for ( '[]', '[A_CONSTANT]', '*' );
@@ -29,29 +29,29 @@
 
 for my $input (@composite_type_strings) {
     isa_ok( $parser->type($input),
-        "Boilerplater::Type::Composite", $input );
+        "Clownfish::Type::Composite", $input );
 }
 
-eval { my $type = Boilerplater::Type::Composite->new };
+eval { my $type = Clownfish::Type::Composite->new };
 like( $@, qr/child/i, "child required" );
 
-my $foo_type = Boilerplater::Type::Object->new( specifier => 'Foo' );
-my $composite_type = Boilerplater::Type::Composite->new(
+my $foo_type = Clownfish::Type::Object->new( specifier => 'Foo' );
+my $composite_type = Clownfish::Type::Composite->new(
     child       => $foo_type,
     indirection => 1,
 );
 is( $composite_type->get_specifier,
     'Foo', "get_specifier delegates to child" );
 
-my $other = Boilerplater::Type::Composite->new(
+my $other = Clownfish::Type::Composite->new(
     child       => $foo_type,
     indirection => 1,
 );
 ok( $composite_type->equals($other), "equals" );
 ok( $composite_type->is_composite,   "is_composite" );
 
-my $bar_type = Boilerplater::Type::Object->new( specifier => 'Bar' );
-my $bar_composite = Boilerplater::Type::Composite->new(
+my $bar_type = Clownfish::Type::Object->new( specifier => 'Bar' );
+my $bar_composite = Clownfish::Type::Composite->new(
     child       => $bar_type,
     indirection => 1,
 );

Modified: lucene/lucy/trunk/clownfish/t/200-function.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/200-function.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/200-function.t (original)
+++ lucene/lucy/trunk/clownfish/t/200-function.t Mon Dec  7 12:58:04 2009
@@ -3,11 +3,11 @@
 
 use Test::More tests => 6;
 
-BEGIN { use_ok('Boilerplater::Function') }
-use Boilerplater::Parser;
-use Boilerplater::Parcel;
+BEGIN { use_ok('Clownfish::Function') }
+use Clownfish::Parser;
+use Clownfish::Parcel;
 
-my $parser = Boilerplater::Parser->new;
+my $parser = Clownfish::Parser->new;
 $parser->parcel_definition('parcel Boil;')
     or die "failed to process parcel_definition";
 
@@ -20,13 +20,13 @@
     micro_sym   => 'return_an_obj',
 );
 
-my $func = Boilerplater::Function->new(%args);
-isa_ok( $func, "Boilerplater::Function" );
+my $func = Clownfish::Function->new(%args);
+isa_ok( $func, "Clownfish::Function" );
 
-eval { my $death = Boilerplater::Function->new( %args, extra_arg => undef ) };
+eval { my $death = Clownfish::Function->new( %args, extra_arg => undef ) };
 like( $@, qr/extra_arg/, "Extra arg kills constructor" );
 
-eval { Boilerplater::Function->new( %args, micro_sym => 'Uh_Oh' ); };
+eval { Clownfish::Function->new( %args, micro_sym => 'Uh_Oh' ); };
 like( $@, qr/Uh_Oh/, "invalid micro_sym kills constructor" );
 
 my %sub_args = ( class => 'Boil::Obj', cnick => 'Obj' );
@@ -34,7 +34,7 @@
 isa_ok(
     $parser->subroutine_declaration_statement( $_, 0, %sub_args, inert => 1 )
         ->{declared},
-    "Boilerplater::Function",
+    "Clownfish::Function",
     "function declaration: $_"
     )
     for (

Modified: lucene/lucy/trunk/clownfish/t/201-method.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/201-method.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/201-method.t (original)
+++ lucene/lucy/trunk/clownfish/t/201-method.t Mon Dec  7 12:58:04 2009
@@ -3,10 +3,10 @@
 
 use Test::More tests => 30;
 
-BEGIN { use_ok('Boilerplater::Method') }
-use Boilerplater::Parser;
+BEGIN { use_ok('Clownfish::Method') }
+use Clownfish::Parser;
 
-my $parser = Boilerplater::Parser->new;
+my $parser = Clownfish::Parser->new;
 $parser->parcel_definition('parcel Boil;')
     or die "failed to process parcel_definition";
 
@@ -19,28 +19,28 @@
     macro_sym   => 'Return_An_Obj',
 );
 
-my $method = Boilerplater::Method->new(%args);
-isa_ok( $method, "Boilerplater::Method" );
+my $method = Clownfish::Method->new(%args);
+isa_ok( $method, "Clownfish::Method" );
 
 ok( $method->parcel, "parcel exposure by default" );
 
-eval { my $death = Boilerplater::Method->new( %args, extra_arg => undef ) };
+eval { my $death = Clownfish::Method->new( %args, extra_arg => undef ) };
 like( $@, qr/extra_arg/, "Extra arg kills constructor" );
 
-eval { Boilerplater::Method->new( %args, macro_sym => 'return_an_obj' ); };
+eval { Clownfish::Method->new( %args, macro_sym => 'return_an_obj' ); };
 like( $@, qr/macro_sym/, "Invalid macro_sym kills constructor" );
 
-my $dupe = Boilerplater::Method->new(%args);
+my $dupe = Clownfish::Method->new(%args);
 ok( $method->compatible($dupe), "compatible()" );
 
 my $macro_sym_differs
-    = Boilerplater::Method->new( %args, macro_sym => 'Eat' );
+    = Clownfish::Method->new( %args, macro_sym => 'Eat' );
 ok( !$method->compatible($macro_sym_differs),
     "different macro_sym spoils compatible()"
 );
 ok( !$macro_sym_differs->compatible($method), "... reversed" );
 
-my $extra_param = Boilerplater::Method->new( %args,
+my $extra_param = Clownfish::Method->new( %args,
     param_list => $parser->param_list('(Foo *self, i32_t count = 0, int b)'),
 );
 ok( !$method->compatible($macro_sym_differs),
@@ -48,35 +48,35 @@
 );
 ok( !$extra_param->compatible($method), "... reversed" );
 
-my $default_differs = Boilerplater::Method->new( %args,
+my $default_differs = Clownfish::Method->new( %args,
     param_list => $parser->param_list('(Foo *self, i32_t count = 1)'), );
 ok( !$method->compatible($default_differs),
     "different initial_value spoils compatible()"
 );
 ok( !$default_differs->compatible($method), "... reversed" );
 
-my $missing_default = Boilerplater::Method->new( %args,
+my $missing_default = Clownfish::Method->new( %args,
     param_list => $parser->param_list('(Foo *self, i32_t count)'), );
 ok( !$method->compatible($missing_default),
     "missing initial_value spoils compatible()"
 );
 ok( !$missing_default->compatible($method), "... reversed" );
 
-my $param_name_differs = Boilerplater::Method->new( %args,
+my $param_name_differs = Clownfish::Method->new( %args,
     param_list => $parser->param_list('(Foo *self, i32_t countess)'), );
 ok( !$method->compatible($param_name_differs),
     "different param name spoils compatible()"
 );
 ok( !$param_name_differs->compatible($method), "... reversed" );
 
-my $param_type_differs = Boilerplater::Method->new( %args,
+my $param_type_differs = Clownfish::Method->new( %args,
     param_list => $parser->param_list('(Foo *self, u32_t count)'), );
 ok( !$method->compatible($param_type_differs),
     "different param type spoils compatible()"
 );
 ok( !$param_type_differs->compatible($method), "... reversed" );
 
-my $self_type_differs = Boilerplater::Method->new(
+my $self_type_differs = Clownfish::Method->new(
     %args,
     class_name  => 'Boil::Bar',
     class_cnick => 'Bar',
@@ -86,7 +86,7 @@
     "different self type still compatible(), since can't test inheritance" );
 ok( $self_type_differs->compatible($method), "... reversed" );
 
-my $not_final = Boilerplater::Method->new(%args);
+my $not_final = Clownfish::Method->new(%args);
 my $final     = $not_final->finalize;
 
 eval { $method->override($final); };
@@ -105,7 +105,7 @@
 
 isa_ok(
     $parser->subroutine_declaration_statement( $_, 0, %sub_args )->{declared},
-    "Boilerplater::Method",
+    "Clownfish::Method",
     "method declaration: $_"
     )
     for (

Modified: lucene/lucy/trunk/clownfish/t/202-overridden_method.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/202-overridden_method.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/202-overridden_method.t (original)
+++ lucene/lucy/trunk/clownfish/t/202-overridden_method.t Mon Dec  7 12:58:04 2009
@@ -3,10 +3,10 @@
 
 use Test::More tests => 1;
 
-use Boilerplater::Method;
-use Boilerplater::Parser;
+use Clownfish::Method;
+use Clownfish::Parser;
 
-my $parser = Boilerplater::Parser->new;
+my $parser = Clownfish::Parser->new;
 $parser->parcel_definition('parcel Boil;')
     or die "failed to process parcel_definition";
 
@@ -19,8 +19,8 @@
     parcel      => 'Boil',
 );
 
-my $orig      = Boilerplater::Method->new(%args);
-my $overrider = Boilerplater::Method->new(
+my $orig      = Clownfish::Method->new(%args);
+my $overrider = Clownfish::Method->new(
     %args,
     param_list  => $parser->param_list('(FooJr *self)'),
     class_name  => 'Boil::Foo::FooJr',

Modified: lucene/lucy/trunk/clownfish/t/203-final_method.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/203-final_method.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/203-final_method.t (original)
+++ lucene/lucy/trunk/clownfish/t/203-final_method.t Mon Dec  7 12:58:04 2009
@@ -3,9 +3,9 @@
 
 use Test::More tests => 2;
 
-use Boilerplater::Parser;
+use Clownfish::Parser;
 
-my $parser = Boilerplater::Parser->new;
+my $parser = Clownfish::Parser->new;
 $parser->parcel_definition('parcel Boil;')
     or die "failed to process parcel_definition";
 
@@ -18,7 +18,7 @@
     parcel      => 'Boil',
 );
 
-my $not_final_method = Boilerplater::Method->new(%args);
+my $not_final_method = Clownfish::Method->new(%args);
 my $final_method     = $not_final_method->finalize;
 ok( !$not_final_method->final, "not final by default" );
 ok( $final_method->final,      "finalize" );

Modified: lucene/lucy/trunk/clownfish/t/300-variable.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/300-variable.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/300-variable.t (original)
+++ lucene/lucy/trunk/clownfish/t/300-variable.t Mon Dec  7 12:58:04 2009
@@ -2,19 +2,19 @@
 use warnings;
 
 use Test::More tests => 13;
-use Boilerplater::Type;
-use Boilerplater::Parser;
+use Clownfish::Type;
+use Clownfish::Parser;
 
-BEGIN { use_ok('Boilerplater::Variable') }
+BEGIN { use_ok('Clownfish::Variable') }
 
-my $parser = Boilerplater::Parser->new;
+my $parser = Clownfish::Parser->new;
 $parser->parcel_definition('parcel Boil;')
     or die "failed to process parcel_definition";
 
 sub new_type { $parser->type(shift) }
 
 eval {
-    my $death = Boilerplater::Variable->new(
+    my $death = Clownfish::Variable->new(
         micro_sym => 'foo',
         type      => new_type('int'),
         extra_arg => undef,
@@ -22,12 +22,12 @@
 };
 like( $@, qr/extra_arg/, "Extra arg kills constructor" );
 
-eval { my $death = Boilerplater::Variable->new( micro_sym => 'foo' ) };
+eval { my $death = Clownfish::Variable->new( micro_sym => 'foo' ) };
 like( $@, qr/type/, "type is required" );
-eval { my $death = Boilerplater::Variable->new( type => new_type('i32_t') ) };
+eval { my $death = Clownfish::Variable->new( type => new_type('i32_t') ) };
 like( $@, qr/micro_sym/, "micro_sym is required" );
 
-my $var = Boilerplater::Variable->new(
+my $var = Clownfish::Variable->new(
     micro_sym => 'foo',
     type      => new_type('float*')
 );
@@ -35,14 +35,14 @@
 is( $var->local_declaration, 'float* foo;', "declaration" );
 ok( $var->local, "default to local access" );
 
-$var = Boilerplater::Variable->new(
+$var = Clownfish::Variable->new(
     micro_sym => 'foo',
     type      => new_type('float[1]')
 );
 is( $var->local_c, 'float foo[1]',
     "to_c appends array to var name rather than type specifier" );
 
-$var = Boilerplater::Variable->new(
+$var = Clownfish::Variable->new(
     parcel      => 'Boil',
     micro_sym   => 'foo',
     type        => new_type("Foo*"),
@@ -52,7 +52,7 @@
 is( $var->global_c, 'boil_Foo* boil_LobClaw_foo', "global_c" );
 
 isa_ok( $parser->var_declaration_statement($_)->{declared},
-    "Boilerplater::Variable", "var_declaration_statement: $_" )
+    "Clownfish::Variable", "var_declaration_statement: $_" )
     for (
     'parcel int foo;',
     'private Obj *obj;',

Modified: lucene/lucy/trunk/clownfish/t/301-param_list.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/301-param_list.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/301-param_list.t (original)
+++ lucene/lucy/trunk/clownfish/t/301-param_list.t Mon Dec  7 12:58:04 2009
@@ -3,20 +3,20 @@
 
 use Test::More tests => 13;
 
-BEGIN { use_ok('Boilerplater::ParamList') }
-use Boilerplater::Type;
-use Boilerplater::Parser;
+BEGIN { use_ok('Clownfish::ParamList') }
+use Clownfish::Type;
+use Clownfish::Parser;
 
-my $parser = Boilerplater::Parser->new;
+my $parser = Clownfish::Parser->new;
 $parser->parcel_definition('parcel Boil;')
     or die "failed to process parcel_definition";
 
 isa_ok( $parser->param_variable($_),
-    "Boilerplater::Variable", "param_variable: $_" )
+    "Clownfish::Variable", "param_variable: $_" )
     for ( 'u32_t baz', 'CharBuf *stuff', 'float **ptr', );
 
 my $param_list = $parser->param_list("(Obj *self, int num)");
-isa_ok( $param_list, "Boilerplater::ParamList" );
+isa_ok( $param_list, "Clownfish::ParamList" );
 ok( !$param_list->variadic, "not variadic" );
 is( $param_list->to_c, 'boil_Obj* self, int num', "to_c" );
 is( $param_list->name_list, 'self, num', "name_list" );
@@ -31,5 +31,5 @@
 is( $param_list->to_c, 'boil_Obj* self, int num, ...', "to_c" );
 is( $param_list->num_vars, 2, "num_vars" );
 isa_ok( $param_list->get_variables->[0],
-    "Boilerplater::Variable", "get_variables..." );
+    "Clownfish::Variable", "get_variables..." );
 

Modified: lucene/lucy/trunk/clownfish/t/400-class.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/400-class.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/400-class.t (original)
+++ lucene/lucy/trunk/clownfish/t/400-class.t Mon Dec  7 12:58:04 2009
@@ -2,23 +2,23 @@
 use warnings;
 
 use Test::More tests => 51;
-use Boilerplater::Class;
-use Boilerplater::Parser;
+use Clownfish::Class;
+use Clownfish::Parser;
 
-my $parser = Boilerplater::Parser->new;
+my $parser = Clownfish::Parser->new;
 
-my $thing = Boilerplater::Variable->new(
+my $thing = Clownfish::Variable->new(
     parcel     => 'Boil',
     class_name => 'Foo',
     type       => $parser->type('Thing*'),
     micro_sym  => 'thing',
 );
-my $widget = Boilerplater::Variable->new(
+my $widget = Clownfish::Variable->new(
     class_name => 'Widget',
     type       => $parser->type('Widget*'),
     micro_sym  => 'widget',
 );
-my $tread_water = Boilerplater::Function->new(
+my $tread_water = Clownfish::Function->new(
     parcel      => 'Boil',
     class_name  => 'Foo',
     return_type => $parser->type('void'),
@@ -33,17 +33,17 @@
     functions   => [$tread_water],
 );
 
-my $foo = Boilerplater::Class->create(%foo_create_args);
-eval { Boilerplater::Class->create(%foo_create_args) };
+my $foo = Clownfish::Class->create(%foo_create_args);
+eval { Clownfish::Class->create(%foo_create_args) };
 like( $@, qr/conflict/i,
     "Can't call create for the same class more than once" );
-my $should_be_foo = Boilerplater::Class->fetch_singleton(
+my $should_be_foo = Clownfish::Class->fetch_singleton(
     parcel     => 'Boil',
     class_name => 'Foo',
 );
 is( $foo, $should_be_foo, "fetch_singleton" );
 
-my $foo_jr = Boilerplater::Class->create(
+my $foo_jr = Clownfish::Class->create(
     parcel            => 'Boil',
     class_name        => 'Foo::FooJr',
     parent_class_name => 'Foo',
@@ -54,7 +54,7 @@
 is( $foo_jr->get_struct_sym,  'FooJr',      "struct_sym" );
 is( $foo_jr->full_struct_sym, 'boil_FooJr', "full_struct_sym" );
 
-my $final_foo = Boilerplater::Class->create(
+my $final_foo = Clownfish::Class->create(
     parcel            => 'Boil',
     class_name        => 'Foo::FooJr::FinalFoo',
     parent_class_name => 'Foo::FooJr',
@@ -86,7 +86,7 @@
     inert      => 1,
 );
 eval {
-    Boilerplater::Class->create( %inert_args, methods => [$inert_do_stuff] );
+    Clownfish::Class->create( %inert_args, methods => [$inert_do_stuff] );
 };
 like(
     $@,
@@ -136,7 +136,7 @@
 my $class_content
     = 'public class Foo::FooJr cnick FooJr extends Foo { private int num; }';
 my $class = $parser->class_declaration($class_content);
-isa_ok( $class, "Boilerplater::Class", "class_declaration FooJr" );
+isa_ok( $class, "Clownfish::Class", "class_declaration FooJr" );
 ok( ( scalar grep { $_->micro_sym eq 'num' } $class->member_vars ),
     "parsed private member var" );
 
@@ -170,7 +170,7 @@
 |;
 
 $class = $parser->class_declaration($class_content);
-isa_ok( $class, "Boilerplater::Class", "class_declaration Dog" );
+isa_ok( $class, "Clownfish::Class", "class_declaration Dog" );
 ok( ( scalar grep { $_->micro_sym eq 'num_dogs' } $class->inert_vars ),
     "parsed inert var" );
 ok( ( scalar grep { $_->micro_sym eq 'mom' } $class->member_vars ),
@@ -195,7 +195,7 @@
         parcel inert void lie_still(); 
     }|;
 $class = $parser->class_declaration($class_content);
-isa_ok( $class, "Boilerplater::Class", "inert class_declaration" );
+isa_ok( $class, "Clownfish::Class", "inert class_declaration" );
 ok( $class->inert, "inert modifier parsed and passed to constructor" );
 
 $class_content = qq|

Modified: lucene/lucy/trunk/clownfish/t/401-c_block.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/401-c_block.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/401-c_block.t (original)
+++ lucene/lucy/trunk/clownfish/t/401-c_block.t Mon Dec  7 12:58:04 2009
@@ -3,19 +3,19 @@
 
 use Test::More tests => 5;
 
-use Boilerplater::CBlock;
-use Boilerplater::Parser;
+use Clownfish::CBlock;
+use Clownfish::Parser;
 
-my $parser = Boilerplater::Parser->new;
+my $parser = Clownfish::Parser->new;
 
-my $block = Boilerplater::CBlock->new( contents => 'int foo;' );
-isa_ok( $block, "Boilerplater::CBlock" );
+my $block = Clownfish::CBlock->new( contents => 'int foo;' );
+isa_ok( $block, "Clownfish::CBlock" );
 is( $block->get_contents, 'int foo;', "get_contents" );
-eval { Boilerplater::CBlock->new };
+eval { Clownfish::CBlock->new };
 like( $@, qr/contents/, "content required" );
 
 $block = $parser->embed_c(qq| __C__\n#define FOO 1\n__END_C__  |);
 
-isa_ok( $block, "Boilerplater::CBlock" );
+isa_ok( $block, "Clownfish::CBlock" );
 is( $block->get_contents, "#define FOO 1\n", "parse embed_c" );
 

Modified: lucene/lucy/trunk/clownfish/t/402-parcel.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/402-parcel.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/402-parcel.t (original)
+++ lucene/lucy/trunk/clownfish/t/402-parcel.t Mon Dec  7 12:58:04 2009
@@ -3,10 +3,10 @@
 
 use Test::More tests => 7;
 
-BEGIN { use_ok('Boilerplater::Parcel') }
+BEGIN { use_ok('Clownfish::Parcel') }
 
 package BoilingThing;
-use base qw( Boilerplater::Symbol );
+use base qw( Clownfish::Symbol );
 
 sub new {
     return shift->SUPER::new( micro_sym => 'sym', exposure => 'parcel', @_ );
@@ -15,7 +15,7 @@
 package main;
 
 # Register singleton.
-Boilerplater::Parcel->singleton( name => 'Boil' );
+Clownfish::Parcel->singleton( name => 'Boil' );
 
 my $thing = BoilingThing->new;
 is( $thing->get_prefix, '', 'get_prefix with no parcel' );

Modified: lucene/lucy/trunk/clownfish/t/403-file.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/403-file.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/403-file.t (original)
+++ lucene/lucy/trunk/clownfish/t/403-file.t Mon Dec  7 12:58:04 2009
@@ -3,10 +3,10 @@
 
 use Test::More tests => 17;
 
-use Boilerplater::File;
-use Boilerplater::Parser;
+use Clownfish::File;
+use Clownfish::Parser;
 
-my $parser = Boilerplater::Parser->new;
+my $parser = Clownfish::Parser->new;
 
 my $parcel_declaration = "parcel Stuff;";
 my $class_content      = qq|
@@ -46,9 +46,9 @@
 
 my @blocks = $file->blocks;
 is( scalar @blocks, 3, "all three blocks" );
-isa_ok( $blocks[0], "Boilerplater::Parcel" );
-isa_ok( $blocks[1], "Boilerplater::Class" );
-isa_ok( $blocks[2], "Boilerplater::CBlock" );
+isa_ok( $blocks[0], "Clownfish::Parcel" );
+isa_ok( $blocks[1], "Clownfish::Class" );
+isa_ok( $blocks[2], "Clownfish::CBlock" );
 
 $file = $parser->file( $class_content, 0, source_class => 'Stuff::Thing' );
 ($class) = $file->classes;

Modified: lucene/lucy/trunk/clownfish/t/500-hierarchy.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/500-hierarchy.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/500-hierarchy.t (original)
+++ lucene/lucy/trunk/clownfish/t/500-hierarchy.t Mon Dec  7 12:58:04 2009
@@ -3,8 +3,8 @@
 
 use Test::More tests => 18;
 
-use Boilerplater::Hierarchy;
-use Boilerplater::Util qw( a_isa_b );
+use Clownfish::Hierarchy;
+use Clownfish::Util qw( a_isa_b );
 use File::Spec::Functions qw( catfile splitpath );
 use Fcntl;
 use File::Path qw( rmtree mkpath );
@@ -17,11 +17,11 @@
 # Clean up.
 rmtree( $args{dest} );
 
-eval { my $death = Boilerplater::Hierarchy->new( %args, extra_arg => undef ) };
+eval { my $death = Clownfish::Hierarchy->new( %args, extra_arg => undef ) };
 like( $@, qr/extra_arg/, "Extra arg kills constructor" );
 
-my $hierarchy = Boilerplater::Hierarchy->new(%args);
-isa_ok( $hierarchy, "Boilerplater::Hierarchy" );
+my $hierarchy = Clownfish::Hierarchy->new(%args);
+isa_ok( $hierarchy, "Clownfish::Hierarchy" );
 is( $hierarchy->get_source, $args{source}, "get_source" );
 is( $hierarchy->get_dest,   $args{dest},   "get_dest" );
 
@@ -31,9 +31,9 @@
 is( scalar @files, 3, "recursed and found all three files" );
 my %files;
 for my $file (@files) {
-    die "not a File" unless isa_ok( $file, "Boilerplater::File" );
+    die "not a File" unless isa_ok( $file, "Clownfish::File" );
     ok( !$file->get_modified, "start off not modified" );
-    my ($class) = grep { a_isa_b( $_, "Boilerplater::Class" ) } $file->blocks;
+    my ($class) = grep { a_isa_b( $_, "Clownfish::Class" ) } $file->blocks;
     die "no class" unless $class;
     $files{ $class->get_class_name } = $file;
 }
@@ -44,7 +44,7 @@
 my @classes = $hierarchy->ordered_classes;
 is( scalar @classes, 3, "all classes" );
 for my $class (@classes) {
-    die "not a Class" unless isa_ok( $class, "Boilerplater::Class" );
+    die "not a Class" unless isa_ok( $class, "Clownfish::Class" );
 }
 
 # Generate fake C files, with times set to one second ago.

Modified: lucene/lucy/trunk/clownfish/t/600-parser.t
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/t/600-parser.t?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/t/600-parser.t (original)
+++ lucene/lucy/trunk/clownfish/t/600-parser.t Mon Dec  7 12:58:04 2009
@@ -3,20 +3,20 @@
 
 use Test::More tests => 124;
 
-BEGIN { use_ok('Boilerplater::Parser') }
+BEGIN { use_ok('Clownfish::Parser') }
 
-my $parser = Boilerplater::Parser->new;
-isa_ok( $parser, "Boilerplater::Parser" );
+my $parser = Clownfish::Parser->new;
+isa_ok( $parser, "Clownfish::Parser" );
 
 isa_ok( $parser->parcel_definition("parcel Fish;"),
-    "Boilerplater::Parcel", "parcel_definition" );
+    "Clownfish::Parcel", "parcel_definition" );
 isa_ok( $parser->parcel_definition("parcel Crustacean cnick Crust;"),
-    "Boilerplater::Parcel", "parcel_definition with cnick" );
+    "Clownfish::Parcel", "parcel_definition with cnick" );
 
 # Set and leave parcel.
 my $parcel = $parser->parcel_definition('parcel Boil;')
     or die "failed to process parcel_definition";
-is( $Boilerplater::Parser::parcel, $parcel,
+is( $Clownfish::Parser::parcel, $parcel,
     "parcel_definition sets internal \$parcel var" );
 
 is( $parser->strip_plain_comments("/*x*/"),
@@ -51,7 +51,7 @@
     for ( '[]', '[A_CONSTANT]', '*' );
 is( $parser->type_postfix('[ FOO ]'), '[FOO]', "type_postfix: [ FOO ]" );
 
-isa_ok( $parser->type($_), "Boilerplater::Type", "type $_" )
+isa_ok( $parser->type($_), "Clownfish::Type", "type $_" )
     for ( 'const char *', 'Obj*', 'i32_t', 'char[]', 'long[1]',
     'i64_t[FOO]' );
 
@@ -59,11 +59,11 @@
     for ( 'foo', 'bar_bar_bar' );
 
 isa_ok( $parser->param_variable($_),
-    "Boilerplater::Variable", "param_variable: $_" )
+    "Clownfish::Variable", "param_variable: $_" )
     for ( 'u32_t baz;', 'CharBuf *stuff;', 'float **ptr;', );
 
 isa_ok( $parser->var_declaration_statement($_)->{declared},
-    "Boilerplater::Variable", "var_declaration_statement: $_" )
+    "Clownfish::Variable", "var_declaration_statement: $_" )
     for (
     'parcel int foo;',
     'private Obj *obj;',
@@ -91,7 +91,7 @@
     my $parsed = $parser->type($composite);
     isa_ok(
         $parsed,
-        "Boilerplater::Type::Composite",
+        "Clownfish::Type::Composite",
         "composite_type: $composite"
     );
 }
@@ -99,7 +99,7 @@
 my @object_types = ( 'Obj *', "incremented Foo*", "decremented CharBuf *" );
 for my $object_type (@object_types) {
     my $parsed = $parser->object_type($object_type);
-    isa_ok( $parsed, "Boilerplater::Type::Object",
+    isa_ok( $parsed, "Clownfish::Type::Object",
         "object_type: $object_type" );
 }
 
@@ -110,7 +110,7 @@
 );
 while ( my ( $param_list, $num_params ) = each %param_lists ) {
     my $parsed = $parser->param_list($param_list);
-    isa_ok( $parsed, "Boilerplater::ParamList", "param_list: $param_list" );
+    isa_ok( $parsed, "Clownfish::ParamList", "param_list: $param_list" );
 }
 ok( $parser->param_list("(int foo, ...)")->variadic, "variadic param list" );
 my $param_list = $parser->param_list(q|(int foo = 0xFF, char *bar ="blah")|);



Mime
View raw message