File Coverage

lib/WebService/Gyazo/B.pm

Criterion	Covered	Total	%
statement	59	71	83.1
branch	17	26	65.3
condition	8	16	50.0
subroutine	14	14	100.0
pod	6	6	100.0
total	104	133	78.2

package WebService::Gyazo::B;

use strict;
use warnings;

use WebService::Gyazo::B::Image;

use LWP::UserAgent;
use LWP::Protocol::socks;
use HTTP::Request::Common;
use URI::Simple;

our $VERSION = '0.0405';

my %PROXY_PROTOCOLS = (map { $_ => 1 } qw(http https socks socks4));

sub new {
	my ($self, %args) = @_;
	$self = bless(\%args, $self);

	return $self;
}

# Get/set error message
sub error {
	return shift->{error} || 'N/A';
}

sub _error {
	my ( $self, $error_str ) = @_;
	if ( $error_str ) {
		$self->{error} = $error_str;
	}

	return $self->{error};
}

sub isError {
	return shift->{error} ? 1 : 0;
}

# Set proxy
sub setProxy {
	my ($self, $proxyStr) = @_;

	if ( !$proxyStr ) {
		$self->_error('Undefined proxy value!');
		return 0;
	}

	# If $proxyStr was passed, get protocol, ip and port from it
	my $proxyUrl = URI::Simple->new($proxyStr);

	# Check if we have protocol and host/ip from proxy string
	if ( !$proxyUrl->protocol || !$proxyUrl->host ) {
		$self->_error('Wrong proxy protocol or hostname!');
		return 0;
	}

	# Check if protocol is correct
	if ( ! exists($PROXY_PROTOCOLS{$proxyUrl->protocol})) {
		$self->_error('Wrong protocol type: ' . $proxyUrl->protocol);
		return 0;
	}

	# Check if port is correct
	if ( $proxyUrl->port && $proxyUrl->port > 65535 ) {
		$self->_error('Wrong proxy port!');
		return 0;
	}

	$self->{proxy} = sprintf("%s://%s:%s", $proxyUrl->protocol, $proxyUrl->host, $proxyUrl->port || 80);

	return 1;
}

# Assign ID
sub setId {
	my ($self, $id) = @_;

	# Check the length of ID
	if ( ! defined $id || $id !~ m#^\w{1,14}$# ) {
		$self->_error('Wrong id syntax!');
		return 0;
	}

	$self->{id} = $id;

	return 1;
}

# Upload file
sub uploadFile {
	my ($self, $filename) = @_;

	# Assign ID unless already assigned
	$self->{id} ||= time();

	# Check if file path was passed
	if ( ! defined $filename ) {
		$self->_error('File parameter was not specified or is undef!');
		return 0;
	}

	# Check if it is a file
	if ( ! -f $filename ) {
		$self->_error('File parameter to uploadFile() was not found!');
		return 0;
	}

	# Check if file is readable
	if ( ! -r $filename) {
		$self->error('The file parameter to uploadFile() is not readable!');
		return 0;
	}

	# Create user agent object
	$self->{ua} = LWP::UserAgent->new('agent' => 'Gyazo/'.$VERSION) unless (defined $self->{ua});

	# Assign proxy if it was passed
	$self->{ua}->proxy(['http'], $self->{proxy}.'/') if ($self->{proxy});

	# Create object for POST-request
	my $req = POST('https://gyazo.com/upload.cgi',
		'Content_Type' => 'form-data',
		'Content' => [
			'id' => $self->{id},
			'imagedata' => [$filename],
		]
	);

	# Send POST-request and check the response
	my $res = $self->{ua}->request($req);
	if ( my ($id) = ($res->content) =~ m#https://gyazo.com/(\w+)#is ) {
		return WebService::Gyazo::B::Image->new(id => $id);
	} else {
		$self->_error("Cannot parsed URL in the:\n".$res->as_string."\n");
		return 0;
	}
}

1;

__END__