view release on metacpan or  search on metacpan

t/patterns.txt  view on Meta::CPAN

1|2|3|4|5|6|2|6|9|10|5:lamentation|
1|2|3|4|5|6|2|6|9|10|5|12:lamentations|
1|2|3|4|5|6|2|6|9|2:permanence|
1|2|3|4|5|6|2|6|9|3|11:malignantly|
1|2|3|4|5|6|2|6|9|7:unlikeness|
1|2|3|4|5|6|2|8:Acapulco|Angelina|Antigone|Aurelius|Bayesian|Bergsten|Boylston|Bradbury|Cambrian|Carlsbad|Cranford|Crawford|Earthman|Faustian|Haberman|Halstead|Hebrides|Hercules|Herschel|Hibernia|Hispanic|Houghton|Jacobean|Jacobian|Mackinaw|Michelin|...
1|2|3|4|5|6|2|8|1:dashboard|endurance|microfilm|saucepans|seconders|solutions|strengths|subgroups|
1|2|3|4|5|6|2|8|1|10:apocryphal|luminously|microfilms|northbound|
1|2|3|4|5|6|2|8|1|10|11|2|3|1|15|4|17|3:antifundamentalist|
1|2|3|4|5|6|2|8|1|10|4:influential|
1|2|3|4|5|6|2|8|1|10|4|4|13:influentially|

 view release on metacpan or  search on metacpan

lib/Games/EveOnline/EveCentral/Request/EVEMon.pm  view on Meta::CPAN

{
  $Games::EveOnline::EveCentral::Request::EVEMon::VERSION = '0.001';
}


# ABSTRACT: Create a request for the evemon endpoint.


use Moo 1.003001;
use MooX::Types::MooseLike 0.25;
use MooX::StrictConstructor 0.006;

lib/Games/EveOnline/EveCentral/Request/EVEMon.pm  view on Meta::CPAN

=pod

=head1 NAME

Games::EveOnline::EveCentral::Request::EVEMon - Create a request for the evemon endpoint.

=head1 VERSION

version 0.001

lib/Games/EveOnline/EveCentral/Request/EVEMon.pm  view on Meta::CPAN

=head1 METHODS

=head2 request

Returns an HTTP::Request object which can be used to call the 'evemon'
endpoint.

=begin private =end private

=head1 AUTHOR

 view release on metacpan or  search on metacpan

lib/Games/LMSolve/Plank/Base.pm  view on Meta::CPAN

        my ( $start_x, $start_y ) =
            ( $p->{'start'}->{'x'}, $p->{'start'}->{'y'} );
        my ( $end_x, $end_y ) = ( $p->{'end'}->{'x'}, $p->{'end'}->{'y'} );

        my $check_endpoints = sub {
            if ( !$board[$start_y]->[$start_x] )
            {
                die "Plank cannot be placed at point ($start_x,$start_y)!";
            }
            if ( !$board[$end_y]->[$end_x] )

lib/Games/LMSolve/Plank/Base.pm  view on Meta::CPAN

        {
            if ( $start_y == $end_y )
            {
                die "$plank_str has zero length!";
            }
            $check_endpoints->();
            if ( $start_y > $end_y )
            {
                ( $start_y, $end_y ) = ( $end_y, $start_y );
            }
            foreach my $y ( ( $start_y + 1 ) .. ( $end_y - 1 ) )

lib/Games/LMSolve/Plank/Base.pm  view on Meta::CPAN

                'dir'   => "S"
            };
        }
        elsif ( $start_y == $end_y )
        {
            $check_endpoints->();
            if ( $start_x > $end_x )
            {
                ( $start_x, $end_x ) = ( $end_x, $start_x );
            }
            foreach my $x ( ( $start_x + 1 ) .. ( $end_x - 1 ) )

lib/Games/LMSolve/Plank/Base.pm  view on Meta::CPAN

                'dir'   => "E"
            };
        }
        elsif ( ( $end_x - $start_x ) == ( $end_y - $start_y ) )
        {
            $check_endpoints->();
            if ( $start_x > $end_x )
            {
                ( $start_x, $end_x ) = ( $end_x, $start_x );
                ( $start_y, $end_y ) = ( $end_y, $start_y );
            }

 view release on metacpan or  search on metacpan

t/92_paths.t  view on Meta::CPAN

    my @rhs1 = @{$pair->[1]};
    my @lhs2 = @{$path[0]};
    my @rhs2 = @{$path[$#path]};

    ENDPOINTS: if( "@lhs1" ne "@lhs2" or "@rhs1" ne "@rhs2" ) {
        warn " pair (@lhs1)->(@rhs1) != path endpoints (@lhs2)->(@rhs2)\n";
        ok( 0 );

        our $fail ++;
        die "that's too many failures to bother continuing" if $fail > 15;

 view release on metacpan or  search on metacpan

lib/Games/Word/Wordlist/Enable.pm  view on Meta::CPAN

endostyle endostyles endosulfan endosulfans endosymbiont endosymbionts
endosymbioses endosymbiosis endosymbiotic endothecia endothecium endothelia
endothelial endothelioma endotheliomas endotheliomata endothelium endotherm
endothermic endothermies endotherms endothermy endotoxic endotoxin endotoxins
endotracheal endotrophic endow endowed endower endowers endowing endowment
endowments endows endozoic endpaper endpapers endplate endplates endpoint
endpoints endrin endrins ends endue endued endues enduing endurable endurably
endurance endurances endure endured endures enduring enduringly enduringness
enduringnesses enduro enduros endways endwise enema enemas enemata enemies
enemy energetic energetically energetics energid energids energies energise
energised energises energising energization energizations energize energized
energizer energizers energizes energizing energy enervate enervated enervates

 view release on metacpan or  search on metacpan

lib/Genealogy/Relationship.pm  view on Meta::CPAN

=head2 _path_to_ancestor

Internal method. Given a person object and a target ancestor object, returns
an array reference containing the shortest path from the person to the
ancestor (inclusive of both endpoints). Uses breadth-first search so that
the shortest path is always found, even when a person has two parents.

=cut

method _path_to_ancestor {

 view release on metacpan or  search on metacpan

lib/Geo/Coder/GeoApify.pm  view on Meta::CPAN

If not provided,
an in-memory cache is created with a default expiration of one hour.

=item * C<host>

The API host endpoint.
Defaults to L<https://api.geoapify.com/v1/geocode>.

=item * C<min_interval>

Minimum number of seconds to wait between API requests.

 view release on metacpan or  search on metacpan

gentest/gentest_ellipsoid.pl  view on Meta::CPAN

my( $r1,$r2,$r3,$r4,$r5);
EOS
  $tests{range}{code} = [ $code ];
  ${$tests{range}}{count} = 0;

  # test endpoints: poles and equator
  for( my $lat1 = $lat0; $lat1 <= 90; $lat1 += $latinc ) {
    for( my $lon1 = $lon0; $lon1 <= 270; $lon1 += $loninc ) {
      next if abs($lat1) == 90 and $lon1 > 0;
      print "  loc1 = ($lat1,$lon1)\n" if $debug;
      for( my $lat2 = $lat0; $lat2 <= 90; $lat2 += $latinc ) {

 view release on metacpan or  search on metacpan

src/mapbox/earcut.hpp  view on Meta::CPAN

    double hy = hole->y;
    double qx = -std::numeric_limits<double>::infinity();
    Node* m = nullptr;

    // find a segment intersected by a ray from the hole's leftmost Vertex to the left;
    // segment's endpoint with lesser x will be potential connection Vertex
    do {
        if (hy <= p->y && hy >= p->next->y && p->next->y != p->y) {
          double x = p->x + (hy - p->y) * (p->next->x - p->x) / (p->next->y - p->y);
          if (x <= hx && x > qx) {
            qx = x;

src/mapbox/earcut.hpp  view on Meta::CPAN

    if (!m) return 0;

    if (hx == qx) return m->prev;

    // look for points inside the triangle of hole Vertex, segment intersection and endpoint;
    // if there are no points found, we have a valid connection;
    // otherwise choose the Vertex of the minimum angle with the ray as connection Vertex

    const Node* stop = m;
    double tanMin = std::numeric_limits<double>::infinity();

 view release on metacpan or  search on metacpan

lib/Geo/Google/PolylineEncoder.pm  view on Meta::CPAN

package Geo::Google::PolylineEncoder;

use strict;
use warnings;

use accessors qw(num_levels zoom_factor visible_threshold force_endpoints
		 zoom_level_breaks escape_encoded_points lons_first
		 points dists max_dist encoded_points encoded_levels );
use constant defaults => {
			  num_levels  => 18,
			  zoom_factor => 2,
			  force_endpoints => 1,
			  escape_encoded_points => 0,
			  visible_threshold => 0.00001,
			  lons_first => 0,
			 };
our $VERSION = 0.06;

lib/Geo/Google/PolylineEncoder.pm  view on Meta::CPAN

    my $visible_threshold = $self->visible_threshold;
    my $zoom_level_breaks = $self->zoom_level_breaks;

    my $encoded_levels = "";

    if ($self->force_endpoints) {
	$encoded_levels .= $self->encode_number($num_levels_minus_1);
    } else {
	$encoded_levels .= $self->encode_number($num_levels_minus_1 - $self->compute_level($max_dist));
    }

lib/Geo/Google/PolylineEncoder.pm  view on Meta::CPAN

	    $encoded_levels .= $self->encode_number($num_levels_minus_1 - $level);
	}
    }

    if ($self->force_endpoints) {
	$encoded_levels .= $self->encode_number($num_levels_minus_1);
    } else {
	$encoded_levels .= $self->encode_number($num_levels_minus_1 - $self->compute_level($max_dist));
    }

lib/Geo/Google/PolylineEncoder.pm  view on Meta::CPAN

=item new( [%args] )

Create a new encoder.  Arguments are optional and correspond to the accessor
with the same name: L</num_levels>, L</zoom_factor>, L</visible_threshold>,
L</force_endpoints>, etc...

Note: there's nothing stopping you from setting these properties each time you
L</encode> a polyline.

=item num_levels

lib/Geo/Google/PolylineEncoder.pm  view on Meta::CPAN

=item visible_threshold

Indicates the length of a barely visible object at the highest zoom level.
Default: 0.00001.  err.. units.

=item force_endpoints

Indicates whether or not the endpoints should be visible at all zoom levels.
force_endpoints is.  Probably should stay true regardless.
Default: 1=true.

=item escape_encoded_points

Indicates whether or not the encoded points should have escape characters

 view release on metacpan or  search on metacpan

lib/Geo/TCX.pm  view on Meta::CPAN

    if ( $o->{tag_course} ) {
        # in Courses, data is structured as <Lap>...</Lap><Lap>...</Lap><Track>...</Track><Track>...</Track>
        # actually, not sure just seem like it's one long ... track, not multiple ones, which complicates things
        my $xml_str = $o->{tag_course};

        my (@lap_tags, @lap_endpoints, @track_tags);

        if ( $xml_str =~ m,(<Lap>.*</Lap>),s ) {
            my $str = $1;
            @lap_tags = split(/(?s)<\/Lap>\s*<Lap>/, $str );
            if (@lap_tags == 0) { push @lap_tags, $str }

lib/Geo/TCX.pm  view on Meta::CPAN

        for my $i (0 .. $#lap_tags) {
            my ($end_pos, $end_pt);
            if ( $lap_tags[$i] =~ m,<EndPosition>(.*)</EndPosition>,s ) {
                $end_pt = Geo::TCX::Trackpoint->new( $1 );
                push @lap_endpoints, $end_pt
            }
            # since split removed tags sometimes at ^ of string for other at $
            # let's remove them all and add back
            $lap_tags[$i] =~ s,</?Lap>,,g;
            $lap_tags[$i] =~ s,^,<Lap>,g;

lib/Geo/TCX.pm  view on Meta::CPAN

        if (@lap_tags ==1)  { $track_tags[0] = $track_str }
        else  {
            my ($t1, $t2);
            for my $i (0 .. $#lap_tags ) {
                if ($i < $#lap_tags) {
                    ($t1, $t2) = $t->split_at_point_closest_to( $lap_endpoints[$i] );
                    push @track_tags, $t1->xml_string;
                    $t = $t2
                } else { push @track_tags, $t->xml_string } # ie don't split the last track portion
            }
        }

 view release on metacpan or  search on metacpan

lib/Geo/What3Words.pm  view on Meta::CPAN

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

    my $self = {};
    $self->{api_endpoint} = $params{api_endpoint} || 'https://api.what3words.com/v3/';
    $self->{key}          = $params{key}          || die "API key not set";
    $self->{language}     = $params{language};
    $self->{logging}      = $params{logging};

    ## _ua is used for testing. But could also be used to

lib/Geo/What3Words.pm  view on Meta::CPAN

sub ping {
    my $self = shift;

    ## http://example.com/some/path => example.com
    ## also works with IP addresses
    my $host = URI->new($self->{api_endpoint})->host;

    $self->_log("pinging $host...");

    my $netping = Net::Ping->new('external');
    my $res     = $netping->ping($host);

lib/Geo/What3Words.pm  view on Meta::CPAN

    foreach my $key (keys %$rh_fields) {
        delete $rh_fields->{$key} if (!defined($rh_fields->{$key}));
    }

    my $uri = URI->new($self->{api_endpoint} . $method_name);
    $uri->query_form($rh_fields);
    my $url = $uri->as_string;

    $self->_log("GET $url");
    my $response = $self->{ua}->get($url);

lib/Geo/What3Words.pm  view on Meta::CPAN

=item language

Default language for 3 word addresses (e.g. C<'ru'>, C<'de'>). Can be
overridden per request.

=item api_endpoint

Override the API URL. Defaults to C<https://api.what3words.com/v3/>.

=item ua

 view release on metacpan or  search on metacpan

lib/GeoIP2/Record/Traits.pm  view on Meta::CPAN

This returns the autonomous system number
(L<http://en.wikipedia.org/wiki/Autonomous_system_(Internet)>) associated with
the IP address.

This attribute is only available from the City and Insights web service
endpoints and the GeoIP2 Enterprise database.

=head2 $traits_rec->autonomous_system_organization()

This returns the organization associated with the registered autonomous system
number (L<http://en.wikipedia.org/wiki/Autonomous_system_(Internet)>) for the IP
address.

This attribute is only available from the City and Insights web service
endpoints and the GeoIP2 Enterprise database.

=head2 $traits_rec->connection_type()

This returns the connection type associated with the IP address. It may take
the following values: C<Dialup>, C<Cable/DSL>, C<Corporate>, or C<Cellular>.

lib/GeoIP2/Record/Traits.pm  view on Meta::CPAN

This returns the second level domain associated with the IP address. This will
be something like "example.com" or "example.co.uk", not "foo.example.com".

This attribute is only available from the City and Insights web service
endpoints and the GeoIP2 Enterprise database.

=head2 $traits_rec->ip_address()

This returns the IP address that the data in the model is for. If you
performed a "me" lookup against the web service, this will be the externally

lib/GeoIP2/Record/Traits.pm  view on Meta::CPAN

=head2 $traits_rec->isp()

This returns the name of the ISP associated with the IP address.

This attribute is only available from the City and Insights web service
endpoints and the GeoIP2 Enterprise database.

=head2 $traits_rec->organization()

This returns the name of the organization associated with the IP address.

This attribute is only available from the City and Insights web service
endpoints and the GeoIP2 Enterprise database.

=head2 $traits_rec->user_type()

This returns the user type associated with the IP address. This can be one of
the following values:

 view release on metacpan or  search on metacpan

lib/Gerrit/REST.pm  view on Meta::CPAN

=back

=head1 METHODS

Gerrit's REST API documentation lists dozens of "endpoints" which can
be operated via the standard HTTP requests: GET, DELETE, PUT, and
POST. Gerrit::REST objects implement four methods called GET, DELETE,
PUT, and POST to make it easier to invoke and get results from
Gerrit's REST endpoints.

All four methods need a RESOURCE argument which is simply a string
denoting the endpoint URL's path, as indicated in the documentation.

PUT and POST second argument (usually a hash-ref, but sometimes a simple
string) is encoded using the C<encode> method of a C<JSON> object and passed
as contents of the underlying associated HTTP method.

All four methods return the value returned by the associated
endpoint's method, as specified in the documentation, decoded
according to its content type as follows:

=over

=item * application/json

The majority of the API's endpoints return JSON values. Those are
decoded using the C<decode> method of a C<JSON> object. Most of the
endpoints return hashes, which are returned as a Perl hash-ref.

=item * text/plain

Those values are returned as simple strings.

=back

Some endpoints don't return anything. In those cases, the methods
return C<undef>. The methods croak if they get any other type of
values in return.

In case of errors (i.e., if the underlying HTTP method return an error code
different from 2xx) the methods croak with a string error message.

 view release on metacpan or  search on metacpan

examples/burst  view on Meta::CPAN

	  my $m = sin($angle)/cos($angle);
	  if ($m ==0) { $m = 0.000000000001; } #avoid div by 0
	  if ($c ==0) { $c = 0.000000000001; } #avoid div by 0
	  if ($d ==0) { $d = 0.000000000001; } #avoid div by 0

	  # find the positive solution of the quadratic for the endpoints
	  my $x = sqrt(1/((1/$a/$a)+($m*$m/$b/$b)));
	  my $y = sqrt(1/((1/($m*$m*$a*$a))+(1/$b/$b)));

	  # and find the starting points in the same manner
	  my $x_start = sqrt(1/((1/$c/$c)+($m*$m/$d/$d)));

 view release on metacpan or  search on metacpan

t/02-check-jira.t  view on Meta::CPAN

                  fixVersions => [{name => 'master'}],
               }},
);

sub GET {
    my ($jira, $endpoint) = @_;
    my $key;
    if ($endpoint =~ m:/issue/(.*):) {
        $key = $1;
    } else {
        die "JIRA::Client(fake): no such endpoint ($endpoint)\n";
    }
    if (exists $issues{$key}) {
        return $issues{$key};
    } else {
        die "JIRA::Client(fake): no such issue ($key)\n";

 view release on metacpan or  search on metacpan

lib/Git/Raw/Walker.pm  view on Meta::CPAN

Push HEAD of the repository to the list of commits to be used as roots when
starting a revision walk.

=head2 push_range( $start, $end )

Push and hide the respective endpoints of the given range. C<$start> and C<$end>
should be C<"commitish">, that is, it should be a L<Git::Raw::Commit> or
L<Git::Raw::Reference> object, or alternatively a commit id or commit id prefix.

=head2 push_range( $range )

Push and hide the respective endpoints of the given range. C<$range> should be
of the form C<"start_commit_id..end_commit_id">.

=head2 hide( $commit )

Hide a L<Git::Raw::Commit> and its ancestors from the walker.

 view release on metacpan or  search on metacpan

author/generate.pl  view on Meta::CPAN

foreach my $section_pack (@{ $config->{sections} }) {
foreach my $section_name (keys %$section_pack) {
    my $section = $section_pack->{$section_name};

    my $file = $dir->child("$section_name.yml");
    my $endpoints = YAML::XS::Load( $file->slurp() );

    print "=head1 $section->{head}\n\n";
    print "See L<$section->{doc_url}>.\n\n";

    foreach my $endpoint_pack (@$endpoints) {
    foreach my $sub (keys %$endpoint_pack) {
        my $spec = $endpoint_pack->{$sub};

        my ($return, $method, $path, $params_ok);
        if ($spec =~ m{^(?:(\S+) = |)(GET|POST|PUT|DELETE) (\S+?)(\??)$}) {
            ($return, $method, $path, $params_ok) = ($1, $2, $3, $4);
        }

 view release on metacpan or  search on metacpan

author/generate.pl  view on Meta::CPAN

foreach my $section_pack (@{ $config->{sections} }) {
foreach my $section_name (keys %$section_pack) {
    my $section = $section_pack->{$section_name};

    my $file = $dir->child("$section_name.yml");
    my $endpoints = YAML::XS::Load( $file->slurp() );

    print "=head2 $section->{head}\n\n";
    print "See L<$section->{doc_url}>.\n\n";
    print "=over\n\n";

    foreach my $endpoint (@$endpoints) {
        if (keys(%$endpoint) == 1) {
            my ($method) = keys %$endpoint;
            $endpoint = {
                method => $method,
                spec   => $endpoint->{$method},
            };
        }

        my $method = $endpoint->{method};
        my $spec = $endpoint->{spec};

        my ($return, $verb, $path, $params_ok);
        if ($spec =~ m{^(?:(\S+) = |)(GET|POST|PUT|DELETE) ([^/\s]\S*?[^/\s]?)(\??)$}) {
            ($return, $verb, $path, $params_ok) = ($1, $2, $3, $4);
        }

author/generate.pl  view on Meta::CPAN

            die "Invalid spec ($method): $spec";
        }

        my $no_decode = 0;
        $no_decode = 1 if !$return;
        $no_decode = 1 if $endpoint->{no_decode};

        print "=item $method\n\n";
        print '    ';

        print "my \$$return = " if $return;

author/generate.pl  view on Meta::CPAN

        print ");\n\n";

        print "Sends a C<$verb> request to C<$path>";
        print ' and returns the ' . ($no_decode ? 'raw' : 'decoded') . ' response content' if $return;
        print ".\n\n";
        print "$endpoint->{note}\n" if $endpoint->{note};
        print "=cut\n\n";

        print "sub $method {\n";
        print "    my \$self = shift;\n";

 view release on metacpan or  search on metacpan

lib/Google/Ads/AdWords/Client.pm  view on Meta::CPAN

      if ($@) {
        warn("Module $module_name was not found.");
        return;
      } else {

        # Generating the service endpoint url of the form
        # https://{server_url}/{group_name(cm/job/info/o)}/{version}/{service}.
        my $server_url =
          $self->get_alternate_url() =~ /\/$/
          ? substr($self->get_alternate_url(), 0, -1)
          : $self->get_alternate_url();
        my $service_to_group_name =
          $Google::Ads::AdWords::Constants::SERVICE_TO_GROUP{$method_name};
        if (!$service_to_group_name) {
          die("Service " . $method_name . " is not configured in the library.");
        }
        my $endpoint_url =
          sprintf(Google::Ads::AdWords::Constants::PROXY_FORMAT_STRING,
          $server_url, $service_to_group_name, $self->get_version(),
          $method_name);

        # If a suitable module is found, instantiate it and store it in
        # instance-specific storage to emulate a singleton.
        my $service_port = $module_name->new({

            # Setting the server endpoint of the service.
            proxy => [$endpoint_url],

            # Associating our custom serializer.
            serializer =>
              Google::Ads::AdWords::Serializer->new({client => $self}),

 view release on metacpan or  search on metacpan

lib/Google/Ads/GoogleAds/Constants.pm  view on Meta::CPAN

use constant DEFAULT_API_VERSION => "V24";

# The Google OAuth2 service base URL.
use constant OAUTH2_BASE_URL => "https://accounts.google.com/o/oauth2";

# The Google OAuth2 tokeninfo endpoint.
use constant OAUTH2_TOKEN_INFO_URL => "https://oauth2.googleapis.com/tokeninfo";

# Default OAuth2 scope for Google Ads API.
use constant DEFAULT_OAUTH2_SCOPE => "https://www.googleapis.com/auth/adwords";

 view release on metacpan or  search on metacpan

lib/Google/ContentAPI.pm  view on Meta::CPAN

#
# Bill Gerrard <bill@gerrard.org>
#
# VERSION HISTORY
#
# + v1.03       12/10/2020 Allow custom endpoint, update docs for v2.1 API
# + v1.02       04/11/2018 Add accountstatuses, productstatuses methods. Add "custom" resource
# + v1.01       03/27/2018 Added config_json, merchant_id options and switched to Crypt::JWT
# + v1.00       03/23/2018 initial release
#
# COPYRIGHT AND LICENSE

lib/Google/ContentAPI.pm  view on Meta::CPAN

    }
    $self->{merchant_id} = $self->{config}->{merchant_id}
        || $params->{merchant_id}
        || croak "'merchant_id' not provided in json config in new()";

    $self->{endpoint} = $self->{config}->{endpoint}
        || $params->{endpoint}
        || 'https://www.googleapis.com/content/v2';

    $self->{debug} = 1 if $params->{debug};
    $self->{google_auth_token} = get_google_auth_token($self);
    $self->{rest} = init_rest_client($self);

lib/Google/ContentAPI.pm  view on Meta::CPAN

}

sub init_rest_client {
    my $self = shift;
    my $r = REST::Client->new();
    $r->setHost($self->{endpoint});
    $r->addHeader('Authorization', $self->{google_auth_token});
    $r->addHeader('Content-type', 'application/json');
    $r->addHeader('charset', 'UTF-8');
    return $r;
}

lib/Google/ContentAPI.pm  view on Meta::CPAN

For convenience, add your Merchant account ID to the *.json file provided by Google.
Your complete *.json file, after adding your merchant ID, will look something like this:

  {
    "endpoint": "https://www.googleapis.com/content/v2.1",
    "merchant_id": "123456789",
    "type": "service_account",
    "project_id": "content-api-194321",
    "private_key_id": "11b8e20c2540c788e98b49e623ae8167dc3e4a6f",
    "private_key": "-----BEGIN PRIVATE KEY-----

lib/Google/ContentAPI.pm  view on Meta::CPAN

  use Google::ContentAPI;
  use Data::Dumper;

  my $google = Google::ContentAPI->new({
      endpoint => 'https://www.googleapis.com/content/v2.1',
      debug => 0,
      config_file => 'content-api-key.json',
      config_json => $json_text,
      merchant_id => '123456789',
  });

lib/Google/ContentAPI.pm  view on Meta::CPAN

=head2 new()

Create a new Google::ContentAPI object

=head3 endpoint

API endpoint to use.
v2.1 endpoint is 'https://www.googleapis.com/content/v2.1'.
v2.0 endpoint is 'https://www.googleapis.com/content/v2'.
If not provided, default to v2.0 endpoint for backwards compatibility.

=head3 debug

Displays API debug information

 view release on metacpan or  search on metacpan

lib/Google/DNS.pm  view on Meta::CPAN

use JSON::PP qw/decode_json/;
use Class::Accessor::Lite (
    rw => [qw/
        cd
        type
        endpoint
        ua
    /],
);

our $VERSION = '0.02';

lib/Google/DNS.pm  view on Meta::CPAN

    my %args  = @_;

    bless {
        cd       => ($args{cd} || $args{dnssec}) ? 1 : 0,
        type     => $args{type}     || '',
        endpoint => $args{endpoint} || 'https://dns.google.com/resolve',
        ua       => $args{ua}       || HTTP::Tiny->new,
    }, $class;
}

sub resolve {

lib/Google/DNS.pm  view on Meta::CPAN

    if ($self->type) {
        $query{type} = $self->type;
    }
    my $query_string = join('&', map { uri_escape($_).'='.uri_escape($query{$_}) } keys %query);

    my $res = $self->ua->get($self->endpoint.'?'. $query_string);
    croak "wrong response:$res->{status} $res->{reason}" unless $res->{success};
    my $json = $res->{content};
    return $json if $raw;
    return decode_json($json);
}

 view release on metacpan or  search on metacpan

lib/Google/GeoCoder/Smart.pm  view on Meta::CPAN

  my $lng = $best_match->{geometry}{location}{lng};

=head1 DESCRIPTION

L<Google::GeoCoder::Smart|https://metacpan.org/pod/Google::GeoCoder::Smart> provides a lightweight wrapper around the Google Geocoding API
v3 endpoint:

  https://maps.googleapis.com/maps/api/geocode/json

It supports both structured addresses and place IDs, and returns decoded API
payloads with C<rawJSON> attached for debugging.

 view release on metacpan or  search on metacpan

lib/Google/Plus.pm  view on Meta::CPAN

=head2 C<ua>

  my $ua = $plus->ua;
  my $ua = $plus->ua(Mojo::UserAgent->new);

User agent object that retrieves JSON from the Google+ API endpoint.
Defaults to a L<Mojo::UserAgent> object.  This object will use
HTTP/HTTPS proxies when available (via C<HTTP_PROXY> and C<HTTPS_PROXY>
environment variables.)

=head1 METHODS

 view release on metacpan or  search on metacpan

lib/Google/RestApi.pm  view on Meta::CPAN

  $self->{ua} = Furl->new(timeout => $self->{timeout});

  return bless $self, $class;
}

# this is the actual call to the google api endpoint. handles retries, error checking etc.
# this would normally be called via Drive or Sheets objects.
sub api {
  my $self = shift;

  state $check = signature(

lib/Google/RestApi.pm  view on Meta::CPAN

    return $url if $url;
  }
  return;
}

# the maximum number of attempts to call the google api endpoint before giving up.
# undef returns current value. postitive int sets and returns new value.
# 0 sets and returns default value.
sub max_attempts {
  my $self = shift;
  state $check = signature(positional => [PositiveOrZeroInt->where(sub { $_ < 10; }), { optional => 1 }]);

lib/Google/RestApi.pm  view on Meta::CPAN

API interacts with Google.

=head2 Chained API Calls

Every Google API module has an C<api()> method. Sub-resource objects
(see L<Google::RestApi::SubResource>) don't call the Google endpoint
directly; instead, each C<api()> prepends its own URI segment and
delegates to its parent's C<api()>. The calls chain upward until they
reach the top-level API module (e.g. DriveApi3), which prepends the
endpoint base URL and hands the fully-assembled URI to
C<Google::RestApi> for the actual HTTP request.

For example, deleting a reply on a comment on a file produces this chain:

 $reply->api(method => 'delete')

lib/Google/RestApi.pm  view on Meta::CPAN

The ultimate Google API call for the underlying classes. Handles timeouts and retries etc. %args consists of:

=over

=item * C<uri> <uri_string>: The Google API endpoint such as https://www.googleapis.com/drive/v3 along with any path segments added.

=item * C<method> <http_method_string>: The http method being used get|head|put|patch|post|delete.

=item * C<headers> <headers_string_array>: Array ref of http headers.

 view release on metacpan or  search on metacpan

lib/Gpx/Addons/Filter.pm  view on Meta::CPAN

            	if ($start < 915148800 or $end < 915148800) {
            	   carp("You are working on track-points dated before Jan 1, 1999 - strange. (Tip: this function accepts epoch-seconds only)")
            	}
            	
            	
            	# Comparing the timeframe with the segments start- and endpoint
				if ( ($first_point < $start) and ($last_point < $start) ) {
					##### Segment is completely outside of time-frame (before)
					next SEGMENT;
				} elsif (($first_point > $end) and ($last_point > $end)) {
					##### Segment is completely outside of time-frame (after)

 view release on metacpan or  search on metacpan

lib/Grammar/Graph.pm  view on Meta::CPAN

  my ($self, $src, $dst) = @_;
  $self->g->add_edge($dst, $_)
    for $self->g->successors($src);
}

sub _find_endpoints {
  my ($self, $id) = @_;

  my $symbols = $self->symbol_table;
  my $start = $symbols->{$id}{start_vertex};
  my $final = $symbols->{$id}{final_vertex};

lib/Grammar/Graph.pm  view on Meta::CPAN

      partner => $v1, name => $name);

    $self->set_vertex_label($v1, $p1);
    $self->set_vertex_label($v2, $p2);

    my ($start, $final) = $self->_find_endpoints($id);

    $self->_copy_predecessors($v, $v1);
    $self->_copy_successors($start, $v1);

    $self->_copy_successors($v, $v2);

lib/Grammar/Graph.pm  view on Meta::CPAN

  fa_remove_useless_epsilons($self, $self->g->vertices);
  _delete_unreachables($self);

  my $id = _find_id_by_shortname($self, $shortname);

  my ($start_vertex, $final_vertex) = _find_endpoints($self, $id);

  $self->_set_start_vertex($start_vertex);
  $self->_set_final_vertex($final_vertex);

  $self->fa_prelude_postlude($shortname);

 view release on metacpan or  search on metacpan

lib/Graph/Dijkstra.pm  view on Meta::CPAN

=head2 Version 0.4

	o Added input/output methods for Pajek (NET) format files
	o Lots of incompatible changes.
	o Changed references to edge attribute labels to consistently use: sourceID, targetID, and weight.  
	o In the farthestNode and shortestPath methods, changed origin and destination to originID and destinationID as the starting and endpoint node ID values.
	o Changed the node, edge, removeEdge, adjacent, and edgeExists methods to use hash references as parameters.  Get version of node method returns hash reference.
		> Thought is that using hash references as parameters will better support future addition of graph, node, and edge attributes.
	o Changed the farthestNode and shortestPath methods to input the node ID value(s) in the solution hash reference parameter as "originID" and "destinationID".
	o Changed the solution hash reference returned by the farthestNode, shortestPath methods to use sourceID, targetID, and weight as hash attributes replacing source, target, and cost
	o Added two graph level attributes: label and creator.  Attributes are input / output from / to files as supported by that format.

 view release on metacpan or  search on metacpan

lib/Graph/TransitiveClosure/Matrix.pm  view on Meta::CPAN

		}
		$si[$iu]->[$iv] = $V[$iv] unless $iu == $iv;
	    }
	}
    }
    # naming here is u = start, v = midpoint, w = endpoint
    for (my $iv = $#V; $iv >= 0; $iv--) {
	my $div = $di[$iv];
	my $aiv = $ai[$iv];
	for (my $iu = $#V; $iu >= 0; $iu--) {
	    my $aiu = $ai[$iu];