File Coverage

blib/lib/WebService/GData/Base.pm

Criterion	Covered	Total	%
statement	95	103	92.2
branch	34	44	77.2
condition	5	15	33.3
subroutine	21	21	100.0
pod	11	11	100.0
total	166	194	85.5

package WebService::GData::Base;
use WebService::GData 'private';
use base 'WebService::GData';

use WebService::GData::Query;
use WebService::GData::Error;
use WebService::GData::Constants qw(:all);

use JSON;
use LWP;

#the base class specifies the basic get/post/insert/update/delete methods

our $VERSION = 0.02_03;

sub __set {
    my ($this,$func,$val)=@_;
    die new WebService::GData::Error('forbidden_method_call',
        'agent() is used internally.' ) if $func eq 'agent';

    if(my $code = $this->{__UA__}->can($func)){
    	$code->($this->{__UA__},$val);
    	return $this;
    }
    die new WebService::GData::Error('unknown_method_call',
        $func.'() is not a LWP::UserAgent Method.' );
}

sub __get {
	my ($this,$func)=@_;
    die new WebService::GData::Error('forbidden_method_call',
        'agent() is used internally.' ) if $func eq 'agent';
	my $code = $this->{__UA__}->can($func);
	return $code->($this->{__UA__}) if $code;
    die new WebService::GData::Error('unknown_method_call',
        $func.'() is not a LWP::UserAgent Method.' );
}

sub __init {
    my ( $this, %params ) = @_;

    $this->{__COMPRESSION__}= FALSE;
    $this->{__OVERRIDE__}   = FALSE;
    $this->{__AUTH__}       = undef;
    $this->{__URI__}        = undef;
    $this->{__UA__}         = LWP::UserAgent->new;
    $this->{__UA_NAME__}    = '';
    $this->query( new WebService::GData::Query() );

    $this->auth( $params{auth} )
      if ( defined $params{auth} );
}

sub auth {
    my ( $this, $auth ) = @_;

    if ( _is_auth_object_compliant($auth) ) {
        $this->{__AUTH__} = $auth;
        $this->_set_ua_name;
    }
    return $this->{__AUTH__};
}

sub query {
    my ( $this, $query ) = @_;
    $this->{_basequery} = $query
      if ( _is_query_object_compliant($query) );
    return $this->{_basequery};
}

sub override_method {
    my ( $this, $override ) = @_;

    return $this->{__OVERRIDE__} if ( !$override );

    if ( $override eq TRUE ) {
        $this->{__OVERRIDE__} = TRUE;
    }
    if ( $override eq FALSE ) {
        $this->{__OVERRIDE__} = FALSE;
    }
}

sub enable_compression {
    my ( $this, $compression ) = @_;

    return $this->{__COMPRESSION__} if ( !$compression );

    if ( $compression eq TRUE ) {
        $this->{__COMPRESSION__} = TRUE;
    }
    if ( $compression eq FALSE ) {
        $this->{__COMPRESSION__} = FALSE;
    }
    $this->_set_ua_name;
}

sub user_agent_name {
    my ($this,$name) = @_;
    return $this->{__UA__}->agent if not defined $name;
    $this->{__UA_NAME__}=$name;
    $this->_set_ua_name;

}

sub get_uri {
    my $this = shift;
    return $this->{__URI__};
}


sub get {
    my ( $this, $uri,$with_query_string ) = @_;

    #the url from the feeds contain the version but not the one we pass directly
    $this->query->set_from_query_string($uri) if $with_query_string;

    $uri = _delete_query_string($uri);

    _error_invali_uri('get') if ( !$uri || length($uri) == 0 );

    $this->{__URI__} = $uri;
    my $req = HTTP::Request->new( GET => $uri . $this->query->to_query_string );
    $req->content_type('application/atom+xml; charset=UTF-8');

    $this->_prepare_request($req);

    my $ret = $this->_request($req);
    return $this->query->get('alt') =~ m/^jsonc*$/ ? from_json($ret) : $ret;

}

sub post {
    my ( $this, $uri, $content ) = @_;

    _error_invali_uri('post') if ( !$uri || length($uri) == 0 );

    $this->{__URI__} = $uri;
    my $req = HTTP::Request->new( POST => $uri );
    $req->content_type('application/x-www-form-urlencoded');
    $this->_prepare_request( $req, length($content) );
    $req->content($content);
    return $this->_request($req);
}

sub insert {
    my ( $this, $uri, $content, $callback ) = @_;

    _error_invali_uri('insert') if ( !$uri || length($uri) == 0 );

    return $this->_save( 'POST', $uri, $content, $callback );
}

sub update {
    my ( $this, $uri, $content, $callback ) = @_;

    _error_invali_uri('update') if ( !$uri || length($uri) == 0 );

    return $this->_save( 'PUT', $uri, $content, $callback );
}

sub delete {
    my ( $this, $uri ) = @_;

    _error_invali_uri('delete') if ( !$uri || length($uri) == 0 );

    $this->{__URI__} = $uri;
    my $req;
    if ( $this->override_method eq TRUE ) {
        $req = HTTP::Request->new( POST => $uri );
        $req->header( 'X-HTTP-Method-Override' => 'DELETE' );
    }
    else {
        $req = HTTP::Request->new( DELETE => $uri );
    }
    $req->content_type('application/atom+xml; charset=UTF-8');
    $this->_prepare_request($req);

    return $this->_request($req);
}

###PRIVATE###

#methods#

private _set_ua_name => sub {
    my ( $this ) = @_;
    my $custom = $this->{__UA_NAME__} ? $this->{__UA_NAME__}.' ' : '';
    my $name = $custom._ua_base_name();
       $name = $this->auth->source . ' ' . $name if $this->auth;
       $name.= ' (gzip)' if $this->enable_compression eq TRUE;
    $this->{__UA__}->agent($name);
};

private _request => sub {
    my ( $this, $req ) = @_;

    $this->_set_ua_name();

    if($this->enable_compression eq TRUE) {
    	my $compressions = HTTP::Message::decodable();
        $this->{__UA__}->default_header('Accept-Encoding' => $compressions) if $compressions=~m/gzip/;
    }

    my $res = $this->{__UA__}->request($req);

    if ( $res->is_success ) {
        return $this->enable_compression eq TRUE ? $res->decoded_content():$res->content();
    }
    else {
        die new WebService::GData::Error( $res->code, $res->content );
    }
};

private _save => sub {
    my ( $this, $method, $uri, $content, $callback ) = @_;
    $this->{__URI__} = $uri;
    my $req;
    if ( $this->override_method eq TRUE && $method =~ m/PUT|PATCH/ ) {
        $req = HTTP::Request->new( POST => $uri );
        $req->header( 'X-HTTP-Method-Override' => $method );
    }
    else {
        $req = HTTP::Request->new( "$method" => $uri );
    }
    $req->content_type('application/atom+xml; charset=UTF-8');



    $this->_prepare_request( $req, length($content) );
    $req->content($content);
    if ($callback) {
        &$callback($req);
    }

    return $this->_request($req);
};

private _prepare_request => sub {
    my ( $this, $req, $length ) = @_;
    $req->header( 'GData-Version' => $this->query->get('v') );
    $req->header( 'Content-Length' => $length ) if ($length);
    if ( $this->auth ) {
        $this->auth->set_authorization_headers( $this, $req );
        $this->auth->set_service_headers( $this, $req );
    }
};

#sub#

private _error_invali_uri => sub {
    my $method = shift;
    die new WebService::GData::Error( 'invalid_uri',
        'The uri is empty in ' . $method . '().' );
};

private _ua_base_name => sub {
    return __PACKAGE__ . "/" . $VERSION;
};


private _is_object => sub {
    my $val = shift;
    eval { $val->can('can'); };
    return undef if ($@);
    return 1;

};

#duck typing has I don't want to enfore inheritance
private _is_auth_object_compliant => sub {
    my $auth = shift;
    return 1
      if ( _is_object($auth)
        && $auth->can('set_authorization_headers')
        && $auth->can('set_service_headers')
        && $auth->can('source') );
    return undef;
};

private _is_query_object_compliant => sub {
    my $query = shift;
    return 1
      if ( _is_object($query)
        && $query->can('to_query_string')
        && $query->can('get')
        && int( $query->get('v') ) >= GDATA_MINIMUM_VERSION );
    return undef;
};

private _delete_query_string => sub {
    my $uri = shift;
    $uri =~ s/\?.*//;
    return $uri;
};

"The earth is blue like an orange.";

__END__