Free net google 1.0 software for linux

Net::Google is a simple OOP-ish interface to the Google SOAP API.

SYNOPSIS

use Net::Google;
use constant LOCAL_GOOGLE_KEY => "********************************";

my $google = Net::Google->new(key=>LOCAL_GOOGLE_KEY);
my $search = $google->search();

# Search interface

$search->query(qw(aaron straup cope));
$search->lr(qw(en fr));
$search->starts_at(5);
$search->max_results(15);

map { print $_->title()."n"; } @{$search->results()};

# or...

foreach my $r (@{$search->response()}) {
print "Search time :".$r->searchTime()."n";

# returns an array ref of Result objects
# the same as the $search->results() method
map { print $_->URL()."n"; } @{$r->resultElements()};
}

# Spelling interface

print $google->spelling(phrase=>"muntreal qwebec")->suggest(),"n";

# Cache interface

my $cache = $google->cache(url=>"http://search.cpan.org/recent");
print $cache->get();

Provides a simple OOP-ish interface to the Google SOAP API

Net::Google::Cache is a simple OOP-ish interface to the Google SOAP API for cached documents.

SYNOPSIS

use Net::Google::Cache;
my $cache = Net::Google::Cache(%args);

$cache->url("http://aaronland.net);
print $cache->get();

Provides a simple OOP-ish interface to the Google SOAP API for cached documents.
This package is used by Net::Google.

Net::Google::Service is a SOAP widget(s) for Net::Google.

SYNOPSIS

use Net::Google::Service;
my $search = Net::Google::Service->search({debug=>1});

PACKAGE METHODS

__PACKAGE__->search(%args)
__PACKAGE__->spelling(%args)
__PACKAGE_->cache(%args)

Tie::Google is a Perl module with single-variable access to Google search results.

SYNOPSIS

my $KEYFILE = glob "~/.googlekey";
my ($g, @g, %g);

# Tied array interface
tie @g, "Tie::Google", $KEYFILE, "perl";
for my $r (@g) {
printf " *,
$r->{URL}, $r->{title};
}

# Tied hash interface
tie %g, "Tie::Google", $KEYFILE;
for my $term (qw[ perl python ruby ]) {
my $res = $g{$term};
printf "%d results for %s:n", scalar @$res, $term;

for my $r (@$res) {
printf " * ,
$r->{URL}, $r->{title};
}
}

# Tied scalar interface: I Feel Lucky
use LWP::Simple qw(getprint);
tie $g, "Tie::Google", $KEYFILE, "perl";
getprint($g->{URL});

Net::Google::Response is a simple OOP-ish interface to the Google SOAP API search responses.

SYNOPSIS

my $service = Net::Google->new(key=>LOCAL_GOOGLE_KEY);
my $session = $service->search();

$session->query(qw(Perl modules));

# You are probably better off calling
# $session->results() but if you want
# the raw response object(s) here ya go :

my $responses = $session->response();
my $count = scalar(@$responses);

# $r is a Net::Google::Response object

foreach my $r (@$responses) {
print sprintf("%s : %sn",$r->searchQuery(),$r->estimatedTotalResults());
}

Provides a simple OOP-ish interface to the Google SOAP API for searching. This package is used by Net::Google.

The Net::Google::Response object is used to contain response information provided by the Google search service in response to a search query. The Response object allows the client program to easily access the data returned from a search.

Response data is accessed using methods with identical names to the elements of a search response (as documented in the Google Web APIs Reference, section 3). For instance, the first example in the SYNOPSIS section, above, would return the estimated number of total results for the query.

Response objects may contain other response objects, where an element would return an array of other elements. For instance, calling $response->resultElements() will return a reference to an array of Net::Google::Response objects, each one representing one result from the search.

The Response module will automatically provide methods for the search response, as described by the service WSDL file. The results format is described by the Google APIs documentation, to which you should refer for the most up-to-date information. As of the April 8th, 2002 release of the Google APIs, the methods below are provided for each search result.

Google Hacks project is a compilation of carefully crafted Google searches that expose novel functionality from Googles search and map services.

For example, you can use it to view a timeline of your search results, view a map, search for music, search for books, and perform many other specific kinds of searches.

Zoogle provides a Z39.50 gateway to the Google Web index.

Zoogle is a Z39.50 gateway to the Google web index. With this gateway you can search the Google index with any Z39.50 client.

It is based upon Googles official search API, the popular YAZ toolkit, and the Perl module Net::Z3950::SimpleServer.

Ruby/Google offers a higher-level abstraction of Googles SOAP-driven Web API. Ruby/Google module allows the user to programatically query the Google search engine from Ruby.

The aim of the library is to shield the programmer from the details of the raw data structures returned by the Web API, and in the process make the API more accessible for everyday use.