File Coverage

blib/lib/HTTP/ProxyPAC.pm

Criterion	Covered	Total	%
statement	71	93	76.3
branch	24	44	54.5
condition	14	24	58.3
subroutine	15	16	93.7
pod	2	6	33.3
total	126	183	68.8

package HTTP::ProxyPAC;

use strict;
our $VERSION = '0.31';

use Carp;
use Scalar::Util qw(blessed);
use URI;

my ($useJE, $usePerlLib);

BEGIN {
    # prevent error message when running standalone
    if   (-e 'blib/HTTP/ProxyPAC/Functions.pm') {use lib 'blib'}
    elsif (-e 'lib/HTTP/ProxyPAC/Functions.pm') {use lib 'lib'}

    require HTTP::ProxyPAC::Functions;
    require HTTP::ProxyPAC::Result;
}
our $UserAgent;

sub new {
    my $class = shift;
    my $stuff = shift;

    my %options = @_;

    if ($options{interp} && $options{interp} =~ /javascript|js/i) {
      eval "use JavaScript";
      if ($@) {
        if (-e "t/00_compile.t") {return}
        die $@;
    } } elsif ($options{interp} && $options{interp} =~ /je/i) {
      require JE;
      $useJE = 1;
    } else {
      eval "use JavaScript";
      if ($@) {
        my $atJS = $@;
        eval "use JE";
        if ($@) {
            die "neither the JavaScript module nor the JS module seems to be available\n"
              . "use JavaScript reports: $atJS\nuse JE reports: $@";
        } else {$useJE = 1}
      }
    }
    $usePerlLib = $options{lib} && $options{lib} =~ /perl/i;

    if (blessed($stuff) && $stuff->isa('URI')) {
        return $class->init( $class->load_uri($stuff) );
    }
    elsif (blessed($stuff) && $stuff->isa('IO::Handle')) {
        return $class->init( $class->load_fh($stuff) );
    }
    elsif (ref($stuff) && ref($stuff) eq 'GLOB') {
        return $class->init( $class->load_fh($stuff) );
    }
    elsif (ref($stuff) && ref($stuff) eq 'SCALAR') {
        return $class->init( $$stuff );
    }
    elsif (!ref($stuff)) {
        return $class->init( $class->load_file($stuff) );
    }
    else {
        Carp::croak("Unknown reference type to HTTP::ProxyPAC->new: ", ref($stuff));
    }
}

sub load_uri {
    my($class, $uri) = @_;

    $UserAgent ||= do {
        require LWP::UserAgent;
        LWP::UserAgent->new(agent => __PACKAGE__ . "/" . $VERSION);
    };

    my $res = $UserAgent->get($uri);

    if ($res->content_type ne "application/x-ns-proxy-autoconfig") {
        Carp::croak("Content-Type should be application/x-ns-proxy-autoconfig, is ",
                    $res->content_type);
    }
    return $res->content;
}

sub load_fh {
    my($class, $fh) = @_;
    read($fh, my($body), -s $fh);
    $body;
}

sub load_file {
    my($class, $file) = @_;

    open my $fh, $file or Carp::croak("$file: $!");
    my $body = $class->load_fh($fh);
    close $fh;

    $body;
}


sub init {
    my ($class, $code) = @_;
    my ($func, $runtime, $context);

    if ($useJE) {
        $runtime = new JE::;
    } else {
        $runtime = JavaScript::Runtime->new;
        $context = $runtime->create_context();
    }
    for $func ($usePerlLib ? @HTTP::ProxyPAC::Functions::PACFunctions
                           : @HTTP::ProxyPAC::Functions::baseFunctions) {
        no strict 'refs';
        if ($useJE) {
            $runtime->new_function($func => sub { &{"HTTP::ProxyPAC::Functions::$func"}(@_) });
        } else {
            $context->bind_function(name => $func,
                                    func => sub { &{"HTTP::ProxyPAC::Functions::$func"}(@_) });
    }   }
    # if we are using the JS library functions from Mozilla, include them before the .pac file
    if (!$usePerlLib) {$code = HTTP::ProxyPAC::Functions::nsProxyAutoConfig . $code}

    if ($useJE) {
        $runtime->eval($code);
        bless { context => $runtime }, $class;
    } else {
        $context->eval($code);
        bless { context => $context }, $class;
}   }

sub find_proxy {
    my($self, $url) = @_;

    Carp::croak("Usage: find_proxy(url)") unless defined $url;

    $url = URI->new($url);

    # there is a PAC file for the interpreter to interpret
     my $res = $self->{context}->eval(sprintf("FindProxyForURL('%s', '%s')",
                                                 $url->as_string, $url->host));

     my @res = HTTP::ProxyPAC::Result->parse($res, $url);
     return wantarray ? @res : $res[0];
}

1;
__END__