Geo::Coder::Bing - Geocode addresses with the Bing Maps API

    use Geo::Coder::Bing;

    my $geocoder = Geo::Coder::Bing->new(key => 'Your Bing Maps key');
    my $location = $geocoder->geocode(
        location => 'Hollywood and Highland, Los Angeles, CA'
    );

    $geocoder = Geo::Coder::Bing->new('Your Bing Maps key')
    $geocoder = Geo::Coder::Bing->new(
        key   => 'Your Bing Maps key',
        # https => 1,
        # debug => 1,
    )

    $location = $geocoder->geocode(location => $location)
    @locations = $geocoder->geocode(location => $location)

    {
        __type =>
            "Location:http://schemas.microsoft.com/search/local/ws/rest/v1",
        address => {
            addressLine   => "Hollywood Blvd & N Highland Ave",
            adminDistrict => "CA",
            countryRegion => "United States",
            formattedAddress =>
                "Hollywood Blvd & N Highland Ave, Los Angeles, CA 90028",
            locality   => "Los Angeles",
            postalCode => 90028,
        },
        bbox => [
            "34.0977008647939", "-118.344888641665",
            "34.1054262999352", "-118.332449571785",
        ],
        confidence => "High",
        entityType => "RoadIntersection",
        name  => "Hollywood Blvd & N Highland Ave, Los Angeles, CA 90028",
        point => {
            coordinates => [ "34.1015635823646", "-118.338669106725" ],
            type        => "Point",
        },
    }

    $response = $geocoder->response()

    $ua = $geocoder->ua()
    $ua = $geocoder->ua($ua)

    perldoc Geo::Coder::Bing

package Geo::Coder::Bing;

use strict;
use warnings;

use Carp qw(carp croak);
use Encode ();
use JSON;
use LWP::UserAgent;
use URI;

our $VERSION = '0.11';
$VERSION = eval $VERSION;

sub new {
    my ($class, @params) = @_;
    my %params = (@params % 2) ? (key => @params) : @params;

    carp 'Provide a Bing Maps key to use the new REST API'
        unless $params{key};

    my $self = bless \ %params, $class;

    $self->ua(
        $params{ua} || LWP::UserAgent->new(agent => "$class/$VERSION")
    );

    if ($self->{debug}) {
        my $dump_sub = sub { $_[0]->dump(maxlength => 0); return };
        $self->ua->set_my_handler(request_send  => $dump_sub);
        $self->ua->set_my_handler(response_done => $dump_sub);
    }
    elsif (exists $self->{compress} ? $self->{compress} : 1) {
        $self->ua->default_header(accept_encoding => 'gzip,deflate');
    }

    croak q('https' requires LWP::Protocol::https)
        if $self->{https} and not $self->ua->is_protocol_supported('https');

    return $self;
}

sub response { $_[0]->{response} }

sub ua {
    my ($self, $ua) = @_;
    if ($ua) {
        croak q('ua' must be (or derived from) an LWP::UserAgent')
            unless ref $ua and $ua->isa(q(LWP::UserAgent));
        $self->{ua} = $ua;
    }
    return $self->{ua};
}

sub geocode {
    return $_[0]->{key} ? &_geocode_rest : &_geocode_ajax;
}

sub _geocode_rest {
    my ($self, @params) = @_;
    my %params = (@params % 2) ? (location => @params) : @params;

    my $location = $params{location} or return;
    $location = Encode::encode('utf-8', $location);

    my $uri = URI->new('http://dev.virtualearth.net/REST/v1/Locations');
    $uri->scheme('https') if $self->{https};
    $uri->query_form(
        key => $self->{key},
        q   => $location,
    );

    my $res = $self->{response} = $self->ua->get($uri);
    return unless $res->is_success;

    # Change the content type of the response from 'application/json' so
    # HTTP::Message will decode the character encoding.
    $res->content_type('text/plain');

    my $content = $res->decoded_content;
    return unless $content;

    my $data = eval { from_json($content) };
    return unless $data;

    my @results = @{ $data->{resourceSets}[0]{resources} || [] };
    return wantarray ? @results : $results[0];
}

# Support AJAX API for backwards compatibility.

sub _geocode_ajax {
    my ($self, @params) = @_;
    my %params = (@params % 2) ? (location => @params) : @params;

    my $location = $params{location} or return;
    $location = Encode::encode('utf-8', $location);

    my $uri = URI->new('http://dev.virtualearth.net/');
    $uri->scheme('https') if $self->{https};
    $uri->path_segments(qw(
        services v1 geocodeservice geocodeservice.asmx Geocode
    ));
    $uri->query_form(
        format => 'json',

        # Note: the quotes around the location parameter are required.
        query  => qq("$location"),

        # These are all required, even if empty.
        map { $_ => '' } qw(
            addressLine adminDistrict count countryRegion culture
            curLocAccuracy currentLocation district entityTypes landmark
            locality mapBounds postalCode postalTown rankBy
        ),
    );

    my $res = $self->{response} = $self->ua->get($uri);
    return unless $res->is_success;

    # Change the content type of the response from 'application/json' so
    # HTTP::Message will decode the character encoding.
    $res->content_type('text/plain');

    my $content = $res->decoded_content;
    return unless $content;

    # Workaround invalid data.
    $content =~ s[ \}\.d $ ][}]x;

    my $data = eval { from_json($content) };
    return unless $data;

    my @results = @{ $data->{d}{Results} || [] };
    return wantarray ? @results : $results[0];
}


1;

__END__