This is a bold attempt at getting a decent implementation for
interfaces in Perl.
Especially Perl 5.6.x.
I am aware of the presence of 'Class::Contract' and 'interface'. And
are particulary charmed by the ease-of-use of the latter. However it
lacks some insight. Thus I decided to write my own; largely based on
the principles of 'interfaces'
INSTALL
The usual.
% perl Makefile.PL
% make && make test
# make install
HOWTO
Read `perldoc lib/Interfaces.pm` first.
For a good example of how things work have a looksy through
test-lib/test.pl and test-lib/Car/*.pm
DESIGN DECISISIONS
* I choose not to use an import method (as does 'interfaces'). Mainly
because I wanted to be able to distinctly show others what they are
dealing with (An interface or an implementation). Second to that I
wanted to be able to create abstract interfaces within the same
code. Abstracts are interfaces 2.
* I've tried to use Devel::Size and PPI to do inspection of the
interfaces (and make sure that they are clean and
unimplemented). Devel::Size gave me deviation headache. It turns out
that the size of each method grows as the amount of methods
grow. I am no good with algoritms so finding the greater deviations
was left as an excercise for a later day.
PPI was just 2 much for such a little project.
I have made an implementation where I just run through the file
looking for clues. With enough satisfaction it will just accept.
* I mangle the namespaces of interfaces and implementers because I
want strict enforcement of the interface paradigm. I recognize
that this may lead to problems, but I have been careful.
HOW ITS DONE
interface() and abstract()
When calling the L<interface()> method the namespace of the caller
is checked against the syntax rules.
When all is well the namespace gets overwritten with an import
method. This will cause a die if anyone other then implementing
classes try to use it (actually proxied by the Interface class
itself). 'main' has been freed from this death - you might want to
print $VERSION and you should be able to.
Also it will publish a brand new method into the namespace of the
package it was called from, called '__get_interface_methods__'.
This returns all the available methods.
When the class is an abstract it will create a method with the
name '__get_abstract_methods__'. This will only give back the
abstractly defined methods.
The abstract method(s) of the abstract class will be overwritten
so that they die telling you that the method is abstract and
cannot be invoked here.
implements() and extends()
When calling either method each given interface is polled for
it's methods by calling '__get_xxx_methods__'. Then the caller is
checked for the methods using UNIVERSAL::can.
If all are present the @ISA of the caller is extended with the
name of the interface.
The methods that are missing are collected before confessing so
you can fix it all at once.
TODO
- Figure out a way to make interface / abstract inspection even better
- Make Interfaces.pm adhere to Perl::Critic a bit more
