RubyGems - javonet-ruby-sdk - Versions diffs - 2.1.1 → 2.1.3 - Mend

javonet-ruby-sdk 2.1.1 → 2.1.3

Files changed (904) hide show

data/lib/javonet-ruby-sdk/Binaries/Perl/Linux/X64/deps/lib/perl5/LWP/RobotUA.pm DELETED Viewed

@@ -1,312 +0,0 @@
-package LWP::RobotUA;
-use parent qw(LWP::UserAgent);
-our $VERSION = '6.68';
-require WWW::RobotRules;
-require HTTP::Request;
-require HTTP::Response;
-use Carp ();
-use HTTP::Status ();
-use HTTP::Date qw(time2str);
-use strict;
-#
-# Additional attributes in addition to those found in LWP::UserAgent:
-#
-# $self->{'delay'}    Required delay between request to the same
-#                     server in minutes.
-#
-# $self->{'rules'}     A WWW::RobotRules object
-#
-sub new
-{
-    my $class = shift;
-    my %cnf;
-    if (@_ < 4) {
-	# legacy args
-	@cnf{qw(agent from rules)} = @_;
-    }
-    else {
-	%cnf = @_;
-    }
-    Carp::croak('LWP::RobotUA agent required') unless $cnf{agent};
-    Carp::croak('LWP::RobotUA from address required')
-	unless $cnf{from} && $cnf{from} =~ m/\@/;
-    my $delay = delete $cnf{delay} || 1;
-    my $use_sleep = delete $cnf{use_sleep};
-    $use_sleep = 1 unless defined($use_sleep);
-    my $rules = delete $cnf{rules};
-    my $self = LWP::UserAgent->new(%cnf);
-    $self = bless $self, $class;
-    $self->{'delay'} = $delay;   # minutes
-    $self->{'use_sleep'} = $use_sleep;
-    if ($rules) {
-	$rules->agent($cnf{agent});
-	$self->{'rules'} = $rules;
-    }
-    else {
-	$self->{'rules'} = WWW::RobotRules->new($cnf{agent});
-    }
-    $self;
-}
-sub delay     { shift->_elem('delay',     @_); }
-sub use_sleep { shift->_elem('use_sleep', @_); }
-sub agent
-{
-    my $self = shift;
-    my $old = $self->SUPER::agent(@_);
-    if (@_) {
-	# Changing our name means to start fresh
-	$self->{'rules'}->agent($self->{'agent'});
-    }
-    $old;
-}
-sub rules {
-    my $self = shift;
-    my $old = $self->_elem('rules', @_);
-    $self->{'rules'}->agent($self->{'agent'}) if @_;
-    $old;
-}
-sub no_visits
-{
-    my($self, $netloc) = @_;
-    $self->{'rules'}->no_visits($netloc) || 0;
-}
-*host_count = \&no_visits;  # backwards compatibility with LWP-5.02
-sub host_wait
-{
-    my($self, $netloc) = @_;
-    return undef unless defined $netloc;
-    my $last = $self->{'rules'}->last_visit($netloc);
-    if ($last) {
-	my $wait = int($self->{'delay'} * 60 - (time - $last));
-	$wait = 0 if $wait < 0;
-	return $wait;
-    }
-    return 0;
-}
-sub simple_request
-{
-    my($self, $request, $arg, $size) = @_;
-    # Do we try to access a new server?
-    my $allowed = $self->{'rules'}->allowed($request->uri);
-    if ($allowed < 0) {
-	# Host is not visited before, or robots.txt expired; fetch "robots.txt"
-	my $robot_url = $request->uri->clone;
-	$robot_url->path("robots.txt");
-	$robot_url->query(undef);
-	# make access to robot.txt legal since this will be a recursive call
-	$self->{'rules'}->parse($robot_url, "");
-	my $robot_req = HTTP::Request->new('GET', $robot_url);
-	my $parse_head = $self->parse_head(0);
-	my $robot_res = $self->request($robot_req);
-	$self->parse_head($parse_head);
-	my $fresh_until = $robot_res->fresh_until;
-	my $content = "";
-	if ($robot_res->is_success && $robot_res->content_is_text) {
-	    $content = $robot_res->decoded_content;
-	    $content = "" unless $content && $content =~ /^\s*Disallow\s*:/mi;
-	}
-	$self->{'rules'}->parse($robot_url, $content, $fresh_until);
-	# recalculate allowed...
-	$allowed = $self->{'rules'}->allowed($request->uri);
-    }
-    # Check rules
-    unless ($allowed) {
-	my $res = HTTP::Response->new(
-	  HTTP::Status::RC_FORBIDDEN, 'Forbidden by robots.txt');
-	$res->request( $request ); # bind it to that request
-	return $res;
-    }
-    my $netloc = eval { local $SIG{__DIE__}; $request->uri->host_port; };
-    my $wait = $self->host_wait($netloc);
-    if ($wait) {
-	if ($self->{'use_sleep'}) {
-	    sleep($wait)
-	}
-	else {
-	    my $res = HTTP::Response->new(
-	      HTTP::Status::RC_SERVICE_UNAVAILABLE, 'Please, slow down');
-	    $res->header('Retry-After', time2str(time + $wait));
-	    $res->request( $request ); # bind it to that request
-	    return $res;
-	}
-    }
-    # Perform the request
-    my $res = $self->SUPER::simple_request($request, $arg, $size);
-    $self->{'rules'}->visit($netloc);
-    $res;
-}
-sub as_string
-{
-    my $self = shift;
-    my @s;
-    push(@s, "Robot: $self->{'agent'} operated by $self->{'from'}  [$self]");
-    push(@s, "    Minimum delay: " . int($self->{'delay'}*60) . "s");
-    push(@s, "    Will sleep if too early") if $self->{'use_sleep'};
-    push(@s, "    Rules = $self->{'rules'}");
-    join("\n", @s, '');
-}
-1;
-__END__
-=pod
-=head1 NAME
-LWP::RobotUA - a class for well-behaved Web robots
-=head1 SYNOPSIS
-  use LWP::RobotUA;
-  my $ua = LWP::RobotUA->new('my-robot/0.1', 'me@foo.com');
-  $ua->delay(10);  # be very nice -- max one hit every ten minutes!
-  ...
-  # Then just use it just like a normal LWP::UserAgent:
-  my $response = $ua->get('http://whatever.int/...');
-  ...
-=head1 DESCRIPTION
-This class implements a user agent that is suitable for robot
-applications.  Robots should be nice to the servers they visit.  They
-should consult the F</robots.txt> file to ensure that they are welcomed
-and they should not make requests too frequently.
-But before you consider writing a robot, take a look at
-L<http://www.robotstxt.org/>.
-When you use an I<LWP::RobotUA> object as your user agent, then you do not
-really have to think about these things yourself; C<robots.txt> files
-are automatically consulted and obeyed, the server isn't queried
-too rapidly, and so on.  Just send requests
-as you do when you are using a normal I<LWP::UserAgent>
-object (using C<< $ua->get(...) >>, C<< $ua->head(...) >>,
-C<< $ua->request(...) >>, etc.), and this
-special agent will make sure you are nice.
-=head1 METHODS
-The LWP::RobotUA is a sub-class of L<LWP::UserAgent> and implements the
-same methods. In addition the following methods are provided:
-=head2 new
-    my $ua = LWP::RobotUA->new( %options )
-    my $ua = LWP::RobotUA->new( $agent, $from )
-    my $ua = LWP::RobotUA->new( $agent, $from, $rules )
-The LWP::UserAgent options C<agent> and C<from> are mandatory.  The
-options C<delay>, C<use_sleep> and C<rules> initialize attributes
-private to the RobotUA.  If C<rules> are not provided, then
-L<WWW::RobotRules> is instantiated providing an internal database of
-F<robots.txt>.
-It is also possible to just pass the value of C<agent>, C<from> and
-optionally C<rules> as plain positional arguments.
-=head2 delay
-    my $delay = $ua->delay;
-    $ua->delay( $minutes );
-Get/set the minimum delay between requests to the same server, in
-I<minutes>.  The default is C<1> minute.  Note that this number doesn't
-have to be an integer; for example, this sets the delay to C<10> seconds:
-    $ua->delay(10/60);
-=head2 use_sleep
-    my $bool = $ua->use_sleep;
-    $ua->use_sleep( $boolean );
-Get/set a value indicating whether the UA should L<LWP::RobotUA/sleep> if
-requests arrive too fast, defined as C<< $ua->delay >> minutes not passed since
-last request to the given server.  The default is true.  If this value is
-false then an internal C<SERVICE_UNAVAILABLE> response will be generated.
-It will have a C<Retry-After> header that indicates when it is OK to
-send another request to this server.
-=head2 rules
-    my $rules = $ua->rules;
-    $ua->rules( $rules );
-Set/get which I<WWW::RobotRules> object to use.
-=head2 no_visits
-    my $num = $ua->no_visits( $netloc )
-Returns the number of documents fetched from this server host. Yeah I
-know, this method should probably have been named C<num_visits> or
-something like that. :-(
-=head2 host_wait
-    my $num = $ua->host_wait( $netloc )
-Returns the number of I<seconds> (from now) you must wait before you can
-make a new request to this host.
-=head2 as_string
-    my $string = $ua->as_string;
-Returns a string that describes the state of the UA.
-Mainly useful for debugging.
-=head1 SEE ALSO
-L<LWP::UserAgent>, L<WWW::RobotRules>
-=head1 COPYRIGHT
-Copyright 1996-2004 Gisle Aas.
-This library is free software; you can redistribute it and/or
-modify it under the same terms as Perl itself.
-=cut

data/lib/javonet-ruby-sdk/Binaries/Perl/Linux/X64/deps/lib/perl5/LWP/Simple.pm DELETED Viewed

@@ -1,270 +0,0 @@
-package LWP::Simple;
-use strict;
-our $VERSION = '6.68';
-require Exporter;
-our @EXPORT = qw(get head getprint getstore mirror);
-our @EXPORT_OK = qw($ua);
-# I really hate this.  It was a bad idea to do it in the first place.
-# Wonder how to get rid of it???  (It even makes LWP::Simple 7% slower
-# for trivial tests)
-use HTTP::Status;
-push(@EXPORT, @HTTP::Status::EXPORT);
-sub import
-{
-    my $pkg = shift;
-    my $callpkg = caller;
-    Exporter::export($pkg, $callpkg, @_);
-}
-use LWP::UserAgent ();
-use HTTP::Date ();
-our $ua = LWP::UserAgent->new;  # we create a global UserAgent object
-$ua->agent("LWP::Simple/$VERSION ");
-$ua->env_proxy;
-sub get ($)
-{
-    my $response = $ua->get(shift);
-    return $response->decoded_content if $response->is_success;
-    return undef;
-}
-sub head ($)
-{
-    my($url) = @_;
-    my $request = HTTP::Request->new(HEAD => $url);
-    my $response = $ua->request($request);
-    if ($response->is_success) {
-	return $response unless wantarray;
-	return (scalar $response->header('Content-Type'),
-		scalar $response->header('Content-Length'),
-		HTTP::Date::str2time($response->header('Last-Modified')),
-		HTTP::Date::str2time($response->header('Expires')),
-		scalar $response->header('Server'),
-	       );
-    }
-    return;
-}
-sub getprint ($)
-{
-    my($url) = @_;
-    my $request = HTTP::Request->new(GET => $url);
-    local($\) = ""; # ensure standard $OUTPUT_RECORD_SEPARATOR
-    my $callback = sub { print $_[0] };
-    if ($^O eq "MacOS") {
-	$callback = sub { $_[0] =~ s/\015?\012/\n/g; print $_[0] }
-    }
-    my $response = $ua->request($request, $callback);
-    unless ($response->is_success) {
-	print STDERR $response->status_line, " <URL:$url>\n";
-    }
-    $response->code;
-}
-sub getstore ($$)
-{
-    my($url, $file) = @_;
-    my $request = HTTP::Request->new(GET => $url);
-    my $response = $ua->request($request, $file);
-    $response->code;
-}
-sub mirror ($$)
-{
-    my($url, $file) = @_;
-    my $response = $ua->mirror($url, $file);
-    $response->code;
-}
-1;
-__END__
-=pod
-=head1 NAME
-LWP::Simple - simple procedural interface to LWP
-=head1 SYNOPSIS
- perl -MLWP::Simple -e 'getprint "http://www.sn.no"'
- use LWP::Simple;
- $content = get("http://www.sn.no/");
- die "Couldn't get it!" unless defined $content;
- if (mirror("http://www.sn.no/", "foo") == RC_NOT_MODIFIED) {
-     ...
- }
- if (is_success(getprint("http://www.sn.no/"))) {
-     ...
- }
-=head1 DESCRIPTION
-This module is meant for people who want a simplified view of the
-libwww-perl library.  It should also be suitable for one-liners.  If
-you need more control or access to the header fields in the requests
-sent and responses received, then you should use the full object-oriented
-interface provided by the L<LWP::UserAgent> module.
-The module will also export the L<LWP::UserAgent> object as C<$ua> if you
-ask for it explicitly.
-The user agent created by this module will identify itself as
-C<LWP::Simple/#.##>
-and will initialize its proxy defaults from the environment (by
-calling C<< $ua->env_proxy >>).
-=head1 FUNCTIONS
-The following functions are provided (and exported) by this module:
-=head2 get
-    my $res = get($url);
-The get() function will fetch the document identified by the given URL
-and return it.  It returns C<undef> if it fails.  The C<$url> argument can
-be either a string or a reference to a L<URI> object.
-You will not be able to examine the response code or response headers
-(like C<Content-Type>) when you are accessing the web using this
-function.  If you need that information you should use the full OO
-interface (see L<LWP::UserAgent>).
-=head2 head
-    my $res = head($url);
-Get document headers. Returns the following 5 values if successful:
-($content_type, $document_length, $modified_time, $expires, $server)
-Returns an empty list if it fails.  In scalar context returns TRUE if
-successful.
-=head2 getprint
-    my $code = getprint($url);
-Get and print a document identified by a URL. The document is printed
-to the selected default filehandle for output (normally STDOUT) as
-data is received from the network.  If the request fails, then the
-status code and message are printed on STDERR.  The return value is
-the HTTP response code.
-=head2 getstore
-    my $code = getstore($url, $file)
-    my $code = getstore($url, $filehandle)
-Gets a document identified by a URL and stores it in the file. The
-return value is the HTTP response code.
-You may also pass a writeable filehandle or similar,
-such as a L<File::Temp> object.
-=head2 mirror
-    my $code = mirror($url, $file);
-Get and store a document identified by a URL, using
-I<If-modified-since>, and checking the I<Content-Length>.  Returns
-the HTTP response code.
-=head1 STATUS CONSTANTS
-This module also exports the L<HTTP::Status> constants and procedures.
-You can use them when you check the response code from L<LWP::Simple/getprint>,
-L<LWP::Simple/getstore> or L<LWP::Simple/mirror>.  The constants are:
-   RC_CONTINUE
-   RC_SWITCHING_PROTOCOLS
-   RC_OK
-   RC_CREATED
-   RC_ACCEPTED
-   RC_NON_AUTHORITATIVE_INFORMATION
-   RC_NO_CONTENT
-   RC_RESET_CONTENT
-   RC_PARTIAL_CONTENT
-   RC_MULTIPLE_CHOICES
-   RC_MOVED_PERMANENTLY
-   RC_MOVED_TEMPORARILY
-   RC_SEE_OTHER
-   RC_NOT_MODIFIED
-   RC_USE_PROXY
-   RC_BAD_REQUEST
-   RC_UNAUTHORIZED
-   RC_PAYMENT_REQUIRED
-   RC_FORBIDDEN
-   RC_NOT_FOUND
-   RC_METHOD_NOT_ALLOWED
-   RC_NOT_ACCEPTABLE
-   RC_PROXY_AUTHENTICATION_REQUIRED
-   RC_REQUEST_TIMEOUT
-   RC_CONFLICT
-   RC_GONE
-   RC_LENGTH_REQUIRED
-   RC_PRECONDITION_FAILED
-   RC_REQUEST_ENTITY_TOO_LARGE
-   RC_REQUEST_URI_TOO_LARGE
-   RC_UNSUPPORTED_MEDIA_TYPE
-   RC_INTERNAL_SERVER_ERROR
-   RC_NOT_IMPLEMENTED
-   RC_BAD_GATEWAY
-   RC_SERVICE_UNAVAILABLE
-   RC_GATEWAY_TIMEOUT
-   RC_HTTP_VERSION_NOT_SUPPORTED
-=head1 CLASSIFICATION FUNCTIONS
-The L<HTTP::Status> classification functions are:
-=head2 is_success
-    my $bool = is_success($rc);
-True if response code indicated a successful request.
-=head2 is_error
-    my $bool = is_error($rc)
-True if response code indicated that an error occurred.
-=head1 CAVEAT
-Note that if you are using both LWP::Simple and the very popular L<CGI>
-module, you may be importing a C<head> function from each module,
-producing a warning like C<Prototype mismatch: sub main::head ($) vs none>.
-Get around this problem by just not importing LWP::Simple's
-C<head> function, like so:
-        use LWP::Simple qw(!head);
-        use CGI qw(:standard);  # then only CGI.pm defines a head()
-Then if you do need LWP::Simple's C<head> function, you can just call
-it as C<LWP::Simple::head($url)>.
-=head1 SEE ALSO
-L<LWP>, L<lwpcook>, L<LWP::UserAgent>, L<HTTP::Status>, L<lwp-request>,
-L<lwp-mirror>
-=cut