Jifty::Plugin - Describes a plugin to the Jifty framework

      Plugins:
        - SpiffyThing: {}
        - SomePlugin:
            arguments: to
            the: constructor

use strict;
use warnings;

package Jifty::Plugin;
use base qw/Class::Accessor::Fast Jifty::Object/;
__PACKAGE__->mk_accessors('_pre_init');

sub new {
    my $class = shift;
    my $self = $class->SUPER::new( { @_ });

    # Get a classloader set up
    Jifty::Util->require($class->dispatcher);

    # XXX TODO: Add .po path
    $self->init(@_);

    # XXX: If we have methods for halos, add them. Some way of detecting "are
    # we going to be using halos" would be superb. As it stands right now,
    # plugins are loaded, initialized, and prereq-examined in the order they're
    # listed in the config files. Instead, each phase should be separate.
    Jifty::Util->require("Jifty::Plugin::Halo");
    Jifty::Util->require("Jifty::View::Mason::Halo");

    if ($self->can('halo_pre_template')) {
        Jifty::Plugin::Halo->add_trigger(
            halo_pre_template => sub { $self->halo_pre_template(@_) },
        );
        Jifty::View::Mason::Halo->add_trigger(
            halo_pre_template => sub { $self->halo_pre_template(@_) },
        );
    }

    if ($self->can('halo_post_template')) {
        Jifty::Plugin::Halo->add_trigger(
            halo_post_template => sub { $self->halo_post_template(@_) },
        );
        Jifty::View::Mason::Halo->add_trigger(
            halo_post_template => sub { $self->halo_post_template(@_) },
        );
    }

    return $self;
}

sub init {
    1;
}

sub new_request {
}

sub _calculate_share {
    my $self  = shift;
    my $class = ref($self);

    unless ( $self->{share} and -d $self->{share} ) {
        # If we've got a Jifty in @INC, and the plugin is core, the
        # right thing to do is to strip off lib/ and replace it with
        # share/plugins/Jifty/Plugin/Whatever/
        my $class_to_path = $class;
        $class_to_path =~ s|::|/|g;

        $self->{share} = $INC{ $class_to_path . '.pm' };
        $self->{share} =~ s{lib/+\Q$class_to_path.pm}{share/plugins/$class_to_path};
        $self->{share} = File::Spec->rel2abs( $self->{share} );
    }
    unless ( $self->{share} and -d $self->{share} ) {
        # As above, but only tack on share/, for when we have a
        # non-core plugin in @INC.  We do this before the
        # File::ShareDir, because File::ShareDir only looks at install
        # locations, and the plugin could be hand-set in @INC.
        my $class_to_path = $class;
        $class_to_path =~ s|::|/|g;

        $self->{share} = $INC{ $class_to_path . '.pm' };
        $self->{share} =~ s{lib/+\Q$class_to_path.pm}{share};
        $self->{share} = File::Spec->rel2abs( $self->{share} );
    }
    unless ( $self->{share} and -d $self->{share} ) {
        # If it's an installed non-core plugin, File::ShareDir's
        # dist_dir will find it for us
        my $dist = $class;
        $dist =~ s/::/-/g;
        local $@;
        eval { $self->{share} = File::ShareDir::dist_dir($dist) };
    }
    unless ( $self->{share} and -d $self->{share} ) {
        # We try this last, so plugins that moved out of core, but
        # were installed at when they _were_ in core, will get the
        # updated plugin

        # Core plugins live in jifty's share/plugins/Jifty/Plugin/Whatever/
        my $class_to_path = $class;
        $class_to_path =~ s|::|/|g;
        $self->{share} = Jifty::Util->share_root;
        $self->{share} .= "/plugins/" . $class_to_path;
    }
    unless ( $self->{share} and -d $self->{share} ) {
        $self->{share} = undef;
    }
    return $self->{share};
}

sub template_root {
    my $self = shift;
    my $dir =  $self->_calculate_share();
    return unless $dir;
    return $dir."/web/templates";
}

sub po_root {
    my $self = shift;
    my $dir = $self->_calculate_share();
    return unless $dir;
    return $dir."/po";
}

sub template_class {
    my $self = shift;
    my $class = ref($self) || $self;
    return $class.'::View';
}

sub static_root {
    my $self = shift;
    my $dir =  $self->_calculate_share();
    return unless $dir;
    return $dir."/web/static";
}

sub dispatcher {
    my $self = shift;
    my $class = ref($self) || $self;
    return $class."::Dispatcher";
}

sub prereq_plugins {
    return ();
}

sub version {
    return '0.0.1';
}

sub bootstrapper {
    my $self = shift;
    my $class = ref $self;
    return $class . '::Bootstrap';
}

sub upgrade_class {
    my $self = shift;
    my $class = ref $self;
    return $class . '::Upgrade';
}

sub table_prefix {
    my $self = shift;
    my $class = ref $self;
    $class =~ s/\W+/_/g;
    $class .= '_';
    return lc $class;
}

sub wrap {
    my ($self, $app) = @_;
    return $app;
}

sub psgi_app_static {
    my $self = shift;
    my $static_root = $self->static_root;
    return unless defined $static_root && -d $static_root && -r $static_root;
    Plack::App::File->new(root => $static_root)->to_app
}

1;