view release on metacpan or  search on metacpan

lib/WWW/Mechanize/Shell.pm  view on Meta::CPAN

  perl -Ilib -MWWW::Mechanize::Chrome \
             -MWWW::Mechanize::Shell \
             -e"shell(agent => WWW::Mechanize::Chrome->new())"

=back

=cut

sub init {
  my ($self) = @_;
  my ($name,%args) = @{$self->{API}{args}};

  $self->{agent} = $args{ agent };
  if( ! $self->agent ) {
      my $class = $args{ agent_class } || 'WWW::Mechanize';
      my $args  = $args{ agent_args }  || [];
      $self->{agent} = $class->new( @$args );
  };

  $self->{formfiller} = WWW::Mechanize::FormFiller->new(default => [ Ask => $self ]);

  $self->{history} = [];

  $self->{options} = {
    autosync => 0,
    warnings => (exists $args{warnings} ? $args{warnings} : 1),
    autorestart => 0,
    watchfiles => (exists $args{watchfiles} ? $args{watchfiles} : 1),
    cookiefile => 'cookies.txt',
    dumprequests => 0,
    dumpresponses => 0,
		verbose => 0,
  };
  # Install the request dumper :
  $self->{request_wrapper} = wrap 'LWP::UserAgent::request',
      #pre => sub { printf STDERR "Dumping? %s\n",$self->option("dumprequests"); $self->request_dumper($_[1]) if $self->option("dumprequests"); },
      pre => sub { $self->request_dumper($_[1]) if $self->option("dumprequests"); },
      post => sub {
                    $self->response_dumper($_[-1]) if $self->option("dumpresponses");
                  };

  $self->{redirect_ok_wrapper} = wrap 'WWW::Mechanize::redirect_ok',
    post => sub {
        return unless $_[1];
        $self->status( "\nRedirecting to ".$_[1]->uri."\n" );
        $_[-1]
    };

  # Load the proxy settings from the environment
  $self->agent->env_proxy()
      if $self->agent->can('env_proxy');

  # Read our .rc file :
  # I could use File::Homedir, but the docs claim it dosen't work on Win32. Maybe
  # I should just release a patch for File::Homedir then... Not now.
  my $sourcefile;
  if (exists $args{rcfile}) {
    $sourcefile = delete $args{rcfile};
  } else {
    my $userhome = $^O =~ /win32/i ? $ENV{'USERPROFILE'} || $ENV{'HOME'} : ((getpwuid($<))[7]);
    $sourcefile = "$userhome/.mechanizerc"
      if -f "$userhome/.mechanizerc";
  };
  $self->option('cookiefile', $args{cookiefile}) if (exists $args{cookiefile});
  $self->source_file($sourcefile) if defined $sourcefile;
  $self->{browser} = undef;

  # Keep track of the files we consist of, to enable automatic reloading
  $self->{files} = undef;
  if ($self->option('watchfiles')) {
    eval {
      my @files = grep { -f && -r && $_ ne '-e' } values %INC;
      local $, = ",";
      require File::Modified;
      $self->{files} = File::Modified->new(files=>[@files]);
    };
    $self->display_user_warning( "Module File::Modified not found. Automatic reloading disabled.\n" )
      if ($@);
  };
};

=head2 C<$shell-E<gt>release_agent>

Since the shell stores a reference back to itself within the
WWW::Mechanize instance, it is necessary to break this
circular reference. This method does this.

=cut

sub release_agent {
  my ($self) = @_;
  use Data::Dumper;
  warn Dumper $self;
  undef $self->{request_wrapper};
  undef $self->{redirect_ok_wrapper};
  $self->{agent} = undef;
};

=head2 C<$shell-E<gt>source_file FILENAME>

The C<source_file> method executes the lines of FILENAME
as if they were typed in.

  $shell->source_file( $filename );

=cut

sub source_file {
  my ($self,$filename) = @_;
  local $_; # just to be on the safe side that we don't clobber outside users of $_
  local *F;
  open F, "< $filename"
    or die "Couldn't open '$filename' : $!\n";
  while (<F>) {
    $self->cmd($_);
    warn "cmd: $_"
      if $self->{options}->{verbose};
  };
  close F;
};