lucy-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mar...@apache.org
Subject svn commit: r887915 [1/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
Author: marvin
Date: Mon Dec  7 12:58:04 2009
New Revision: 887915

URL: http://svn.apache.org/viewvc?rev=887915&view=rev
Log:
Perform a mechanical substitution replacing the string "Boilerplater" with the
string "Clownfish" for all files within trunk/clownfish.

Modified:
    lucene/lucy/trunk/clownfish/lib/Clownfish.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/Class.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/File.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/Function.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/Method.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Class.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Constructor.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Method.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Subroutine.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/TypeMap.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/CBlock.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Class.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/DocuComment.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Dumpable.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/File.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Function.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Hierarchy.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Method.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/ParamList.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Parcel.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Parser.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Symbol.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Type.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Arbitrary.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Composite.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Float.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Integer.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Object.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Primitive.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Type/VAList.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Void.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Util.pm
    lucene/lucy/trunk/clownfish/lib/Clownfish/Variable.pm
    lucene/lucy/trunk/clownfish/t/000-load.t
    lucene/lucy/trunk/clownfish/t/001-util.t
    lucene/lucy/trunk/clownfish/t/050-docucomment.t
    lucene/lucy/trunk/clownfish/t/051-symbol.t
    lucene/lucy/trunk/clownfish/t/100-type.t
    lucene/lucy/trunk/clownfish/t/101-primitive_type.t
    lucene/lucy/trunk/clownfish/t/102-integer_type.t
    lucene/lucy/trunk/clownfish/t/103-float_type.t
    lucene/lucy/trunk/clownfish/t/104-void_type.t
    lucene/lucy/trunk/clownfish/t/105-object_type.t
    lucene/lucy/trunk/clownfish/t/106-va_list_type.t
    lucene/lucy/trunk/clownfish/t/107-arbitrary_type.t
    lucene/lucy/trunk/clownfish/t/108-composite_type.t
    lucene/lucy/trunk/clownfish/t/200-function.t
    lucene/lucy/trunk/clownfish/t/201-method.t
    lucene/lucy/trunk/clownfish/t/202-overridden_method.t
    lucene/lucy/trunk/clownfish/t/203-final_method.t
    lucene/lucy/trunk/clownfish/t/300-variable.t
    lucene/lucy/trunk/clownfish/t/301-param_list.t
    lucene/lucy/trunk/clownfish/t/400-class.t
    lucene/lucy/trunk/clownfish/t/401-c_block.t
    lucene/lucy/trunk/clownfish/t/402-parcel.t
    lucene/lucy/trunk/clownfish/t/403-file.t
    lucene/lucy/trunk/clownfish/t/500-hierarchy.t
    lucene/lucy/trunk/clownfish/t/600-parser.t

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish.pm Mon Dec  7 12:58:04 2009
@@ -1,25 +1,25 @@
 use strict;
 use warnings;
 
-package Boilerplater;
+package Clownfish;
 our $VERSION = '0.01';
 
 1;
 
 =head1 NAME
 
-Boilerplater - Bolt OO functionality onto C.
+Clownfish - Bolt OO functionality onto C.
 
 =head1 PRIVATE API
 
-Boilerplater is an implementation detail.  This documentation is partial --
+Clownfish is an implementation detail.  This documentation is partial --
 enough for the curious hacker, but not a full API.
 
 =head1 DESCRIPTION
 
 =head2 Overview.
 
-Boilerplater is a small language for describing an object oriented interface,
+Clownfish is a small language for describing an object oriented interface,
 and a compiler which generates some "boilerplate" code allowing that interface
 to be used from C.
 
@@ -103,19 +103,19 @@
 =head2 Memory management
 
 At present, memory is managed via a reference counting scheme, but this is not
-inherently part of Boilerplater.
+inherently part of Clownfish.
 
 =head2 Namespaces, parcels, prefixes, and "short names"
 
-There are two levels of namespacing in Boilerplater: parcels and classes.
+There are two levels of namespacing in Clownfish: parcels and classes.
 
-Boilerplater classes intended to be published as a single unit may be grouped
+Clownfish classes intended to be published as a single unit may be grouped
 together using a "parcel" (akin to a "package" in Java).  Parcel directives
 need to go at the top of each class file.
 
     parcel Crustacean cnick Crust;
 
-All symbols generated by Boilerplater for classes within a parcel will be
+All symbols generated by Clownfish for classes within a parcel will be
 prefixed by varying capitalizations of the parcel's C-nickname or "cnick" in
 order to avoid namespace collisions with other projects.
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core.pm Mon Dec  7 12:58:04 2009
@@ -1,9 +1,9 @@
 use strict;
 use warnings;
 
-package Boilerplater::Binding::Core;
-use Boilerplater::Util qw( a_isa_b verify_args );
-use Boilerplater::Binding::Core::File;
+package Clownfish::Binding::Core;
+use Clownfish::Util qw( a_isa_b verify_args );
+use Clownfish::Binding::Core::File;
 use File::Spec::Functions qw( catfile );
 use Fcntl;
 
@@ -24,7 +24,7 @@
         confess("Missing required param '$_'") unless defined $self->{$_};
     }
     confess("Not a Hierarchy")
-        unless a_isa_b( $self->{hierarchy}, "Boilerplater::Hierarchy" );
+        unless a_isa_b( $self->{hierarchy}, "Clownfish::Hierarchy" );
 
     return $self;
 }
@@ -46,13 +46,13 @@
         my $source_class = $file->get_source_class;
         next if $written{$source_class};
         $written{$source_class} = 1;
-        Boilerplater::Binding::Core::File->write_h(
+        Clownfish::Binding::Core::File->write_h(
             file   => $file,
             dest   => $dest,
             header => $header,
             footer => $footer,
         );
-        Boilerplater::Binding::Core::File->write_c(
+        Clownfish::Binding::Core::File->write_c(
             file   => $file,
             dest   => $dest,
             header => $header,
@@ -170,16 +170,16 @@
 
 =head1 NAME
 
-Boilerplater::Binding::Core - Generate core C code for a Boilerplater::Hierarchy.
+Clownfish::Binding::Core - Generate core C code for a Clownfish::Hierarchy.
 
 =head1 SYNOPSIS
 
-    my $hierarchy = Boilerplater::Hierarchy->new(
+    my $hierarchy = Clownfish::Hierarchy->new(
         source => '/path/to/bp/files',
         dest   => 'autogen',
     );
     $hierarchy->build;
-    my $core_binding = Boilerplater::Binding::Core->new(
+    my $core_binding = Clownfish::Binding::Core->new(
         hierarchy => $hierarchy,
         dest      => 'autogen',
         header    => "/* Auto-generated file. */\n",
@@ -189,15 +189,15 @@
 
 =head1 DESCRIPTION
 
-A Boilerplater::Hierarchy describes an abstract specifiction for a class
-hierarchy; Boilerplater::Binding::Core is responsible for auto-generating C
+A Clownfish::Hierarchy describes an abstract specifiction for a class
+hierarchy; Clownfish::Binding::Core is responsible for auto-generating C
 code which implements that specification.
 
 =head1 METHODS
 
 =head2 new
 
-    my $binding = Boilerplater::Binding::Core->new(
+    my $binding = Clownfish::Binding::Core->new(
         hierarchy => $hierarchy,            # required
         dest      => '/path/to/autogen',    # required
         header    => $header,               # required
@@ -206,7 +206,7 @@
 
 =over
 
-=item * B<hierarchy> - A L<Boilerplater::Hierarchy>.
+=item * B<hierarchy> - A L<Clownfish::Hierarchy>.
 
 =item * B<dest> - The directory where C output files will be written.
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/Class.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/Class.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/Class.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/Class.pm Mon Dec  7 12:58:04 2009
@@ -1,10 +1,10 @@
 use strict;
 use warnings;
 
-package Boilerplater::Binding::Core::Class;
-use Boilerplater::Util qw( a_isa_b verify_args );
-use Boilerplater::Binding::Core::Method;
-use Boilerplater::Binding::Core::Function;
+package Clownfish::Binding::Core::Class;
+use Clownfish::Util qw( a_isa_b verify_args );
+use Clownfish::Binding::Core::Method;
+use Clownfish::Binding::Core::Function;
 use File::Spec::Functions qw( catfile );
 
 our %new_PARAMS = ( client => undef, );
@@ -16,8 +16,8 @@
 
     # Validate.
     my $client = $self->{client};
-    confess("Not a Boilerplater::Class")
-        unless a_isa_b( $client, "Boilerplater::Class" );
+    confess("Not a Clownfish::Class")
+        unless a_isa_b( $client, "Clownfish::Class" );
 
     # Cache some vars.
     $self->{class_name}      = $client->get_class_name;
@@ -159,7 +159,7 @@
     my $sub_declarations = "";
     for my $sub ( @functions, @novel_methods ) {
         $sub_declarations
-            .= Boilerplater::Binding::Core::Function->func_declaration($sub)
+            .= Clownfish::Binding::Core::Function->func_declaration($sub)
             . "\n\n";
     }
 
@@ -173,14 +173,14 @@
     my $method_typedefs = '';
     for my $method (@novel_methods) {
         $method_typedefs
-            .= Boilerplater::Binding::Core::Method->typedef_dec($method)
+            .= Clownfish::Binding::Core::Method->typedef_dec($method)
             . "\n";
     }
 
     # Define method invocation syntax.
     my $method_defs = '';
     for my $method (@methods) {
-        $method_defs .= Boilerplater::Binding::Core::Method->method_def(
+        $method_defs .= Clownfish::Binding::Core::Method->method_def(
             method => $method,
             cnick  => $cnick,
         ) . "\n";
@@ -198,7 +198,7 @@
     for my $method (@novel_methods) {
         next unless $method->public || $method->abstract;
         $callback_declarations
-            .= Boilerplater::Binding::Core::Method->callback_dec($method);
+            .= Clownfish::Binding::Core::Method->callback_dec($method);
     }
 
     # Define short names.
@@ -214,7 +214,7 @@
     }
     if ( !$client->inert ) {
         for my $method (@novel_methods) {
-            if ( !$method->isa("Boilerplater::Method::Overridden") ) {
+            if ( !$method->isa("Clownfish::Method::Overridden") ) {
                 my $short_typedef = $method->short_typedef;
                 my $full_typedef  = $method->full_typedef;
                 $short_names .= "  #define $short_typedef $full_typedef\n";
@@ -330,7 +330,7 @@
         # Create a default implementation for abstract methods.
         if ( $method->abstract ) {
             if ( $novel{ $method->micro_sym } ) {
-                $callback_funcs .= Boilerplater::Binding::Core::Method
+                $callback_funcs .= Clownfish::Binding::Core::Method
                     ->abstract_method_def($method) . "\n";
             }
         }
@@ -341,11 +341,11 @@
             my $callback_sym = $method->full_callback_sym;
             if ( $novel{ $method->micro_sym } ) {
                 $callback_funcs
-                    .= Boilerplater::Binding::Core::Method->callback_def(
+                    .= Clownfish::Binding::Core::Method->callback_def(
                     $method)
                     . "\n";
                 $callbacks
-                    .= Boilerplater::Binding::Core::Method->callback_obj_def(
+                    .= Clownfish::Binding::Core::Method->callback_obj_def(
                     method => $method,
                     offset => $offset,
                     );
@@ -385,24 +385,24 @@
 
 =head1 NAME
 
-Boilerplater::Binding::Core::Class - Generate core C code for a class.
+Clownfish::Binding::Core::Class - Generate core C code for a class.
 
 =head1 DESCRIPTION
 
-Boilerplater::Class is an abstract specification for a class.  This module
+Clownfish::Class is an abstract specification for a class.  This module
 autogenerates the C code with implements that specification.
 
 =head1 METHODS
 
 =head2 new
 
-    my $class_binding = Boilerplater::Binding::Core::Class->new(
+    my $class_binding = Clownfish::Binding::Core::Class->new(
         client => $class,
     );
 
 =over
 
-=item * B<client> - A L<Boilerplater::Class>.
+=item * B<client> - A L<Clownfish::Class>.
 
 =back
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/File.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/File.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/File.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/File.pm Mon Dec  7 12:58:04 2009
@@ -1,9 +1,9 @@
 use strict;
 use warnings;
 
-package Boilerplater::Binding::Core::File;
-use Boilerplater::Util qw( a_isa_b verify_args );
-use Boilerplater::Binding::Core::Class;
+package Clownfish::Binding::Core::File;
+use Clownfish::Util qw( a_isa_b verify_args );
+use Clownfish::Binding::Core::Class;
 use File::Spec::Functions qw( catfile splitpath );
 use File::Path qw( mkpath );
 use Scalar::Util qw( blessed );
@@ -21,8 +21,8 @@
     my ( undef, %args ) = @_;
     verify_args( \%write_h_PARAMS, %args ) or confess $@;
     my $file = $args{file};
-    confess("Not a Boilerplater::File")
-        unless a_isa_b( $file, "Boilerplater::File" );
+    confess("Not a Clownfish::File")
+        unless a_isa_b( $file, "Clownfish::File" );
     my $h_path = $file->h_path( $args{dest} );
     print "Writing $h_path\n";
 
@@ -41,14 +41,14 @@
     # Aggregate block content.
     my $content = "";
     for my $block ( $file->blocks ) {
-        if ( a_isa_b( $block, 'Boilerplater::Parcel' ) ) { }
-        elsif ( a_isa_b( $block, 'Boilerplater::Class' ) ) {
+        if ( a_isa_b( $block, 'Clownfish::Parcel' ) ) { }
+        elsif ( a_isa_b( $block, 'Clownfish::Class' ) ) {
             my $class_binding
-                = Boilerplater::Binding::Core::Class->new( client => $block,
+                = Clownfish::Binding::Core::Class->new( client => $block,
                 );
             $content .= $class_binding->to_c_header . "\n";
         }
-        elsif ( a_isa_b( $block, 'Boilerplater::CBlock' ) ) {
+        elsif ( a_isa_b( $block, 'Clownfish::CBlock' ) ) {
             $content .= $block->get_contents . "\n";
         }
         else {
@@ -89,8 +89,8 @@
     my ( undef, %args ) = @_;
     verify_args( \%write_h_PARAMS, %args ) or confess $@;
     my $file = $args{file};
-    confess("Not a Boilerplater::File")
-        unless a_isa_b( $file, "Boilerplater::File" );
+    confess("Not a Clownfish::File")
+        unless a_isa_b( $file, "Clownfish::File" );
     my $c_path = $file->c_path( $args{dest} );
     print "Writing $c_path\n";
 
@@ -107,8 +107,8 @@
     my $c_file_syms = "";
     for my $block ( $file->blocks ) {
         if ( blessed($block) ) {
-            if ( $block->isa('Boilerplater::Class') ) {
-                my $bound = Boilerplater::Binding::Core::Class->new(
+            if ( $block->isa('Clownfish::Class') ) {
+                my $bound = Clownfish::Binding::Core::Class->new(
                     client => $block, );
                 $content .= $bound->to_c . "\n";
                 my $c_file_sym = "C_" . uc( $block->full_struct_sym );
@@ -146,11 +146,11 @@
 
 =head1 NAME
 
-Boilerplater::Binding::Core::File - Generate core C code for a .bp file.
+Clownfish::Binding::Core::File - Generate core C code for a .bp file.
 
 =head1 DESCRIPTION
 
-This module is the companion to Boilerplater::File, generating the C code
+This module is the companion to Clownfish::File, generating the C code
 needed to implement the .bp file's specification.
 
 There is a one-to-one mapping between .bp files and autogenerated .h and .c
@@ -162,7 +162,7 @@
 
 =head2 write_h
 
-    Boilerplater::Binding::Core::File->write_c(
+    Clownfish::Binding::Core::File->write_c(
         file   => $file,                            # required
         dest   => '/path/to/autogen_dir',           # required
         header => "/* Autogenerated file. */\n",    # required
@@ -174,7 +174,7 @@
 
 =over
 
-=item * B<file> - A L<Boilerplater::File>.
+=item * B<file> - A L<Clownfish::File>.
 
 =item * B<dest> - The directory under which autogenerated files are being
 written.
@@ -189,7 +189,7 @@
 
 =head2 write_h
 
-    Boilerplater::Binding::Core::File->write_c(
+    Clownfish::Binding::Core::File->write_c(
         file   => $file,                            # required
         dest   => '/path/to/autogen_dir',           # required
         header => "/* Autogenerated file. */\n",    # required

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/Function.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/Function.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/Function.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/Function.pm Mon Dec  7 12:58:04 2009
@@ -1,13 +1,13 @@
 use strict;
 use warnings;
 
-package Boilerplater::Binding::Core::Function;
-use Boilerplater::Util qw( a_isa_b );
+package Clownfish::Binding::Core::Function;
+use Clownfish::Util qw( a_isa_b );
 
 sub func_declaration {
     my ( undef, $function ) = @_;
     confess("Not a Function")
-        unless a_isa_b( $function, "Boilerplater::Function" );
+        unless a_isa_b( $function, "Clownfish::Function" );
     my $return_type = $function->get_return_type;
     my $param_list  = $function->get_param_list;
     my $dec = $function->inline ? 'static CHY_INLINE ' : '';
@@ -25,14 +25,14 @@
 
 =head1 NAME
 
-Boilerplater::Binding::Core::Function - Generate core C code for a function.
+Clownfish::Binding::Core::Function - Generate core C code for a function.
 
 =head1 CLASS METHODS
 
 =head2 func_declaration
 
     my $declaration 
-        = Boilerplater::Binding::Core::Function->func_declaration($function);
+        = Clownfish::Binding::Core::Function->func_declaration($function);
 
 Return C code declaring the function's C implementation.
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/Method.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/Method.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/Method.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Core/Method.pm Mon Dec  7 12:58:04 2009
@@ -1,15 +1,15 @@
 use strict;
 use warnings;
 
-package Boilerplater::Binding::Core::Method;
-use Boilerplater::Util qw( a_isa_b );
+package Clownfish::Binding::Core::Method;
+use Clownfish::Util qw( a_isa_b );
 use Carp;
 
 sub method_def {
     my ( undef,   %args )  = @_;
     my ( $method, $cnick ) = @args{qw( method cnick )};
     confess("Not a Method")
-        unless a_isa_b( $method, "Boilerplater::Method" );
+        unless a_isa_b( $method, "Clownfish::Method" );
     if ( $method->final ) {
         return _final_method_def( $method, $cnick );
     }
@@ -308,18 +308,18 @@
 
 =head1 NAME
 
-Boilerplater::Binding::Core::Method - Generate core C code for a method.
+Clownfish::Binding::Core::Method - Generate core C code for a method.
 
 =head1 DESCRIPTION
 
-Boilerplater::Method is an abstract specification; this class generates C code
+Clownfish::Method is an abstract specification; this class generates C code
 which implements the specification.
 
 =head1 METHODS
 
 =head2 method_def
 
-    my $c_code = Boilerplater::Binding::Core::Method->method_def(
+    my $c_code = Clownfish::Binding::Core::Method->method_def(
         method => $method,
         cnick  => 'FooJr',
     );
@@ -328,7 +328,7 @@
 
 =over
 
-=item * B<method> - A L<Boilerplater::Method>.
+=item * B<method> - A L<Clownfish::Method>.
 
 =item * B<cnick> - The cnick for the class which will be invoking the
 method - i.e. FooJr needs its own method invocation function even if the
@@ -338,35 +338,35 @@
 
 =head2 typedef_dec
 
-    my $c_code = Boilerplater::Binding::Core::Method->typedef_dec($method);
+    my $c_code = Clownfish::Binding::Core::Method->typedef_dec($method);
 
 Return C code expressing a typedef declaration for the method.
 
 =head2 callback_dec
 
-    my $c_code = Boilerplater::Binding::Core::Method->callback_dec($method);
+    my $c_code = Clownfish::Binding::Core::Method->callback_dec($method);
 
 Return C code declaring the Callback object for this method.
 
 =head2 callback_obj_def
 
     my $c_code 
-        = Boilerplater::Binding::Core::Method->callback_obj_def($method);
+        = Clownfish::Binding::Core::Method->callback_obj_def($method);
 
 Return C code defining the Callback object for this method, which stores
 introspection data and a pointer to the callback function.
 
 =head2 callback_def
 
-    my $c_code = Boilerplater::Binding::Core::Method->callback_def($method);
+    my $c_code = Clownfish::Binding::Core::Method->callback_def($method);
 
 Return C code implementing a callback to the Host for this method.  This code
-is used when a Host method has overridden a method in a Boilerplater class.
+is used when a Host method has overridden a method in a Clownfish class.
 
 =head2 abstract_method_def
 
     my $c_code 
-        = Boilerplater::Binding::Core::Method->abstract_method_def($method);
+        = Clownfish::Binding::Core::Method->abstract_method_def($method);
 
 Return C code implementing a version of the method which throws an "abstract
 method" error at runtime.

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl.pm Mon Dec  7 12:58:04 2009
@@ -1,22 +1,22 @@
 use strict;
 use warnings;
 
-package Boilerplater::Binding::Perl;
+package Clownfish::Binding::Perl;
 
-use Boilerplater::Hierarchy;
+use Clownfish::Hierarchy;
 use Carp;
 use File::Spec::Functions qw( catfile );
 use Fcntl;
 
-use Boilerplater::Parcel;
-use Boilerplater::Class;
-use Boilerplater::Function;
-use Boilerplater::Method;
-use Boilerplater::Variable;
-use Boilerplater::Util qw( verify_args a_isa_b write_if_changed );
-use Boilerplater::Binding::Perl::Class;
-use Boilerplater::Binding::Perl::Method;
-use Boilerplater::Binding::Perl::Constructor;
+use Clownfish::Parcel;
+use Clownfish::Class;
+use Clownfish::Function;
+use Clownfish::Method;
+use Clownfish::Variable;
+use Clownfish::Util qw( verify_args a_isa_b write_if_changed );
+use Clownfish::Binding::Perl::Class;
+use Clownfish::Binding::Perl::Method;
+use Clownfish::Binding::Perl::Constructor;
 
 our %new_PARAMS = (
     parcel     => undef,
@@ -31,9 +31,9 @@
     my $either = shift;
     verify_args( \%new_PARAMS, @_ ) or confess $@;
     my $self = bless { %new_PARAMS, @_, }, ref($either) || $either;
-    if ( !a_isa_b( $self->{parcel}, 'Boilerplater::Parcel' ) ) {
+    if ( !a_isa_b( $self->{parcel}, 'Clownfish::Parcel' ) ) {
         $self->{parcel}
-            = Boilerplater::Parcel->singleton( name => $self->{parcel} );
+            = Clownfish::Parcel->singleton( name => $self->{parcel} );
     }
     my $parcel = $self->{parcel};
     for ( keys %new_PARAMS ) {
@@ -65,7 +65,7 @@
 sub write_bindings {
     my $self           = shift;
     my @ordered        = $self->{hierarchy}->ordered_classes;
-    my $registry       = Boilerplater::Binding::Perl::Class->registry;
+    my $registry       = Clownfish::Binding::Perl::Class->registry;
     my $hand_rolled_xs = "";
     my $generated_xs   = "";
     my $xs             = "";
@@ -216,7 +216,7 @@
     my %has_pod;
     my %modified;
 
-    my $registry = Boilerplater::Binding::Perl::Class->registry;
+    my $registry = Clownfish::Binding::Perl::Class->registry;
     $has_pod{ $_->get_class_name } = 1
         for grep { $_->get_make_pod } values %$registry;
 
@@ -336,7 +336,7 @@
 
 sub write_xs_typemap {
     my $self = shift;
-    Boilerplater::Binding::Perl::TypeMap->write_xs_typemap(
+    Clownfish::Binding::Perl::TypeMap->write_xs_typemap(
         hierarchy => $self->{hierarchy}, );
 }
 
@@ -348,16 +348,16 @@
 
 =head1 NAME
 
-Boilerplater::Binding::Perl - Perl bindings for a Boilerplater::Hierarchy.
+Clownfish::Binding::Perl - Perl bindings for a Clownfish::Hierarchy.
 
 =head1 DESCRIPTION
 
-Boilerplater::Binding::Perl presents an interface for auto-generating XS and
-Perl code to bind C code for a Boilerplater class hierarchy to Perl.
+Clownfish::Binding::Perl presents an interface for auto-generating XS and
+Perl code to bind C code for a Clownfish class hierarchy to Perl.
 
 In theory this module could be much more flexible and its API could be more
 elegant.  There are many ways which you could walk the parsed parcels,
-classes, methods, etc. in a Boilerplater::Hierarchy and generate binding code.
+classes, methods, etc. in a Clownfish::Hierarchy and generate binding code.
 However, our needs are very limited, so we are content with a "one size fits
 one" solution.
 
@@ -381,7 +381,7 @@
 
 =head2 new
 
-    my $perl_binding = Boilerplater::Binding::Perl->new(
+    my $perl_binding = Clownfish::Binding::Perl->new(
         boot_class => 'Lucy',                          # required
         parcel     => 'Lucy',                          # required
         hierarchy  => $hierarchy,                      # required
@@ -395,10 +395,10 @@
 =item * B<boot_class> - The name of the main class, which will own the shared
 object.
 
-=item * B<parcel> - The L<Boilerplater::Parcel> to which the C<boot_class>
+=item * B<parcel> - The L<Clownfish::Parcel> to which the C<boot_class>
 belongs.
 
-=item * B<hierarchy> - A Boilerplater::Hierarchy.
+=item * B<hierarchy> - A Clownfish::Hierarchy.
 
 =item * B<lib_dir> - location of the Perl lib directory to which files will be
 written.
@@ -440,7 +440,7 @@
     $perl_binding->write_boot;
 
 Write out "boot" files to the Hierarchy's C<dest_dir> which contain code for
-bootstrapping Boilerplater classes.
+bootstrapping Clownfish classes.
 
 =head1 COPYRIGHT AND LICENSE
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Class.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Class.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Class.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Class.pm Mon Dec  7 12:58:04 2009
@@ -1,8 +1,8 @@
 use strict;
 use warnings;
 
-package Boilerplater::Binding::Perl::Class;
-use Boilerplater::Util qw( verify_args );
+package Clownfish::Binding::Perl::Class;
+use Clownfish::Util qw( verify_args );
 use Carp;
 
 our %registry;
@@ -29,12 +29,12 @@
     confess("$self->{class_name} already registered")
         if exists $registry{ $self->{class_name} };
 
-    # Retrieve Boilerplater::Class client, if it will be needed.
+    # Retrieve Clownfish::Class client, if it will be needed.
     if (   $self->{bind_methods}
         || $self->{bind_constructors}
         || $self->{make_pod} )
     {
-        $self->{client} = Boilerplater::Class->fetch_singleton(
+        $self->{client} = Clownfish::Class->fetch_singleton(
             parcel     => $self->{parcel},
             class_name => $self->{class_name},
         );
@@ -58,7 +58,7 @@
 sub constructor_bindings {
     my $self = shift;
     my @bound = map {
-        my $xsub = Boilerplater::Binding::Perl::Constructor->new(
+        my $xsub = Clownfish::Binding::Perl::Constructor->new(
             class => $self->{client},
             alias => $_,
         );
@@ -109,7 +109,7 @@
             next unless $real_method;
 
             # Create the binding, add it to the array.
-            my $method_binding = Boilerplater::Binding::Perl::Method->new(
+            my $method_binding = Clownfish::Binding::Perl::Method->new(
                 method => $real_method,
                 %$bind_args,
             );
@@ -376,14 +376,14 @@
 
 =head1 NAME
 
-Boilerplater::Binding::Perl::Class - Generate Perl binding code for a
-Boilerplater::Class.
+Clownfish::Binding::Perl::Class - Generate Perl binding code for a
+Clownfish::Class.
 
 =head1 CLASS METHODS
 
 =head1 register
 
-    Boilerplater::Binding::Perl::Class->register(
+    Clownfish::Binding::Perl::Class->register(
         parcel       => 'Boil',                               # required
         class_name   => 'Foo::FooJr',                         # required
         bind_methods => [qw( Do_Stuff _get_foo|Get_Foo )],    # default: undef
@@ -394,20 +394,20 @@
 
 Create a new class binding and lodge it in the registry.  May only be called
 once for each unique class name, and must be called after all classes have
-been parsed (via Boilerplater::Hierarchy's build()).
+been parsed (via Clownfish::Hierarchy's build()).
 
 =over
 
-=item * B<parcel> - A L<Boilerplater::Parcel> or parcel name.
+=item * B<parcel> - A L<Clownfish::Parcel> or parcel name.
 
 =item * B<class_name> - The name of the class to be registered.
 
 =item * B<xs_code> - Raw XS code to be included in the final .xs file
-generated by Boilerplater::Binding::Perl. The XS directives PACKAGE and
+generated by Clownfish::Binding::Perl. The XS directives PACKAGE and
 MODULE should be specified.
 
 =item * B<bind_methods> - An array of names for novel methods for which XS
-bindings should be auto-generated, supplied using Boilerplater's C<Macro_Name>
+bindings should be auto-generated, supplied using Clownfish's C<Macro_Name>
 method-naming convention.  The Perl subroutine name will be derived by
 lowercasing C<Method_Name> to C<method_name>, but this can be overridden by
 prepending an alias and a pipe: e.g. C<_get_foo|Get_Foo>.
@@ -425,34 +425,34 @@
 
 =head1 registry
 
-    my $registry = Boilerplater::Binding::Perl::Class->registry;
+    my $registry = Clownfish::Binding::Perl::Class->registry;
     while ( my $class_name, $class_binding ) = each %$registry ) {
         ...
     }
 
 Return the hash registry used by register().  The keys are class names, and
-the values are Boilerplater::Binding::Perl::Class objects.
+the values are Clownfish::Binding::Perl::Class objects.
 
 =head1 OBJECT METHODS
 
 =head2 get_class_name get_bind_methods get_bind_methods get_make_pod
 get_xs_code get_client
 
-Accessors.  C<get_client> retrieves the Boilerplater::Class module to be
+Accessors.  C<get_client> retrieves the Clownfish::Class module to be
 bound.
 
 =head2 constructor_bindings
 
     my @ctor_bindings = $class_binding->constructor_bindings;
 
-Return a list of Boilerplater::Binding::Perl::Constructor objects created as
+Return a list of Clownfish::Binding::Perl::Constructor objects created as
 per the C<bind_constructors> spec.
 
 =head2 method_bindings
 
     my @method_bindings = $class_binding->method_bindings;
 
-Return a list of Boilerplater::Binding::Perl::Method objects created as per
+Return a list of Clownfish::Binding::Perl::Method objects created as per
 the C<bind_methods> spec.
 
 =head2 create_pod

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Constructor.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Constructor.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Constructor.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Constructor.pm Mon Dec  7 12:58:04 2009
@@ -1,11 +1,11 @@
 use strict;
 use warnings;
 
-package Boilerplater::Binding::Perl::Constructor;
-use base qw( Boilerplater::Binding::Perl::Subroutine );
+package Clownfish::Binding::Perl::Constructor;
+use base qw( Clownfish::Binding::Perl::Subroutine );
 use Carp;
-use Boilerplater::Binding::Perl::TypeMap qw( from_perl );
-use Boilerplater::ParamList;
+use Clownfish::Binding::Perl::TypeMap qw( from_perl );
+use Clownfish::ParamList;
 
 sub new {
     my ( $either, %args ) = @_;
@@ -147,11 +147,11 @@
 
 =head1 NAME
 
-Boilerplater::Binding::Perl::Constructor - Binding for an object method.
+Clownfish::Binding::Perl::Constructor - Binding for an object method.
 
 =head1 DESCRIPTION
 
-This class isa Boilerplater::Binding::Perl::Subroutine -- see its
+This class isa Clownfish::Binding::Perl::Subroutine -- see its
 documentation for various code-generating routines.
 
 Constructors are always bound to accept labeled params, even if there is only
@@ -161,14 +161,14 @@
 
 =head2 new
 
-    my $constructor_binding = Boilerplater::Binding::Perl::Constructor->new(
+    my $constructor_binding = Clownfish::Binding::Perl::Constructor->new(
         class => $class,
         alias => "_new|init2",
     );
 
 =over
 
-=item * B<class> - A L<Boilerplater::Class>.
+=item * B<class> - A L<Clownfish::Class>.
 
 =item * B<alias> - A specifier for the name of the constructor, and
 optionally, a specifier for the implementing function.  If C<alias> has a pipe

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Method.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Method.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Method.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Method.pm Mon Dec  7 12:58:04 2009
@@ -1,10 +1,10 @@
 use strict;
 use warnings;
 
-package Boilerplater::Binding::Perl::Method;
-use base qw( Boilerplater::Binding::Perl::Subroutine );
-use Boilerplater::Util qw( verify_args );
-use Boilerplater::Binding::Perl::TypeMap qw( from_perl to_perl );
+package Clownfish::Binding::Perl::Method;
+use base qw( Clownfish::Binding::Perl::Subroutine );
+use Clownfish::Util qw( verify_args );
+use Clownfish::Binding::Perl::TypeMap qw( from_perl to_perl );
 use Carp;
 
 our %new_PARAMS = ( 
@@ -285,11 +285,11 @@
 
 =head1 NAME
 
-Boilerplater::Binding::Perl::Method - Binding for an object method.
+Clownfish::Binding::Perl::Method - Binding for an object method.
 
 =head1 DESCRIPTION
 
-This class isa Boilerplater::Binding::Perl::Subroutine -- see its
+This class isa Clownfish::Binding::Perl::Subroutine -- see its
 documentation for various code-generating routines.
 
 Method bindings use labeled parameters if the C function takes more than one
@@ -300,13 +300,13 @@
 
 =head2 new
 
-    my $binding = Boilerplater::Binding::Perl::Method->new(
+    my $binding = Clownfish::Binding::Perl::Method->new(
         method => $method,    # required
     );
 
 =over
 
-=item * B<method> - A L<Boilerplater::Method>.
+=item * B<method> - A L<Clownfish::Method>.
 
 =back
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Subroutine.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Subroutine.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Subroutine.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/Subroutine.pm Mon Dec  7 12:58:04 2009
@@ -1,14 +1,14 @@
 use strict;
 use warnings;
 
-package Boilerplater::Binding::Perl::Subroutine;
+package Clownfish::Binding::Perl::Subroutine;
 use Carp;
-use Boilerplater::Class;
-use Boilerplater::Function;
-use Boilerplater::Method;
-use Boilerplater::Variable;
-use Boilerplater::ParamList;
-use Boilerplater::Util qw( verify_args );
+use Clownfish::Class;
+use Clownfish::Function;
+use Clownfish::Method;
+use Clownfish::Variable;
+use Clownfish::ParamList;
+use Clownfish::Util qw( verify_args );
 
 our %new_PARAMS = (
     param_list         => undef,
@@ -121,8 +121,8 @@
 
 =head1 NAME
 
-Boilerplater::Binding::Perl::Subroutine - Abstract base binding for a
-Boilerplater::Function.
+Clownfish::Binding::Perl::Subroutine - Abstract base binding for a
+Clownfish::Function.
 
 =head1 SYNOPSIS
 
@@ -130,7 +130,7 @@
 
 =head1 DESCRIPTION
 
-This class is used to generate binding code for invoking Boilerplater's
+This class is used to generate binding code for invoking Clownfish's
 functions and methods across the Perl/C barrier.
 
 =head1 METHODS
@@ -149,7 +149,7 @@
 
 =over
 
-=item * B<param_list> - A L<Boilerplater::ParamList>.
+=item * B<param_list> - A L<Clownfish::ParamList>.
 
 =item * B<alias> - The local, unqualified name for the Perl subroutine that
 will be used to invoke the function.
@@ -157,7 +157,7 @@
 =item * B<class_name> - The name of the Perl class that the subroutine belongs
 to.
 
-=item * B<retval_type> - The return value's L<Type|Boilerplater::Type>.
+=item * B<retval_type> - The return value's L<Type|Clownfish::Type>.
 
 =item * B<use_labeled_params> - True if the binding should take hash-style
 labeled parameters, false if it should take positional arguments.

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/TypeMap.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/TypeMap.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/TypeMap.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Binding/Perl/TypeMap.pm Mon Dec  7 12:58:04 2009
@@ -1,7 +1,7 @@
 use strict;
 use warnings;
 
-package Boilerplater::Binding::Perl::TypeMap;
+package Clownfish::Binding::Perl::TypeMap;
 use base qw( Exporter );
 use Scalar::Util qw( blessed );
 use Carp;
@@ -64,7 +64,7 @@
     chy_bool_t => sub {"$_[0] = newSViv( $_[1] );"},
 );
 
-# Extract a Boilerplater object from a Perl SV.
+# Extract a Clownfish object from a Perl SV.
 sub _sv_to_bp_obj {
     my ( $type, $bp_var, $xs_var, $stack_var ) = @_;
     my $struct_sym = $type->get_specifier;
@@ -97,8 +97,8 @@
 
 sub from_perl {
     my ( $type, $bp_var, $xs_var, $stack_var ) = @_;
-    confess("Not a Boilerplater::Type")
-        unless blessed($type) && $type->isa('Boilerplater::Type');
+    confess("Not a Clownfish::Type")
+        unless blessed($type) && $type->isa('Clownfish::Type');
 
     if ( $type->is_object ) {
         return _sv_to_bp_obj( $type, $bp_var, $xs_var, $stack_var );
@@ -119,8 +119,8 @@
 
 sub to_perl {
     my ( $type, $xs_var, $bp_var ) = @_;
-    confess("Not a Boilerplater::Type")
-        unless ref($type) && $type->isa('Boilerplater::Type');
+    confess("Not a Clownfish::Type")
+        unless ref($type) && $type->isa('Clownfish::Type');
     my $type_str = $type->to_c;
 
     if ( $type->is_object ) {
@@ -273,12 +273,12 @@
 
 =head1 NAME
 
-Boilerplater::Binding::Perl::TypeMap - Convert between BP and Perl via XS.
+Clownfish::Binding::Perl::TypeMap - Convert between BP and Perl via XS.
 
 =head1 DESCRIPTION
 
 TypeMap serves up C code fragments for translating between Perl data
-structures and Boilerplater data structures.  The functions to_perl() and
+structures and Clownfish data structures.  The functions to_perl() and
 from_perl() achieve this for individual types; write_xs_typemap() exports all
 types using the XS "typemap" format documented in C<perlxs>.
 
@@ -295,7 +295,7 @@
 
 =over
 
-=item * B<type> - A Boilerplater::Type, which will be used to select the
+=item * B<type> - A Clownfish::Type, which will be used to select the
 mapping code.
 
 =item * B<bp_var> - The name of the variable being assigned to.
@@ -304,10 +304,10 @@
 a value.
 
 =item * B<stack_var> - Only required needed when C<type> is
-Boilerplater::Object indicating that C<bp_var> is an either an Obj or a
-CharBuf.  When passing strings or other simple types to Boilerplater functions
+Clownfish::Object indicating that C<bp_var> is an either an Obj or a
+CharBuf.  When passing strings or other simple types to Clownfish functions
 from Perl, we allow the user to supply simple scalars rather than forcing them
-to create Boilerplater objects.  We do this by creating a ZombieCharBuf on the
+to create Clownfish objects.  We do this by creating a ZombieCharBuf on the
 stack and assigning the string from the Perl scalar to it.  C<stack_var> is
 the name of that ZombieCharBuf wrapper.  
 
@@ -324,7 +324,7 @@
 
 =over
 
-=item * B<type> - A Boilerplater::Type, which will be used to select the
+=item * B<type> - A Clownfish::Type, which will be used to select the
 mapping code.
 
 =item * B<xs_var> - The C name of the Perl scalar being assigned to.
@@ -338,13 +338,13 @@
 
 =head2 write_xs_typemap 
 
-    Boilerplater::Binding::Perl::Typemap->write_xs_typemap(
+    Clownfish::Binding::Perl::Typemap->write_xs_typemap(
         hierarchy => $hierarchy,
     );
 
 =over
 
-=item * B<hierarchy> - A L<Boilerplater::Hierarchy>.
+=item * B<hierarchy> - A L<Clownfish::Hierarchy>.
 
 =back 
 
@@ -352,7 +352,7 @@
 L<perlxs>.  
 
 We generate this file on the fly rather than maintain a static copy because we
-want an entry for each Boilerplater type so that we can differentiate between
+want an entry for each Clownfish type so that we can differentiate between
 them when checking arguments.  Keeping the entries up-to-date manually as
 classes come and go would be a pain.
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/CBlock.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/CBlock.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/CBlock.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/CBlock.pm Mon Dec  7 12:58:04 2009
@@ -1,8 +1,8 @@
 use strict;
 use warnings;
 
-package Boilerplater::CBlock;
-use Boilerplater::Util qw( verify_args );
+package Clownfish::CBlock;
+use Clownfish::Util qw( verify_args );
 use Carp;
 
 our %new_PARAMS = ( contents => undef, );
@@ -27,7 +27,7 @@
 
 =head1 NAME
 
-Boilerplater::CBlock - A block of embedded C code.
+Clownfish::CBlock - A block of embedded C code.
 
 =head1 DESCRIPTION
 
@@ -55,7 +55,7 @@
 
 =head2 new
 
-    my $c_block = Boilerplater::CBlock->new(
+    my $c_block = Clownfish::CBlock->new(
         contents => $text,
     );
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Class.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Class.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Class.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Class.pm Mon Dec  7 12:58:04 2009
@@ -1,17 +1,17 @@
 use strict;
 use warnings;
 
-package Boilerplater::Class;
-use base qw( Boilerplater::Symbol );
+package Clownfish::Class;
+use base qw( Clownfish::Symbol );
 use Carp;
 use Config;
-use Boilerplater::Function;
-use Boilerplater::Method;
-use Boilerplater::Util qw(
+use Clownfish::Function;
+use Clownfish::Method;
+use Clownfish::Util qw(
     verify_args
     a_isa_b
 );
-use Boilerplater::Dumpable;
+use Clownfish::Dumpable;
 use File::Spec::Functions qw( catfile );
 use Scalar::Util qw( reftype );
 
@@ -32,7 +32,7 @@
     exposure          => 'parcel',
 );
 
-my $dumpable = Boilerplater::Dumpable->new;
+my $dumpable = Clownfish::Dumpable->new;
 
 our %registry;
 
@@ -57,8 +57,8 @@
     # Maybe prepend parcel prefix.
     my $parcel = $args{parcel};
     if ( defined $parcel ) {
-        if ( !a_isa_b( $parcel, "Boilerplater::Parcel" ) ) {
-            $parcel = Boilerplater::Parcel->singleton( name => $parcel );
+        if ( !a_isa_b( $parcel, "Clownfish::Parcel" ) ) {
+            $parcel = Clownfish::Parcel->singleton( name => $parcel );
         }
         $key = $parcel->get_prefix . $key;
     }
@@ -66,7 +66,7 @@
     return $registry{$key};
 }
 
-sub new { confess("The constructor for Boilerplater::Class is create()") }
+sub new { confess("The constructor for Clownfish::Class is create()") }
 
 sub create {
     my ( $class_class, %args ) = @_;
@@ -100,16 +100,16 @@
 
     # Verify that members of supplied arrays meet "is a" requirements.
     for ( @{ $self->{functions} } ) {
-        confess("Not a Boilerplater::Function")
-            unless a_isa_b( $_, 'Boilerplater::Function' );
+        confess("Not a Clownfish::Function")
+            unless a_isa_b( $_, 'Clownfish::Function' );
     }
     for ( @{ $self->{methods} } ) {
-        confess("Not a Boilerplater::Method")
-            unless a_isa_b( $_, 'Boilerplater::Method' );
+        confess("Not a Clownfish::Method")
+            unless a_isa_b( $_, 'Clownfish::Method' );
     }
     for ( @{ $self->{member_vars} }, @{ $self->{inert_vars} } ) {
-        confess("Not a Boilerplater::Variable")
-            unless a_isa_b( $_, 'Boilerplater::Variable' );
+        confess("Not a Clownfish::Variable")
+            unless a_isa_b( $_, 'Clownfish::Variable' );
     }
 
     # Assume that Foo::Bar should be found in Foo/Bar.h.
@@ -224,7 +224,7 @@
 
 sub add_method {
     my ( $self, $method ) = @_;
-    confess("Not a Method") unless a_isa_b( $method, "Boilerplater::Method" );
+    confess("Not a Method") unless a_isa_b( $method, "Clownfish::Method" );
     confess("Can't call add_method after grow_tree") if $self->{tree_grown};
     confess("Can't add_method to an inert class")    if $self->{inert};
     push @{ $self->{methods} }, $method;
@@ -333,16 +333,16 @@
 
 =head1 NAME
 
-Boilerplater::Class - An object representing a single class definition.
+Clownfish::Class - An object representing a single class definition.
 
 =head1 CONSTRUCTORS
 
-Boilerplater::Class objects are stored as quasi-singletons, one for each
+Clownfish::Class objects are stored as quasi-singletons, one for each
 unique parcel/class_name combination.
 
 =head2 fetch_singleton 
 
-    my $class = Boilerplater::Class->fetch_singleton(
+    my $class = Clownfish::Class->fetch_singleton(
         parcel     => 'Boil',
         class_name => 'Foo::Bar',
     );
@@ -351,7 +351,7 @@
 
 =head2 create
 
-    my $class = Boilerplater::Class->create(
+    my $class = Clownfish::Class->create(
         parcel            => 'Boil',        # default: special
         class_name        => 'Foo::FooJr',  # required
         cnick             => 'FooJr',       # default: derived from class_name
@@ -373,7 +373,7 @@
 =over
 
 =item * B<parcel>, B<class_name>, B<cnick>, B<exposure> - see
-L<Boilerplater::Symbol>.
+L<Clownfish::Symbol>.
 
 =item * B<source_class> - The name of the class that owns the file in which
 this class was declared.  Should be "Foo" if "Foo::FooJr" is defined in
@@ -385,18 +385,18 @@
 =item * B<inert> - Should be true if the class is inert, i.e. cannot be
 instantiated.
 
-=item * B<methods> - An array where each element is a Boilerplater::Method.
+=item * B<methods> - An array where each element is a Clownfish::Method.
 
-=item * B<functions> - An array where each element is a Boilerplater::Method.
+=item * B<functions> - An array where each element is a Clownfish::Method.
 
 =item * B<member_vars> - An array where each element is a
-Boilerplater::Variable and should be a member variable in each instantiated
+Clownfish::Variable and should be a member variable in each instantiated
 object.
 
 =item * B<inert_vars> - An array where each element is a
-Boilerplater::Variable and should be a shared (class) variable.
+Clownfish::Variable and should be a shared (class) variable.
 
-=item * B<docucomment> - A Boilerplater::DocuComment describing this Class.
+=item * B<docucomment> - A Clownfish::DocuComment describing this Class.
 
 =item * B<attributes> - An arbitrary hash of attributes.
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/DocuComment.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/DocuComment.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/DocuComment.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/DocuComment.pm Mon Dec  7 12:58:04 2009
@@ -1,7 +1,7 @@
 use strict;
 use warnings;
 
-package Boilerplater::DocuComment;
+package Clownfish::DocuComment;
 use Carp;
 
 our %new_PARAMS = (
@@ -90,7 +90,7 @@
 
 =head1 NAME
 
-Boilerplater::DocuComment - Formatted comment a la Doxygen.
+Clownfish::DocuComment - Formatted comment a la Doxygen.
 
 =head1 SYNOPSIS
 
@@ -104,19 +104,19 @@
      * @return a return value.
      */
     END_COMMENT
-    my $docucomment = Boilerplater::DocuComment->parse($text);
+    my $docucomment = Clownfish::DocuComment->parse($text);
 
 =head1 CONSTRUCTORS 
 
 =head2 parse 
 
-    my $self = Boilerplater::DocuComment->parse($text);
+    my $self = Clownfish::DocuComment->parse($text);
 
 Parse comment text.
 
 =head2 new
 
-    my $self = Boilerplater::DocuComment->new(
+    my $self = Clownfish::DocuComment->new(
         description => "Brief.  Start long.  More long.",
         brief       => "Brief.",
         long        => "Long start. More long.",

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Dumpable.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Dumpable.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Dumpable.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Dumpable.pm Mon Dec  7 12:58:04 2009
@@ -1,12 +1,12 @@
 use strict;
 use warnings;
 
-package Boilerplater::Dumpable;
+package Clownfish::Dumpable;
 use Carp;
-use Boilerplater::Class;
-use Boilerplater::Type;
-use Boilerplater::Method;
-use Boilerplater::Variable;
+use Clownfish::Class;
+use Clownfish::Type;
+use Clownfish::Method;
+use Clownfish::Variable;
 
 sub new {
     my $either = shift;
@@ -32,21 +32,21 @@
     }
 }
 
-# Create a Boilerplater::Method object for either Dump() or Load().
+# Create a Clownfish::Method object for either Dump() or Load().
 sub _make_method_obj {
     my ( $self, $class, $dump_or_load ) = @_;
-    my $return_type = Boilerplater::Type::Object->new(
+    my $return_type = Clownfish::Type::Object->new(
         incremented => 1,
         specifier   => 'Obj',
         indirection => 1,
         parcel      => $class->get_parcel,
     );
-    my $self_type = Boilerplater::Type::Object->new(
+    my $self_type = Clownfish::Type::Object->new(
         specifier   => $class->get_struct_sym,
         indirection => 1,
         parcel      => $class->get_parcel,
     );
-    my $self_var = Boilerplater::Variable->new(
+    my $self_var = Clownfish::Variable->new(
         type      => $self_type,
         parcel    => $class->get_parcel,
         micro_sym => 'self',
@@ -55,24 +55,24 @@
     my $param_list;
     if ( $dump_or_load eq 'Dump' ) {
         $param_list
-            = Boilerplater::ParamList->new( variables => [$self_var], );
+            = Clownfish::ParamList->new( variables => [$self_var], );
     }
     else {
-        my $dump_type = Boilerplater::Type::Object->new(
+        my $dump_type = Clownfish::Type::Object->new(
             specifier   => 'Obj',
             indirection => 1,
             parcel      => $class->get_parcel,
         );
-        my $dump_var = Boilerplater::Variable->new(
+        my $dump_var = Clownfish::Variable->new(
             type      => $dump_type,
             parcel    => $class->get_parcel,
             micro_sym => 'dump',
         );
-        $param_list = Boilerplater::ParamList->new(
+        $param_list = Clownfish::ParamList->new(
             variables => [ $self_var, $dump_var ], );
     }
 
-    return Boilerplater::Method->new(
+    return Clownfish::Method->new(
         parcel      => $class->get_parcel,
         return_type => $return_type,
         class_name  => $class->get_class_name,
@@ -228,11 +228,11 @@
 
 =head1 NAME
 
-Boilerplater::Dumpable - Auto-generate code for "dumpable" classes.
+Clownfish::Dumpable - Auto-generate code for "dumpable" classes.
 
 =head1 SYNOPSIS
 
-    my $dumpable = Boilerplater::Dumpable->new;
+    my $dumpable = Clownfish::Dumpable->new;
     for my $class ( grep { $_->has_attribute('dumpable') } @classes ) {
         $dumpable->add_dumpables($class);
     }
@@ -240,7 +240,7 @@
 =head1 DESCRIPTION
 
 If a class declares that it has the attribute "dumpable", but does not declare
-either Dump or Load(), Boilerplater::Dumpable will attempt to auto-generate
+either Dump or Load(), Clownfish::Dumpable will attempt to auto-generate
 those methods if methods inherited from the parent class do not suffice.
 
     class Foo::Bar extends Foo : dumpable {
@@ -257,7 +257,7 @@
 
 =head2 new
 
-    my $dumpable = Boilerplater::Dumpable->new;
+    my $dumpable = Clownfish::Dumpable->new;
 
 Constructor.  Takes no arguments.
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/File.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/File.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/File.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/File.pm Mon Dec  7 12:58:04 2009
@@ -1,9 +1,9 @@
 use strict;
 use warnings;
 
-package Boilerplater::File;
-use Boilerplater::Util qw( verify_args a_isa_b );
-use Boilerplater::Parcel;
+package Clownfish::File;
+use Clownfish::Util qw( verify_args a_isa_b );
+use Clownfish::Parcel;
 use Scalar::Util qw( blessed );
 use File::Spec::Functions qw( catfile );
 use Carp;
@@ -28,15 +28,15 @@
     if ( defined $self->{parcel} ) {
         if ( !blessed( $self->{parcel} ) ) {
             $self->{parcel}
-                = Boilerplater::Parcel->singleton( name => $self->{parcel} );
+                = Clownfish::Parcel->singleton( name => $self->{parcel} );
         }
-        confess("Not a Boilerplater::Parcel")
-            unless $self->{parcel}->isa('Boilerplater::Parcel');
+        confess("Not a Clownfish::Parcel")
+            unless $self->{parcel}->isa('Clownfish::Parcel');
     }
     for my $block ( @{ $self->{blocks} } ) {
-        next if a_isa_b( $block, "Boilerplater::Parcel" );
-        next if a_isa_b( $block, "Boilerplater::Class" );
-        next if a_isa_b( $block, "Boilerplater::CBlock" );
+        next if a_isa_b( $block, "Clownfish::Parcel" );
+        next if a_isa_b( $block, "Clownfish::Class" );
+        next if a_isa_b( $block, "Clownfish::CBlock" );
         confess("Invalid block: $block");
     }
     confess("Missing required param 'source_class'")
@@ -53,7 +53,7 @@
 sub classes {
     my $self = shift;
     return
-        grep { ref $_ and $_->isa('Boilerplater::Class') }
+        grep { ref $_ and $_->isa('Clownfish::Class') }
         @{ $self->{blocks} };
 }
 
@@ -101,18 +101,18 @@
 
 =head1 NAME
 
-Boilerplater::File - Structured representation of the contents of a
-Boilerplater source file.
+Clownfish::File - Structured representation of the contents of a
+Clownfish source file.
 
 =head1 DESCRIPTION
 
-An abstraction representing a file which contains Boilerplater code.
+An abstraction representing a file which contains Clownfish code.
 
 =head1 METHODS
 
 =head2 new
 
-    my $file_obj = Boilerplater::File->new(
+    my $file_obj = Clownfish::File->new(
         blocks       => \@blocks,            # required
         source_class => 'Dog::Dalmation',    # required
         parcel       => 'Dog',               # default: special
@@ -121,7 +121,7 @@
 =over
 
 =item * B<blocks> - An arrayref.  Each element must be either a
-Boilerplater::Class, a Boilerplater::Parcel, or a Boilerplater::CBlock.
+Clownfish::Class, a Clownfish::Parcel, or a Clownfish::CBlock.
 
 =item * B<source_class> - The class name associated with the source file,
 regardless of how what classes are defined in the source file. Example: If
@@ -129,7 +129,7 @@
 at 'Foo/Bar.bp' within the source directory and that the output C header file
 should be 'Foo/Bar.h' within the target include directory.
 
-=item * B<parcel> - A Boilerplater::Parcel or parcel name.
+=item * B<parcel> - A Clownfish::Parcel or parcel name.
 
 =back
 
@@ -143,7 +143,7 @@
 
     my @classes = $file->classes;
 
-Return all Boilerplater::Class blocks from the file as a list.
+Return all Clownfish::Class blocks from the file as a list.
 
 =head2 get_modified set_modified
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Function.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Function.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Function.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Function.pm Mon Dec  7 12:58:04 2009
@@ -1,12 +1,12 @@
 use strict;
 use warnings;
 
-package Boilerplater::Function;
-use base qw( Boilerplater::Symbol );
+package Clownfish::Function;
+use base qw( Clownfish::Symbol );
 use Carp;
-use Boilerplater::Util qw( verify_args a_isa_b );
-use Boilerplater::Type;
-use Boilerplater::ParamList;
+use Clownfish::Util qw( verify_args a_isa_b );
+use Clownfish::Type;
+use Clownfish::ParamList;
 
 my %new_PARAMS = (
     return_type => undef,
@@ -32,9 +32,9 @@
     confess("Invalid micro_sym: '$self->{micro_sym}'")
         unless $self->{micro_sym} =~ /^[a-z0-9_]+$/;
     confess 'param_list must be a ParamList object'
-        unless a_isa_b( $self->{param_list}, "Boilerplater::ParamList" );
+        unless a_isa_b( $self->{param_list}, "Clownfish::ParamList" );
     confess 'return_type must be a Type object'
-        unless a_isa_b( $self->{return_type}, "Boilerplater::Type" );
+        unless a_isa_b( $self->{return_type}, "Clownfish::Type" );
 
     return $self;
 }
@@ -57,13 +57,13 @@
 
 =head1 NAME
 
-Boilerplater::Function - Metadata describing a function.
+Clownfish::Function - Metadata describing a function.
 
 =head1 METHODS
 
 =head2 new
 
-    my $type = Boilerplater::Function->new(
+    my $type = Clownfish::Function->new(
         class_name  => 'MyProject::FooFactory',    # required
         class_cnick => 'FooFact',                  # required
         return_type => $void_type                  # required
@@ -82,21 +82,21 @@
 
 =item * B<class_cnick> - The C nickname for the class. 
 
-=item * B<return_type> - A L<Boilerplater::Type> representing the function's
+=item * B<return_type> - A L<Clownfish::Type> representing the function's
 return type.
 
-=item * B<param_list> - A L<Boilerplater::ParamList> representing the
+=item * B<param_list> - A L<Clownfish::ParamList> representing the
 function's argument list.
 
 =item * B<micro_sym> - The lower case name of the function, without any
 namespacing prefixes.
 
-=item * B<docucomment> - A L<Boilerplater::DocuComment> describing the
+=item * B<docucomment> - A L<Clownfish::DocuComment> describing the
 function.
 
-=item * B<parcel> - A L<Boilerplater::Parcel> or a parcel name.
+=item * B<parcel> - A L<Clownfish::Parcel> or a parcel name.
 
-=item * B<exposure> - The function's exposure (see L<Boilerplater::Symbol>).
+=item * B<exposure> - The function's exposure (see L<Clownfish::Symbol>).
 
 =item * B<inline> - Should be true if the function should be inlined by the
 compiler.

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Hierarchy.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Hierarchy.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Hierarchy.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Hierarchy.pm Mon Dec  7 12:58:04 2009
@@ -1,16 +1,16 @@
 use strict;
 use warnings;
 
-package Boilerplater::Hierarchy;
+package Clownfish::Hierarchy;
 use Carp;
 use File::Find qw( find );
 use File::Spec::Functions qw( catfile splitpath );
 use File::Path qw( mkpath );
 use Fcntl;
 
-use Boilerplater::Util qw( slurp_file current verify_args );
-use Boilerplater::Class;
-use Boilerplater::Parser;
+use Clownfish::Util qw( slurp_file current verify_args );
+use Clownfish::Class;
+use Clownfish::Parser;
 
 our %new_PARAMS = (
     source => undef,
@@ -21,7 +21,7 @@
     my $either = shift;
     verify_args( \%new_PARAMS, @_ ) or confess $@;
     my $self = bless {
-        parser => Boilerplater::Parser->new,
+        parser => Clownfish::Parser->new,
         trees  => {},
         files  => {},
         %new_PARAMS,
@@ -168,22 +168,22 @@
 
 =head1 NAME
 
-Boilerplater::Hierarchy - A class hierarchy.
+Clownfish::Hierarchy - A class hierarchy.
 
 =head1 DESCRIPTION
 
-A Boilerplater::Hierarchy consists of all the classes defined in files within
+A Clownfish::Hierarchy consists of all the classes defined in files within
 a source directory and its subdirectories.
 
 There may be more than one tree within the Hierarchy, since all "inert"
-classes are root nodes, and since Boilerplater does not officially define any
+classes are root nodes, and since Clownfish does not officially define any
 core classes itself from which all instantiable classes must descend.
 
 =head1 METHODS
 
 =head2 new
 
-    my $hierarchy = Boilerplater::Hierarchy->new(
+    my $hierarchy = Clownfish::Hierarchy->new(
         source => undef,    # required
         dest   => undef,    # required
     );

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Method.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Method.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Method.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Method.pm Mon Dec  7 12:58:04 2009
@@ -1,9 +1,9 @@
 use strict;
 use warnings;
 
-package Boilerplater::Method;
-use base qw( Boilerplater::Function );
-use Boilerplater::Util qw( verify_args );
+package Clownfish::Method;
+use base qw( Clownfish::Function );
+use Clownfish::Util qw( verify_args );
 use Carp;
 
 my %new_PARAMS = (
@@ -164,14 +164,14 @@
 
 =head1 NAME
 
-Boilerplater::Method - Metadata describing an instance method.
+Clownfish::Method - Metadata describing an instance method.
 
 =head1 DESCRIPTION
 
-Boilerplater::Method is a specialized subclass of Boilerplater::Function, with
+Clownfish::Method is a specialized subclass of Clownfish::Function, with
 the first argument required to be an Obj.
 
-When compiling Boilerplater code to C, Method objects generate all the code
+When compiling Clownfish code to C, Method objects generate all the code
 that Function objects do, but also create symbols for indirect invocation via
 VTable.
 
@@ -179,7 +179,7 @@
 
 =head2 new
 
-    my $type = Boilerplater::Method->new(
+    my $type = Clownfish::Method->new(
         parcel      => 'MyProject'                 # default: special
         class_name  => 'MyProject::FooFactory',    # required
         class_cnick => 'FooFact ',                 # default: special
@@ -194,7 +194,7 @@
 
 =over
 
-=item * B<param_list> - A Boilerplater::ParamList.  The first element must be an
+=item * B<param_list> - A Clownfish::ParamList.  The first element must be an
 object of the class identified by C<class_name>.
 
 =item * B<macro_sym> - The mixed case name which will be used when invoking the
@@ -205,7 +205,7 @@
 =item * B<final> - Indicate whether the method is final.
 
 =item * B<parcel>, B<class_name>, B<class_cnick>, B<return_type>,
-B<docucomment>, - see L<Boilerplater::Function>.
+B<docucomment>, - see L<Clownfish::Function>.
 
 =back
 
@@ -221,7 +221,7 @@
 
 =head2 self_type
 
-Return the L<Boilerplater::Type> for C<self>.
+Return the L<Clownfish::Type> for C<self>.
 
 =head2 short_method_sym
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/ParamList.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/ParamList.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/ParamList.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/ParamList.pm Mon Dec  7 12:58:04 2009
@@ -1,9 +1,9 @@
 use strict;
 use warnings;
 
-package Boilerplater::ParamList;
-use Boilerplater::Variable;
-use Boilerplater::Util qw( verify_args );
+package Clownfish::ParamList;
+use Clownfish::Variable;
+use Clownfish::Util qw( verify_args );
 use Carp;
 
 our %new_PARAMS = (
@@ -22,7 +22,7 @@
         unless ref( $self->{variables} ) eq 'ARRAY';
     for my $var ( @{ $self->{variables} } ) {
         confess "invalid variable: '$var'"
-            unless ref($var) && $var->isa("Boilerplater::Variable");
+            unless ref($var) && $var->isa("Clownfish::Variable");
     }
 
     # Validate or init initial_values.
@@ -68,7 +68,7 @@
 
 =head1 NAME
 
-Boilerplater::ParamList - parameter list.
+Clownfish::ParamList - parameter list.
 
 =head1 DESCRIPTION
 
@@ -76,7 +76,7 @@
 
 =head2 new
 
-    my $type = Boilerplater::ParamList->new(
+    my $type = Clownfish::ParamList->new(
         variables      => \@vars,    # required
         initial_values => \@vals,    # default: undef
         variadic       => 1,         # default: false
@@ -85,7 +85,7 @@
 =over
 
 =item * B<variables> - An array where each element is a
-L<Boilerplater::Variable>. 
+L<Clownfish::Variable>. 
 
 =item * B<initial_values> - If supplied, an array of default values, one for
 each variable.

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Parcel.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Parcel.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Parcel.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Parcel.pm Mon Dec  7 12:58:04 2009
@@ -1,9 +1,9 @@
 use strict;
 use warnings;
 
-package Boilerplater::Parcel;
+package Clownfish::Parcel;
 use base qw( Exporter );
-use Boilerplater::Util qw( verify_args );
+use Clownfish::Util qw( verify_args );
 use Carp;
 
 our %parcels;
@@ -74,19 +74,19 @@
 
 =head1 NAME
 
-Boilerplater::Parcel - Collection of code.
+Clownfish::Parcel - Collection of code.
 
 =head1 DESCRIPTION
 
 A Parcel is a cohesive collection of code, which could, in theory, be
 published as as a single entity.
 
-Boilerplater supports two-tier manual namespacing, using a prefix, an optional
+Clownfish supports two-tier manual namespacing, using a prefix, an optional
 class nickname, and the local symbol:
 
   prefix_ClassNick_local_symbol
   
-Boilerplater::Parcel supports the first tier, specifying initial prefixes.
+Clownfish::Parcel supports the first tier, specifying initial prefixes.
 These prefixes come in three capitalization variants: prefix_, Prefix_, and
 PREFIX_.
 
@@ -94,7 +94,7 @@
 
 =head2 singleton 
 
-    Boilerplater::Parcel->singleton(
+    Clownfish::Parcel->singleton(
         name  => 'Crustacean',
         cnick => 'Crust',
     );
@@ -118,7 +118,7 @@
 
 =head2 default_parcel
 
-   $parcel ||= Boilerplater::Parcel->default_parcel;
+   $parcel ||= Clownfish::Parcel->default_parcel;
 
 Return the singleton for default parcel, which has no prefix.
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Parser.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Parser.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Parser.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Parser.pm Mon Dec  7 12:58:04 2009
@@ -1,34 +1,34 @@
 use strict;
 use warnings;
 
-package Boilerplater::Parser;
+package Clownfish::Parser;
 use base qw( Parse::RecDescent );
 
-use Boilerplater::Parcel;
-use Boilerplater::Type;
-use Boilerplater::Type::Primitive;
-use Boilerplater::Type::Integer;
-use Boilerplater::Type::Float;
-use Boilerplater::Type::Void;
-use Boilerplater::Type::VAList;
-use Boilerplater::Type::Arbitrary;
-use Boilerplater::Type::Object;
-use Boilerplater::Type::Composite;
-use Boilerplater::Variable;
-use Boilerplater::DocuComment;
-use Boilerplater::Function;
-use Boilerplater::Method;
-use Boilerplater::Class;
-use Boilerplater::CBlock;
-use Boilerplater::File;
+use Clownfish::Parcel;
+use Clownfish::Type;
+use Clownfish::Type::Primitive;
+use Clownfish::Type::Integer;
+use Clownfish::Type::Float;
+use Clownfish::Type::Void;
+use Clownfish::Type::VAList;
+use Clownfish::Type::Arbitrary;
+use Clownfish::Type::Object;
+use Clownfish::Type::Composite;
+use Clownfish::Variable;
+use Clownfish::DocuComment;
+use Clownfish::Function;
+use Clownfish::Method;
+use Clownfish::Class;
+use Clownfish::CBlock;
+use Clownfish::File;
 use Carp;
 
 our $grammar = <<'END_GRAMMAR';
 
 file:
-    { Boilerplater::Parser->set_parcel(undef); 0; }
+    { Clownfish::Parser->set_parcel(undef); 0; }
     major_block[%arg](s) eofile
-    { Boilerplater::Parser->new_file( \%item, \%arg ) }
+    { Clownfish::Parser->new_file( \%item, \%arg ) }
 
 major_block:
       class_declaration[%arg]
@@ -38,8 +38,8 @@
 parcel_definition:
     'parcel' class_name cnick(?) ';'
     { 
-        my $parcel = Boilerplater::Parser->new_parcel( \%item );
-        Boilerplater::Parser->set_parcel($parcel);
+        my $parcel = Clownfish::Parser->new_parcel( \%item );
+        Clownfish::Parser->set_parcel($parcel);
         $parcel;
     }
 
@@ -47,7 +47,7 @@
     '__C__'
     /.*?(?=__END_C__)/s  
     '__END_C__'
-    { Boilerplater::CBlock->new( contents => $item[2] ) }
+    { Clownfish::CBlock->new( contents => $item[2] ) }
 
 class_declaration:
     docucomment(?)
@@ -62,7 +62,7 @@
             parent => $item{'class_extension(?)'}[0],
         ](s?)
     '}'
-    { Boilerplater::Parser->new_class( \%item, \%arg ) }
+    { Clownfish::Parser->new_class( \%item, \%arg ) }
 
 class_modifier:
       'inert'
@@ -98,7 +98,7 @@
         $return = {
             exposure  => $item[1][0] || 'parcel',
             modifiers => $item[2],
-            declared  => Boilerplater::Parser->new_var( \%item, \%arg ),
+            declared  => Clownfish::Parser->new_var( \%item, \%arg ),
         };
     }
 
@@ -114,7 +114,7 @@
         $return = {
             exposure  => $item[2],
             modifiers => $item[3],
-            declared  => Boilerplater::Parser->new_sub( \%item, \%arg ),
+            declared  => Clownfish::Parser->new_sub( \%item, \%arg ),
         };
     }
 
@@ -124,7 +124,7 @@
     (/,\s*.../)(?)
     ')'
     {
-        Boilerplater::Parser->new_param_list( $item[2], $item[3][0] ? 1 : 0 );
+        Clownfish::Parser->new_param_list( $item[2], $item[3][0] ? 1 : 0 );
     }
 
 param_list_elem:
@@ -133,7 +133,7 @@
 
 param_variable:
     type declarator
-    { Boilerplater::Parser->new_var(\%item); }
+    { Clownfish::Parser->new_var(\%item); }
 
 assignment: 
     '=' scalar_constant
@@ -141,7 +141,7 @@
 
 type:
     simple_type type_postfix(s?)
-    { Boilerplater::Parser->simple_or_composite_type(\%item) }
+    { Clownfish::Parser->simple_or_composite_type(\%item) }
 
 simple_type:
       object_type
@@ -153,7 +153,7 @@
 
 object_type:
     type_qualifier(s?) object_type_specifier '*'
-    { Boilerplater::Parser->new_object_type(\%item); }
+    { Clownfish::Parser->new_object_type(\%item); }
 
 primitive_type:
       c_integer_type
@@ -163,27 +163,27 @@
 
 c_integer_type:
     type_qualifier(s?) c_integer_specifier
-    { Boilerplater::Parser->new_integer_type(\%item) }
+    { Clownfish::Parser->new_integer_type(\%item) }
 
 chy_integer_type:
     type_qualifier(s?) chy_integer_specifier
-    { Boilerplater::Parser->new_integer_type(\%item) }
+    { Clownfish::Parser->new_integer_type(\%item) }
 
 float_type:
     type_qualifier(s?) c_float_specifier
-    { Boilerplater::Parser->new_float_type(\%item) }
+    { Clownfish::Parser->new_float_type(\%item) }
 
 void_type:
     type_qualifier(s?) void_type_specifier
-    { Boilerplater::Parser->new_void_type(\%item) }
+    { Clownfish::Parser->new_void_type(\%item) }
 
 va_list_type:
     va_list_type_specifier
-    { Boilerplater::Type::VAList->new }
+    { Clownfish::Type::VAList->new }
 
 arbitrary_type:
     arbitrary_type_specifier
-    { Boilerplater::Parser->new_arbitrary_type(\%item); }
+    { Clownfish::Parser->new_arbitrary_type(\%item); }
 
 type_qualifier:
       'const' 
@@ -261,7 +261,7 @@
 
 docucomment:
     /\/\*\*.*?\*\//s
-    { Boilerplater::DocuComment->parse($item[1]) }
+    { Clownfish::DocuComment->parse($item[1]) }
 
 constant_expression:
       /\d+/
@@ -323,26 +323,26 @@
         || $item->{chy_integer_specifier};
     my %args = ( specifier => $specifier );
     $args{$_} = 1 for @{ $item->{'type_qualifier(s?)'} };
-    return Boilerplater::Type::Integer->new(%args);
+    return Clownfish::Type::Integer->new(%args);
 }
 
 sub new_float_type {
     my ( undef, $item ) = @_;
     my %args = ( specifier => $item->{c_float_specifier} );
     $args{$_} = 1 for @{ $item->{'type_qualifier(s?)'} };
-    return Boilerplater::Type::Float->new(%args);
+    return Clownfish::Type::Float->new(%args);
 }
 
 sub new_void_type {
     my ( undef, $item ) = @_;
     my %args = ( specifier => $item->{void_type_specifier} );
     $args{$_} = 1 for @{ $item->{'type_qualifier(s?)'} };
-    return Boilerplater::Type::Void->new(%args);
+    return Clownfish::Type::Void->new(%args);
 }
 
 sub new_arbitrary_type {
     my ( undef, $item ) = @_;
-    return Boilerplater::Type::Arbitrary->new(
+    return Clownfish::Type::Arbitrary->new(
         specifier => $item->{arbitrary_type_specifier},
         parcel    => $parcel,
     );
@@ -355,7 +355,7 @@
         parcel    => $parcel,
     );
     $args{$_} = 1 for @{ $item->{'type_qualifier(s?)'} };
-    return Boilerplater::Type::Object->new(%args);
+    return Clownfish::Type::Object->new(%args);
 }
 
 sub simple_or_composite_type {
@@ -380,7 +380,7 @@
                 $args{indirection}++;
             }
         }
-        return Boilerplater::Type::Composite->new(%args);
+        return Clownfish::Type::Composite->new(%args);
     }
 }
 
@@ -392,7 +392,7 @@
         $args{class_name}  = $arg->{class} if $arg->{class};
         $args{class_cnick} = $arg->{cnick} if $arg->{cnick};
     }
-    return Boilerplater::Variable->new(
+    return Clownfish::Variable->new(
         parcel    => $parcel,
         type      => $item->{type},
         micro_sym => $item->{declarator},
@@ -404,7 +404,7 @@
     my ( undef, $param_list_elems, $variadic ) = @_;
     my @vars = map { $_->[0] } @$param_list_elems;
     my @vals = map { $_->[1] } @$param_list_elems;
-    return Boilerplater::ParamList->new(
+    return Clownfish::ParamList->new(
         variables      => \@vars,
         initial_values => \@vals,
         variadic       => $variadic,
@@ -421,12 +421,12 @@
     my %extra_args = $exposure ? ( exposure => $exposure ) : ();
 
     if ($inert) {
-        $class = 'Boilerplater::Function';
+        $class = 'Clownfish::Function';
         $extra_args{micro_sym} = $item->{declarator};
         $extra_args{inline} = scalar grep { $_ eq 'inline' } @$modifiers;
     }
     else {
-        $class = 'Boilerplater::Method';
+        $class = 'Clownfish::Method';
         $extra_args{macro_sym} = $item->{declarator};
         $extra_args{abstract} = scalar grep { $_ eq 'abstract' } @$modifiers;
         $extra_args{final}    = scalar grep { $_ eq 'final' } @$modifiers;
@@ -460,7 +460,7 @@
         my $subs      = $inert ? \@functions : \@methods;
         my $vars      = $inert ? \@inert_vars : \@member_vars;
 
-        if ( $declared->isa('Boilerplater::Variable') ) {
+        if ( $declared->isa('Clownfish::Variable') ) {
             push @$vars, $declared;
         }
         else {
@@ -468,7 +468,7 @@
         }
     }
 
-    return Boilerplater::Class->create(
+    return Clownfish::Class->create(
         parcel            => $parcel,
         class_name        => $item->{class_name},
         cnick             => $item->{'cnick(?)'}[0],
@@ -488,7 +488,7 @@
 sub new_file {
     my ( undef, $item, $arg ) = @_;
 
-    return Boilerplater::File->new(
+    return Clownfish::File->new(
         parcel       => $parcel,
         blocks       => $item->{'major_block(s)'},
         source_class => $arg->{source_class},
@@ -497,7 +497,7 @@
 
 sub new_parcel {
     my ( undef, $item ) = @_;
-    Boilerplater::Parcel->singleton(
+    Clownfish::Parcel->singleton(
         name  => $item->{class_name},
         cnick => $item->{'cnick(?)'}[0],
     );
@@ -511,7 +511,7 @@
 
 =head1 NAME
 
-Boilerplater::Parser - Parse Boilerplater header files.
+Clownfish::Parser - Parse Clownfish header files.
 
 =head1 SYNOPSIS
 
@@ -519,7 +519,7 @@
 
 =head1 DESCRIPTION
 
-Boilerplater::Parser is a combined lexer/parser which parses .bp code.  It is
+Clownfish::Parser is a combined lexer/parser which parses .bp code.  It is
 not at all strict, as it relies heavily on the C parser to pick up errors such
 as misspelled type names.
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Symbol.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Symbol.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Symbol.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Symbol.pm Mon Dec  7 12:58:04 2009
@@ -1,9 +1,9 @@
 use strict;
 use warnings;
 
-package Boilerplater::Symbol;
-use Boilerplater::Parcel;
-use Boilerplater::Util qw( a_isa_b );
+package Clownfish::Symbol;
+use Clownfish::Parcel;
+use Clownfish::Util qw( a_isa_b );
 use Scalar::Util qw( blessed );
 use Carp;
 
@@ -24,14 +24,14 @@
     # Acquire a Parcel.
     my $parcel = $args{parcel};
     if ( !defined $parcel ) {
-        $parcel = Boilerplater::Parcel->default_parcel;
+        $parcel = Clownfish::Parcel->default_parcel;
     }
     elsif ( blessed($parcel) ) {
-        confess("Not a Boilerplater::Parcel")
-            unless $parcel->isa('Boilerplater::Parcel');
+        confess("Not a Clownfish::Parcel")
+            unless $parcel->isa('Clownfish::Parcel');
     }
     else {
-        $parcel = Boilerplater::Parcel->singleton( name => $args{parcel} );
+        $parcel = Clownfish::Parcel->singleton( name => $args{parcel} );
     }
 
     # Create the object.
@@ -121,11 +121,11 @@
 
 =head1 NAME
 
-Boilerplater::Symbol - Abstract base class for Boilerplater symbols.
+Clownfish::Symbol - Abstract base class for Clownfish symbols.
 
 =head1 DESCRIPTION
 
-Boilerplater::Symbol serves as an abstract parent class for entities which may
+Clownfish::Symbol serves as an abstract parent class for entities which may
 live in the global namespace, such as classes, functions, methods, and
 variables.
 
@@ -141,7 +141,7 @@
 
 =over
 
-=item * B<parcel> - A Boilerplater::Parcel, or a string that can be used to
+=item * B<parcel> - A Clownfish::Parcel, or a string that can be used to
 create/retrieve one.  If not supplied, will be assigned to the default Parcel.
 
 =item * B<exposure> - The scope in which the symbol is exposed.  Must be

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Type.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Type.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Type.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Type.pm Mon Dec  7 12:58:04 2009
@@ -1,9 +1,9 @@
 use strict;
 use warnings;
 
-package Boilerplater::Type;
-use Boilerplater::Parcel;
-use Boilerplater::Util qw( verify_args );
+package Clownfish::Type;
+use Clownfish::Parcel;
+use Clownfish::Util qw( verify_args );
 use Scalar::Util qw( blessed );
 use Carp;
 
@@ -25,10 +25,10 @@
     if ( defined $self->{parcel} ) {
         if ( !blessed( $self->{parcel} ) ) {
             $self->{parcel}
-                = Boilerplater::Parcel->singleton( name => $self->{parcel} );
+                = Clownfish::Parcel->singleton( name => $self->{parcel} );
         }
-        confess("Not a Boilerplater::Parcel")
-            unless $self->{parcel}->isa('Boilerplater::Parcel');
+        confess("Not a Clownfish::Parcel")
+            unless $self->{parcel}->isa('Clownfish::Parcel');
     }
     return $self;
 }
@@ -63,7 +63,7 @@
 
 =head1 NAME
 
-Boilerplater::Type - A variable's type.
+Clownfish::Type - A variable's type.
 
 =head1 METHODS
 
@@ -97,7 +97,7 @@
 
 =item *
 
-B<parcel> - A Boilerplater::Parcel or a parcel name.
+B<parcel> - A Clownfish::Parcel or a parcel name.
 
 =item *
 
@@ -109,8 +109,8 @@
 
     do_stuff() if $type->equals($other);
 
-Returns true if two Boilerplater::Type objects are equivalent.  The default
-implementation merely checks that C<$other> is a Boilerplater::Type object, so
+Returns true if two Clownfish::Type objects are equivalent.  The default
+implementation merely checks that C<$other> is a Clownfish::Type object, so
 it should be overridden in all subclasses.
 
 =head2 to_c
@@ -136,23 +136,23 @@
 
 =over
 
-=item * is_object: Boilerplater::Type::Object
+=item * is_object: Clownfish::Type::Object
 
-=item * is_primitive: Boilerplater::Type::Primitive
+=item * is_primitive: Clownfish::Type::Primitive
 
-=item * is_integer: Boilerplater::Type::Integer
+=item * is_integer: Clownfish::Type::Integer
 
-=item * is_floating: Boilerplater::Type::Float
+=item * is_floating: Clownfish::Type::Float
 
-=item * is_void: Boilerplater::Type::Void
+=item * is_void: Clownfish::Type::Void
 
-=item * is_composite: Boilerplater::Type::Composite
+=item * is_composite: Clownfish::Type::Composite
 
 =back
 
 =head2 is_string_type
 
-Returns true if $type represents a Boilerplater type which holds unicode
+Returns true if $type represents a Clownfish type which holds unicode
 strings.
 
 =head1 COPYRIGHT AND LICENSE

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Arbitrary.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Arbitrary.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Arbitrary.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Arbitrary.pm Mon Dec  7 12:58:04 2009
@@ -1,9 +1,9 @@
 use strict;
 use warnings;
 
-package Boilerplater::Type::Arbitrary;
-use base qw( Boilerplater::Type );
-use Boilerplater::Util qw( verify_args );
+package Clownfish::Type::Arbitrary;
+use base qw( Clownfish::Type );
+use Clownfish::Util qw( verify_args );
 use Scalar::Util qw( blessed );
 use Carp;
 
@@ -52,13 +52,13 @@
 
 =head1 NAME
 
-Boilerplater::Type::Arbitrary - An arbitrary type.
+Clownfish::Type::Arbitrary - An arbitrary type.
 
 =head1 DESCRIPTION
 
 The "arbitrary" type class is a hack that spares us from having to support C
 types with complex declaration syntaxes -- such as unions, structs, enums, or
-function pointers -- from within Boilerplater itself.
+function pointers -- from within Clownfish itself.
 
 The only constraint is that the C<specifier> must end in "_t".  This allows us
 to create complex types in a C header file...
@@ -74,7 +74,7 @@
 
 =head2 new
 
-    my $type = Boilerplater::Type->new(
+    my $type = Clownfish::Type->new(
         specifier => 'floatint_t',    # required
         parcel    => 'Boil',          # default: undef
     );
@@ -83,7 +83,7 @@
 
 =item * B<specifier> - The name of the type, which must end in "_t".
 
-=item * B<parcel> - A L<Boilerplater::Parcel> or a parcel name.
+=item * B<parcel> - A L<Clownfish::Parcel> or a parcel name.
 
 =back
 

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Composite.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Composite.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Composite.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Composite.pm Mon Dec  7 12:58:04 2009
@@ -1,9 +1,9 @@
 use strict;
 use warnings;
 
-package Boilerplater::Type::Composite;
-use base qw( Boilerplater::Type );
-use Boilerplater::Util qw( verify_args a_isa_b );
+package Clownfish::Type::Composite;
+use base qw( Clownfish::Type );
+use Clownfish::Util qw( verify_args a_isa_b );
 use Scalar::Util qw( blessed );
 use Carp;
 
@@ -18,7 +18,7 @@
     my $array = delete $args{array};
     my $child = delete $args{child};
     confess("Missing required param 'child'")
-        unless a_isa_b( $child, "Boilerplater::Type" );
+        unless a_isa_b( $child, "Clownfish::Type" );
     verify_args( \%new_PARAMS, %args ) or confess $@;
     my $self = $either->SUPER::new(%args);
     $self->{child} = $child;
@@ -59,13 +59,13 @@
 
 =head1 NAME
 
-Boilerplater::Type::Composite - A composite type, e.g. Obj**.
+Clownfish::Type::Composite - A composite type, e.g. Obj**.
 
 =head1 METHODS
 
 =head2 new
 
-    my $type = Boilerplater::Type::Composite->new(
+    my $type = Clownfish::Type::Composite->new(
         specifier   => 'char',    # required
         indirection => undef,     # default 0
         array       => '[]',      # default undef,

Modified: lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Float.pm
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Float.pm?rev=887915&r1=887914&r2=887915&view=diff
==============================================================================
--- lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Float.pm (original)
+++ lucene/lucy/trunk/clownfish/lib/Clownfish/Type/Float.pm Mon Dec  7 12:58:04 2009
@@ -1,9 +1,9 @@
 use strict;
 use warnings;
 
-package Boilerplater::Type::Float;
-use base qw( Boilerplater::Type::Primitive );
-use Boilerplater::Util qw( verify_args );
+package Clownfish::Type::Float;
+use base qw( Clownfish::Type::Primitive );
+use Clownfish::Util qw( verify_args );
 use Carp;
 
 our %new_PARAMS = (
@@ -38,12 +38,12 @@
 
 =head1 NAME
 
-Boilerplater::Type::Float - A primitive Type representing a floating point
+Clownfish::Type::Float - A primitive Type representing a floating point
 number.
 
 =head1 DESCRIPTION
 
-Boilerplater::Type::Float represents floating point types of various widths.
+Clownfish::Type::Float represents floating point types of various widths.
 Currently only two are supported:
 
     float
@@ -53,7 +53,7 @@
 
 =head2 new
 
-    my $type = Boilerplater::Type::Float->new(
+    my $type = Clownfish::Type::Float->new(
         const     => 1,           # default: undef
         specifier => 'double',    # required
     );



Mime
View raw message