NAME
Gloom - Gloom (the Great Little OO Module)
SYNOPSIS
In your "Makefile.PL":
use inc::Module::Install;
name 'MyMod';
use_gloom 'MyMod::OO';
then in "lib/MyMod/Foo.pm":
package MyMod::Foo;
use MyMod::OO -base;
has 'foo';
and:
package MyMod::Foo::Bar;
use MyMod::Foo -base;
has 'bar';
NOTE
Module::Install is not required to use Gloom. It just makes it a trivial
process. If you don't use Module::Install, you can manually copy/symlink
Gloom.pm to your "lib/MyMod/OO.pm".
DESCRIPTION
Gloom is a simple, clean and small OO base module. It can be used by
CPAN modules that need to be OO, but don't want to require a dependency
module to do it.
Gloom provides the OO basics like single inheritance, standard "new" and
"init" constructor methods, and "has" attribute accessors. It also turns
on "strict" and "warnings" automatically.
Gloom is cascading. Using Gloom as a base class for class "Foo", enables
"Foo" to later be used as a Gloomy base class. Using the "-base" syntax
invokes all the Gloom functionality.
WHENCE GLOOM?
Using basic idiomatic OO in Perl is problematic. Perl provides the
lowest level mechanisms, but this is not even the bare minimum that you
would find useable. You'd want at least an object constructor and
attribute accessors.
Moose and friends is the way to do serious OO right, but Moose has
issues too. Imagine you want to write a very simple CPAN module, and
want to do it in the OO style. Adding a Moose prerequisite feels like
adding an army tank to a flower arrangement. It's a huge installation
pain for your users if its not already installed, and it still carries a
startup performance penalty.
This is where Gloom comes in. Gloom is a CPAN module author's friend. It
provides Perl OO basics with No Dependency Prerequisites. You simply
copy or symlink "Gloom.pm" as your module's OO base module, then Gloom
will figure out the rest.
The great lesson of "Module::Install" is that you can fix deficiencies
in standard things like ExtUtils::MakeMaker or even "perl" itself, by
shipping a little extra code with each module. With Gloom, you always
ship Gloom.pm, renamed as your OO base module.
If you use Module::Install, all you need to do is add a line to your
"Makefile.PL" file. It will create a Gloom based OO module for you and
keep it up to date. Just imagine, all your Perl OO needs resolved with
one line in a Makefile.PL! See Module::Install::Gloom for details.
The great lesson of Spiffy was OO feature propagation/cascading. When a
module is a Gloom subclass, it can be used as a first-rate Gloom base
class.
Spiffy was not well received by some people because it used source
filtering for a couple unrelated things. Just for the record, Gloom uses
no source filtering or any other fancy magics.
Gloom has nothing except the OO primitives that everyone wants. Gloom
simply makes basic Perl OO something that you don't need to worry about
any more.
FEATURES
Gloom provides the following features:
Usage, Inheritance and Cascading
When you use a Gloom subclass module, you can pass it the "-base"
option to establish single inheritance to that module. In other
words, that module becomes your module's base or parent class.
package My::Foo;
use My::OO -base;
Now you are free to use My::Foo as a base class for some other
class:
package Your::Foo;
use My::Foo -base;
has 'what_you_want';
My::Foo has all the exact same powers of OO cascading as Gloom
itself.
Note that My::OO is an exact copy of Gloom.pm. You don't change
anything in the file. The code sees how it was called and adapts the
package name on the fly.
Constructor
Gloom has a "new()" class method. It creates an object and calls
"$self- >init(@_)".
The default "init()" method expects its arguments to be a list of
attribute name/value pairs. You can easily subclass "init()" to do
things differently.
Attribute Accessor Generators
Gloom provides "has" accessors that work exactly like the "field"
accessors from "Class::Field". ("has" is the Perl standard name for
attribute generators). The attributes are always read/write. They
provide an optional default value as well as an optional
initialization code snippet.
package Foo;
use Bar -base;
has 'this';
has 'that' => {}; # Defaults to a hash;
has 'thus', -init => '$self->set_thus';
You can also mark them to support method chaining:
has 'this', -chain;
has 'that';
$self->this('one')->that('two');
NOTE: Gloom "has()" is completely different in usage from Moose
"has()".
Exporting
Gloom and all its subclasses export the "has()" function. You can
have your base class export more things by simply defining the
Exporter variables, like:
our @EXPORT = qw(foo bar);
our @EXPORT_OK = qw(baz);
Other Stuff
Since the "has" generators always return a true value, you usually
don't need the annoying:
1;
line at the bottom of your Gloom based modules. The true value they
return is the Perl source code of the accessor. You can see this by
doing something like:
print has 'foo' -init => '$self->init_foo';
Like Moose, using Gloom (or any subclass of Gloom) as a base class,
will automagically do the equivalent of:
use strict;
use warnings;
REPOSITORY AND COMMUNITY
The Gloom module can be found on CPAN and on GitHub:
"/github.com/ingydotnet/gloom- pm" in http:.
Please join #gloom on irc.perl.org to discuss the new Gloom of Perl.
AUTHOR
ingy döt Net <ingy@cpan.org>
COPYRIGHT
Copyright 2010-2014. Ingy döt Net.
This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.
See <http://www.perl.com/perl/misc/Artistic.html>