pbot/PBot/Plugins.pm

# File: Plugins.pm
# Author: pragma-
#
# Purpose: Loads and manages plugins.

# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

package PBot::Plugins;
use parent 'PBot::Class';

use warnings; use strict;
use feature 'unicode_strings';

use File::Basename;

sub initialize {
    my ($self, %conf) = @_;
    $self->{plugins} = {};
    $self->{pbot}->{commands}->register(sub { $self->load_cmd(@_) },   "plug",     1);
    $self->{pbot}->{commands}->register(sub { $self->unload_cmd(@_) }, "unplug",   1);
    $self->{pbot}->{commands}->register(sub { $self->reload_cmd(@_) }, "replug",   1);
    $self->{pbot}->{commands}->register(sub { $self->list_cmd(@_) },   "pluglist", 0);
}

sub autoload {
    my ($self, %conf) = @_;
    return if $self->{pbot}->{registry}->get_value('plugins', 'noautoload');

    my $path     = $self->{pbot}->{registry}->get_value('general', 'plugin_dir') // 'Plugins';
    my $data_dir = $self->{pbot}->{registry}->get_value('general', 'data_dir');

    $self->{pbot}->{logger}->log("Loading plugins ...\n");
    my $plugin_count = 0;

    my $fh;
    if (not open $fh, "<$data_dir/plugin_autoload") {
        $self->{pbot}->{logger}->log("warning: file $data_dir/plugin_autoload does not exist; skipping autoloading of Plugins\n");
        return;
    }

    chomp(my @plugins = <$fh>);
    close $fh;

    foreach my $plugin (sort @plugins) {
        $plugin = basename $plugin;
        $plugin =~ s/.pm$//;

        # do not load plugins that begin with a comment
        next if $plugin =~ m/^\s*#/;

        $plugin_count++ if $self->load($plugin, %conf);
    }
    $self->{pbot}->{logger}->log("$plugin_count plugin" . ($plugin_count == 1 ? '' : 's') . " loaded.\n");
}

sub load {
    my ($self, $plugin, %conf) = @_;

    $self->unload($plugin);

    return if $self->{pbot}->{registry}->get_value('plugins', 'disabled');

    my $path = $self->{pbot}->{registry}->get_value('general', 'plugin_dir') // 'Plugins';

    if (not grep { $_ eq $path } @INC) {
        unshift @INC, $path;
    }

    $self->{pbot}->{refresher}->{refresher}->refresh_module("$path/$plugin.pm");

    my $ret = eval {
        require "$path/$plugin.pm";

        if ($@) {
            chomp $@;
            $self->{pbot}->{logger}->log("Error loading $plugin: $@\n");
            return 0;
        }

        $self->{pbot}->{logger}->log("Loading $plugin\n");
        my $class = "Plugins::$plugin";
        $self->{plugins}->{$plugin} = $class->new(pbot => $self->{pbot}, %conf);
        $self->{pbot}->{refresher}->{refresher}->update_cache("$path/$plugin.pm");
        return 1;
    };

    if ($@) {
        chomp $@;
        $self->{pbot}->{logger}->log("Error loading $plugin: $@\n");
        return 0;
    }
    return $ret;
}

sub unload {
    my ($self, $plugin) = @_;

    if (exists $self->{plugins}->{$plugin}) {
        eval {
            $self->{plugins}->{$plugin}->unload;
            delete $self->{plugins}->{$plugin};
        };
        if ($@) {
            chomp $@;
            $self->{pbot}->{logger}->log("Warning: got error unloading plugin $plugin: $@\n");
        }

        my $path  = $self->{pbot}->{registry}->get_value('general', 'plugin_dir') // 'Plugins';
        my $class = $path;
        $class =~ s,[/\\],::,g;

        $self->{pbot}->{refresher}->{refresher}->unload_module($class . '::' . $plugin);
        $self->{pbot}->{refresher}->{refresher}->unload_subs("$path/$plugin.pm");

        $self->{pbot}->{logger}->log("Plugin $plugin unloaded.\n");
        return 1;
    } else {
        return 0;
    }
}

sub reload_cmd {
    my ($self, $from, $nick, $user, $host, $arguments) = @_;

    if (not length $arguments) { return "Usage: replug <plugin>"; }

    my $unload_result = $self->unload_cmd($from, $nick, $user, $host, $arguments);
    my $load_result   = $self->load_cmd($from, $nick, $user, $host, $arguments);

    my $result = "";
    $result .= "$unload_result " if $unload_result =~ m/^Unloaded/;
    $result .= $load_result;
    return $result;
}

sub load_cmd {
    my ($self, $from, $nick, $user, $host, $arguments) = @_;

    if (not length $arguments) { return "Usage: plug <plugin>"; }

    if   ($self->load($arguments)) { return "Loaded $arguments plugin."; }
    else                           { return "Plugin $arguments failed to load."; }
}

sub unload_cmd {
    my ($self, $from, $nick, $user, $host, $arguments) = @_;

    if (not length $arguments) { return "Usage: unplug <plugin>"; }

    if   ($self->unload($arguments)) { return "Unloaded $arguments plugin."; }
    else                             { return "Plugin $arguments is not loaded."; }
}

sub list_cmd {
    my ($self, $from, $nick, $user, $host, $arguments) = @_;
    my $result = "Loaded plugins: ";
    my $count  = 0;
    my $comma  = '';

    foreach my $plugin (sort keys %{$self->{plugins}}) {
        $result .= $comma . $plugin;
        $count++;
        $comma = ', ';
    }

    $result .= 'none' if $count == 0;
    return $result;
}

1;