File Coverage

blib/lib/Net/HTTP/Knork.pm

Criterion	Covered	Total	%
statement	118	127	92.9
branch	21	32	65.6
condition	8	13	61.5
subroutine	23	25	92.0
pod	1	7	14.2
total	171	204	83.8

package Net::HTTP::Knork;

# ABSTRACT: Lightweight implementation of Spore specification
use Moo;
use Sub::Install;
use Try::Tiny;
use Carp;
use JSON::MaybeXS;
use Data::Rx;
use LWP::UserAgent;
use URI;
use File::ShareDir ':ALL';
use Subclass::Of;
use Net::HTTP::Knork::Request;
use Net::HTTP::Knork::Response;

with 'Net::HTTP::Knork::Role::Middleware';


has 'client' => ( is => 'lazy', );

# option that allows one to pass optional parameters that are not specified
# in the spore 'optional_params' section for a given method

has 'lax_optionals' => ( is => 'rw', default => sub {0} );

has 'base_url' => (
    is      => 'rw',
    lazy    => 1,
    builder => sub {
        return $_[0]->spec->{base_url};
    }
);

has 'request' => (
    is      => 'rw',
    lazy    => 1,
    clearer => 1,
    builder => sub {
        return Net::HTTP::Knork::Request->new( $_[0]->env );
    }
);

has 'env' => ( is => 'rw', );

has 'spec' => (
    is       => 'lazy',
    required => 1,
    coerce   => sub {
        my $json_spec = $_[0];
        my $spec;

        # it could be a file
        try {
            open my $fh, '<', $json_spec or croak 'Cannot read the spec file';
            local $/ = undef;
            binmode $fh;
            $spec = decode_json(<$fh>);
            close $fh;
        }
        catch {
            try {
                $spec = decode_json($json_spec);
            }

            # it is not json, so we are returning the string as is
            catch {
                $spec = $json_spec;
            };
        };
        return $spec;
    }
);

has 'default_params' => (
    is        => 'rw',
    default   => sub { {} },
    predicate => 1,
    clearer   => 1,
    writer    => 'set_default_params',
);

has 'spore_rx' => (
    is      => 'rw',
    default => sub {
        return dist_file(
            'Net-HTTP-Knork',
            'config/specs/spore_validation.rx'
        );
    }
);


# Change the namespace of a given instance, so that there won't be any
# method collision between two instances

sub BUILD {
    my $self     = shift;
    my $subclass = subclass_of('Net::HTTP::Knork');
    bless( $self, $subclass );
    $self->build_from_spec();
}

sub _build_client {
    my $self = shift;
    return LWP::UserAgent->new();
}

sub validate_spore {
    my ( $self, $spec ) = @_;
    my $rx = Data::Rx->new;
    my $spore_schema;
    if ( -f $self->spore_rx ) {
        open my $fh, "<", $self->spore_rx;
        binmode $fh;
        local $/ = undef;
        $spore_schema = <$fh>;
        close $fh;
    }
    else {
        croak "Spore schema " . $self->spore_rx . " could not be found";
    }
    my $json_schema = decode_json($spore_schema);
    my $schema      = $rx->make_schema($json_schema);
    try {
        my $valid = $schema->assert_valid($spec);
    }
    catch {
        croak "Spore specification is invalid, please fix it\n" . $_;
    };
}

# take a spec and instanciate methods that matches those

sub build_from_spec {
    my $self = shift;
    my $spec = $self->spec;

    $self->validate_spore($spec);
    my $base_url = $self->base_url;
    croak
      'We need a base URL, either in the spec or as a parameter to build_from_spec'
      unless $base_url;
    $self->build_methods();
}

sub build_methods {
    my $self = shift;
    foreach my $method ( keys %{ $self->spec->{methods} } ) {
        my $sub_from_spec =
          $self->make_sub_from_spec( $self->spec->{methods}->{$method} );
        Sub::Install::install_sub(
            {   code => $sub_from_spec,
                into => ref($self),
                as   => $method,
            }
        );
    }
}

sub make_sub_from_spec {
    my $reg       = shift;
    my $meth_spec = shift;
    return sub {
        my $self = shift;
        $self->clear_request;

        my %param_spec;
        if (scalar @_ == 1 and ref($_[0]) eq 'HASH') {
            %param_spec = %{ $_[0] };
        }
        else {
            %param_spec = @_;
        }

        if ( $self->has_default_params ) {
            foreach my $d_param ( keys( %{ $self->default_params } ) ) {
                $param_spec{$d_param} = $self->default_params->{$d_param};
            }
        }
        my %method_args = %{$meth_spec};
        my $method      = $method_args{method};
        my $payload =
          ( defined $param_spec{spore_payload} )
          ? delete $param_spec{spore_payload}
          : delete $param_spec{payload};

        if ( $method_args{required_payload} && !$payload ) {
            croak "this method requires a payload and no payload is provided";
        }
        if ( $payload
            && ( $method !~ /^(?:POST|PUT|PATCH)$/i ) )
        {
            croak "payload requires a PUT, PATCH or POST method";
        }

        $payload //= undef;

        if ( $method_args{required_params} ) {
            foreach my $required ( @{ $method_args{required_params} } ) {
                if ( !grep { $required eq $_ } keys %param_spec ) {
                    croak
                      "Parameter '$required' is marked as required but is missing";
                }
            }
        }

        my $params;
        foreach ( @{ $method_args{required_params} } ) {
            push @$params, $_, delete $param_spec{$_};
        }

        foreach ( @{ $method_args{optional_params} } ) {
            push @$params, $_, delete $param_spec{$_}
              if ( defined( $param_spec{$_} ) );
        }
        if (%param_spec) {
            if ( $self->lax_optionals ) {
                foreach ( keys %param_spec ) {
                    push @$params, $_, delete $param_spec{$_};
                }
            }
        }

        my $base_url =
          ( exists $method_args{base_url} )
          ? $method_args{base_url}
          : $self->base_url;
        $base_url = URI->new( $base_url );
        my $env      = {
            REQUEST_METHOD => $method,
            SERVER_NAME    => $base_url->host,
            SERVER_PORT    => $base_url->port,
            SCRIPT_NAME    => (
                $base_url->path eq '/'
                ? ''
                : $base_url->path
            ),
            PATH_INFO       => $method_args{path},
            REQUEST_URI     => '',
            QUERY_STRING    => '',
            HTTP_USER_AGENT => $self->client->agent // '',

            'spore.params'     => $params,
            'spore.payload'    => $payload,
            'spore.errors'     => *STDERR,
            'spore.url_scheme' => $base_url->scheme,
            'spore.userinfo'   => $base_url->userinfo,

        };
        $self->env($env);
        my $request      = $self->request->finalize();
        my $raw_response = $self->perform_request($request);
        return $self->generate_response($raw_response);
    };
}


sub perform_request {
    my $self    = shift;
    my $request = shift;
    return $self->client->request($request);
}

sub generate_response {
    my $self           = shift;
    my $raw_response   = shift;
    my $orig_response  = shift;
    my $knork_response = $self->request->new_response(
        $raw_response->code, $raw_response->message, $raw_response->headers,
        $raw_response->content
    );
    if ( defined($orig_response) ) {
        $knork_response->raw_body( $orig_response->content )
          unless defined( ( $knork_response->raw_body ) );
    }
    return $knork_response;
}



1;

__END__