Shlomi,
On May 8, 2008, at 3:41 PM, Shlomi Fish wrote:
Hi all!
Shlomif's Tenth Law of Perl OOP: "Every sufficiently complex
Class::Accessor
program contains contains an ad hoc, informally-specified, bug-
ridden, slow
implementation of half of Moose."
Very nice, I like that quote, if you don't mind I will likely include
it in the YAPC::NA talk I am gonna give.
Skimming over your code, I think you could save a lot of code by
moving to Moose, and using some MooseX:: (specifically
MooseX::AttribtueHelpers, MooseX::Object::Pluggable, and likely a few
more too).
You will find, as others who are porting other Class::Accessor code
to Moose, that there are some Class::Accessor-isms that conflict with
Moose-isms so be watchful during the port. Otherwise, i think you
will find you can clean up your code pretty well using Moose :)
- Stevan
(see http://en.wikipedia.org/wiki/Greenspun's_Tenth_Rule ).
I used Class::Accessor for Test-Run ( see
http://freshmeat.net/projects/test-run/ ), because that's what I
was used to
using, and found the easiest solution, but ended up implementing a
lot of
extra Object Orientation logic (and not-so-OO logic) in Test-Run-
Base and in
other classes, and wonder if I can use Moose (possibly with some
extra MooseX
plugins, to replace it. I can possibly write some of my own plugins.
Here goes. The files in question are at:
http://xrl.us/bka2c - Test::Run::Base:
# Contains an abstraction above Text::Sprintf::Named, that allows a
class to
format strings using Python-like "%(attribute)s" escapes. Useful as a
mini-templating language. I might mostly ditch it completely in
favour of
Template Toolkit.
In turn I maintain a set of compiled formatters as an object-based
property,
and can format according them.
# Has a silly copy_from() method to copy a list of attributes from
another
object using the accessors.
# accum_array():
<<<<<<<<<<<
This is a more simplistic version of the :CUMULATIVE functionality
in Class::Std. It was done to make sure that one can collect all the
members of array refs out of methods defined in each class into one
big
array ref, that can later be used.
# $self->_run_sequence([EMAIL PROTECTED])
<<<<<<<<<<<<
Runs the sequence of commands specified using
C<_calc__${calling_sub}__callbacks> while passing @params to
each one. Generates a list of all the callbacks return values.
# package->delegate_methods($field, [EMAIL PROTECTED])
I think this would be trivial to do using Moose.
# http://xrl.us/bka67 - Test::Run::Base::Struct
These are classes whose constructors (the ->new() subroutines) can
only be
passed proper pre-defined fields. It's very hacky and ad-hoc at the
moment,
so I'm open for better Moose-based solutions.
# http://xrl.us/bkba3 - Test::Run::Base::Plugger
# http://xrl.us/bkba5 - Test::Run::Base::PlugHelpers
Two plugin-abstractions. For more information see:
http://use.perl.org/~Shlomi+Fish/journal/33492
I also have some other OO and other abstractions stuff there spread
around the
code, but I think that's the main thing.
I'd appreciate any pointers to how I can implement these things
using Moose so
I can convert Test-Run to it.
Regards,
Shlomi Fish
-----------------------------------------------------------------
Shlomi Fish http://www.shlomifish.org/
The Case for File Swapping - http://xrl.us/bjn7i
The bad thing about hardware is that it sometimes work and
sometimes doesn't.
The good thing about software is that it's consistent: it always
does not
work, and it always does not work in exactly the same way.