MozRepl - Perl interface of MozRepl

    use strict;
    use warnings;

    use MozRepl;

    my $repl = MozRepl->new;
    $repl->setup; ### You must write it.

    $repl->execute(q|window.alert("Internet Explorer:<")|);

    print $repl->repl_inspect({ source => "window" });
    print $repl->repl_search({ pattern => "^getElement", source => "document"});

    $repl->setup({
        client => {
            extra_client_args => {
                binmode => 1
            }
        }
    });

    $repl->setup_log([qw/info warn error fatal/]);

    my $repl = MozRepl->new;
    $repl->log($another_log_instance);
    $repl->setup($config);

package MozRepl;

use strict;
use warnings;

use base qw(Class::Accessor::Fast Class::Data::Inheritable);

__PACKAGE__->mk_accessors($_) for (qw/client log plugins repl search/);
__PACKAGE__->mk_classdata($_) for (qw/log_class client_class/);

__PACKAGE__->log_class('MozRepl::Log');
__PACKAGE__->client_class('MozRepl::Client');

use Text::SimpleTable;
use UNIVERSAL::require;

use MozRepl::Util;

our $VERSION = '0.06';

sub new {
    my ($class, $args) = @_;

    if (exists $args->{search} && ref $args->{search} eq 'ARRAY') {
        unshift(@{$args->{search}}, "MozRepl::Plugin");
        my %seen = ();
        $args->{search} = [grep { ++$seen{$_} } @{$args->{search}}];
    }
    else {
        $args->{search} = ["MozRepl::Plugin"];
    }

    my $pluggable = "Module::Pluggable::Fast";

    my %param = (
        "require" => 1,
        "name" => "__load_plugins",
        "search" => $args->{search}
    );

    $pluggable->use(%param);

    my $self = $class->SUPER::new({
        client => undef,
        log => undef,
        repl => 'repl',
        plugins => {},
        search => $args->{search}
    });

    return $self;
}

sub setup {
    my ($self, $args) = @_;

    $self->setup_log($args->{log});
    $self->setup_client($args->{client});

    if ($self->log->is_debug) {
        my $table = Text::SimpleTable->new([15, 'type'], [60, 'module']);
        $table->row('logging', $self->log_class);
        $table->row('client', $self->client_class);
        $self->log->debug("---- Delegating classes ----\n" . $table->draw);
    }

    $self->setup_plugins($args->{plugins});
}

sub setup_log {
    my ($self, $args) = @_;

    $args ||= [qw/debug info warn error fatal/];

    ### skip already exists log instance
    unless ($self->log) {
        $self->log_class->use;
        $self->log($self->log_class->new(@$args));
    }
    else {
        $self->log_class(ref $self->log);
    }

    return unless ($self->log->is_debug);

    $self->log->debug('MozRepl logging enabled');
}

sub setup_client {
    my ($self, $args) = @_;

    $self->client_class->use;
    $self->client($self->client_class->new($self, $args));
    $self->client->setup($self);
}

sub setup_plugins {
    my ($self, $args) = @_;

    $self->plugins({});

    my @plugins = $self->load_plugins($args);

    for my $plugin (@plugins) {
        $self->setup_plugin($plugin, $args);
    }
}

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

    return if ($self->enable_plugin($plugin));

    my $plugin_obj = $plugin->new($args);
    $plugin_obj->setup($self, $args);

    my $method = MozRepl::Util->plugin_to_method($plugin, $self->search);

    unless ($self->can($method)) {
        no strict 'refs';

        $self->log->debug('define method : ' . $method);

        *{__PACKAGE__ . "::" . $method} = sub {
            my ($repl, @args) = @_;
            $plugin_obj->execute($repl, @args);
        };
    }

    $self->plugins->{$plugin} = $plugin_obj;
}

sub load_plugins {
    my ($self, $args) = @_;

    my @available_plugins = grep { $_ ne 'MozRepl::Plugin::Base' } $self->__load_plugins;
    my %plugins = ();
    my %except_plugins = ();

    $self->log->debug(sprintf("Available plugins (%d)", scalar(@available_plugins)));

    if ($self->log->is_debug && @available_plugins) {
        my $table = Text::SimpleTable->new([80, 'Available plugin']);
        $table->row($_) for (@available_plugins);
        $self->log->debug("---- Available plugin list ----\n" . $table->draw);
    }

    return if (@available_plugins == 0);

    if ($args->{plugins} && ref $args->{plugins} eq 'ARRAY') {
        $plugins{$_} = 1 for (map { MozRepl::Util->canonical_plugin_name($_) } @{$args->{plugins}});
    }
    else {
        @plugins{@available_plugins} = map { 1 } @available_plugins;
    }

    if ($args->{except_plugins} && ref $args->{except_plugins} eq 'ARRAY') {
        $except_plugins{$_} = 1 for (map { MozRepl::Util->canonical_plugin_name($_) } @{$args->{except_plugins}});
    }

    my @plugins = 
        grep { $plugins{$_} }
        grep { !$except_plugins{$_} }
        grep { $_ ne "MozRepl::Plugin::Base" }
            @available_plugins;

    $self->log->debug(sprintf("Load plugins (%d)", scalar(@plugins)));

    if ($self->log->is_debug && @plugins) {
        my $table = Text::SimpleTable->new([80, 'Load plugin']);
        $table->row($_) for (@plugins);
        $self->log->debug("---- Load plugin list ----\n" . $table->draw);
    }

    wantarray ? @plugins : \@plugins;
}

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

    return ((grep { $_ eq $plugin } keys %{$self->plugins}) == 1) ? 1 : 0;
}

sub execute {
    my ($self, $command) = @_;

    $self->client->execute($self, $command);
}

sub finalize {
    my ($self, $args) = @_;

    $self->client->quit;
}

1; # End of MozRepl