How can I code a factory in Perl and Moose?

Question

Is there a simpler or better (=>easier to maintain) way to use Perl and Moose to instantiate classes based on incoming data?

The following code is a stripped down sample from a project I'm working on.

package FooBar;
use Moose;
has 'SUBCLASS' =>('isa'=>'Str',required=>'1',is=>'ro');
has 'MSG' =>('isa'=>'Str',required=>'1',is=>'ro');

sub BUILD {
      my $self = shift;
      my ($a)=@_;
      bless($self,$a->{SUBCLASS})
}
sub Hi {
   my $self=shift;
   print "Hi, I'm a " . ref($self)  ." and I say [". $self->MSG()."]\n";
}

package Foo;
use Moose;
extends ("FooBar");

package Bar;
use Moose;
extends ("FooBar");

package main;
use strict;
use warnings;

for my $line (<DATA>) {
   my ($case,$msg)=split(/[\n\r,]\s*/,$line);
   FooBar->new(SUBCLASS=>$case,MSG=>$msg)->Hi();
}

__DATA__
Foo, First Case
Bar, Second Case

EDIT: It just struck me that this is pretty much what happens when you call the DBI. Depending on the parameters you pass, it will use entirely different code while maintaining a (mostly) consistent interface

Answer 1

You could simply do:

$case->new( MSG => $msg )->Hi();

If that is easier or better is up to you to decide.

Answer 2

Well, the object is already created when BUILD is called, so I would say

sub BUILD {
      my $self = shift;
      return bless $self, $self->SUBCLASS;
}

You may always wish to switch from an inheritance based model to a role based model where you create the object you want (rather than passing the class into the factory class), then apply the common role.

Answer 3

Ick. Stevan has a very compelling argument that new should always only return an instance of Class. Anything else is confusing to new people learning the system.

You might wanna take a look at MooseX::AbstractFactory. If that won't work for you then:

package FooBar;
use Moose;

has [qw(SUBCLASS MSG)] => ( is => 'ro', required => 1);

sub create_instance {
    return $self->package->new(message => $self->msg);
}

package FooBar::Object;
use Moose;

has msg => ( is => 'ro', required => 1);

sub Hi {
   my $self = shift;
   print "Hi, I'm a " . ref($self)  ." and I say [". $self->MSG()."]\n";
}

package Foo;
use Moose;
extends qw(FooBar::Object);

package Bar;
use Moose;
extends qw(FooBar::Object);


package main;
or my $line (<DATA>) {
   my ($case,$msg)=split(/[\n\r,]\s*/,$line);
   FooBar->new(SUBCLASS=>$case,MSG=>$msg)->create_instance->Hi
}

__DATA__
Foo, First Case
Bar, Second Case

Of course there are many other ways to implement this same concept in Moose. Without knowing the specifics of your domain problem it's hard to tell that something like MooseX::Traits wouldn't be better:

package Foo;
use Moose;
with qw(MooseX::Traits);

package Bar;
use Moose;
with qw(MooseX::Traits);

package Messaging;
use Moose::Role;

has msg => ( is => 'ro', required => 1);

sub Hi {
   my $self = shift;
   print "Hi, I'm a " . ref($self)  ." and I say [". $self->MSG()."]\n";
}

package main;
use strict;
Foo->new_with_traits(traits => ['Messaging'], msg => 'First Case')->Hi;

This is roughly what the other poster meant about using a Role based solution.

Answer 4

Just a note on some of the answers:

Calling bless in BUILD, or anywhere outside of the MOP internals, is always unacceptable. (If you must rebless, there is Class::MOP::Class->rebless_instance!)

I second the advice on not allowing new to return anything other than an instance of __PACKAGE__. If you want a method that creates an instance of something, call it something else. Example:

class Message {
   method new_from_string(Str $msg){
       my ($foo, $bar, $baz) = ($msg =~ /<...>/); # blah blah blah
       my $class = "Message::${foo}::$baz";
       Class::MOP::load_class($class);
       return $class->new( bar => $msg );
   }
}

Then, when you want to create a literal message:

Message->new( whatever => 'you want' );

When you want to parse a string and return the correct message subclass:

Message->new_from_string( 'OH::Hello!' );

Finally, if it doesn't make sense to be able to create an instance of Message, then it should not be a class. It should be a role.

You can handle building with some other object, of course. Just make sure this other object is responsible only for understanding the string format, for example, and not message internals:

class MessageString {
    has 'string' => ( initarg => 'string', reader => 'message_as_string' );

    method new_from_string(ClassName $class: Str $string) {
        return $class->new( string => $string );
    }

    method as_message_object {
        # <parse>
        return Message::Type->new( params => 'go here', ... );
    }
}

role Message { ... }
class Message::Type with Message { ... }

Now you are no longer concerned with having some "superclass" responsible for building "subclasses", which I think is better design. (Remember, MessageString has no special power over the classes that do "Message". That is the key here; it is only responsible for understanding stringified messages.)

Anyway, now you just:

my $data =  <>; # Yup, I called it $data.  Sorry, Andy Lester.
my $parsed = MessageString->new_from_string( $data );
my $message = $parsed->as_message_object;
$message->interact_with

(You know "MVC"? This is similar.)