view release on metacpan or  search on metacpan

lib/Forward/Routes.pm  view on Meta::CPAN

package Forward::Routes;
use strict;
use warnings;

use 5.010001;

use Forward::Routes::Match;
use Forward::Routes::Pattern;
use Forward::Routes::Resources;
use Scalar::Util qw/weaken/;
use Carp 'croak';

our $VERSION = '0.56';


## ---------------------------------------------------------------------------
##  Constructor
## ---------------------------------------------------------------------------

sub new {
    my $class = shift;
    my $self = bless {}, $class;
    return $self->initialize(@_);
}


sub initialize {
    my $self = shift;

    # block
    my $code_ref = pop @_ if @_ && ref $_[-1] eq 'CODE';

    # inherit
    $self->{_inherit_format} = 1;
    $self->{_inherit_via} = 1;
    $self->{_inherit_namespace} = 1;
    $self->{_inherit_app_namespace} = 1;

    # Pattern
    my $pattern = @_ % 2 ? shift : undef;
    $self->pattern->pattern($pattern) if defined $pattern;

    # Shortcut in case of chained API
    return $self unless @_ || $code_ref;

    # Remaining params
    my $params = ref $_[0] eq 'HASH' ? {%{$_[0]}} : {@_};

    $self->format(delete $params->{format}) if exists $params->{format};
    $self->via(delete $params->{via}) if exists $params->{via};
    $self->namespace(delete $params->{namespace}) if exists $params->{namespace};
    $self->app_namespace(delete $params->{app_namespace}) if exists $params->{app_namespace};
    $self->defaults(delete $params->{defaults});
    $self->name(delete $params->{name});
    $self->to(delete $params->{to});
    $self->constraints(delete $params->{constraints});
    $self->resource_name(delete $params->{resource_name});

    # after inheritance
    $code_ref->($self) if $code_ref;

    return $self;
}


## ---------------------------------------------------------------------------
##  Routes tree
## ---------------------------------------------------------------------------

sub add_route {

lib/Forward/Routes.pm  view on Meta::CPAN

    $params = Forward::Routes::Resources->_prepare_resource_options(@$params);

    my $last_resource;

    while (my $name = shift @$params) {

        my $options;
        if (@$params && ref $params->[0] eq 'HASH') {
            $options = shift @$params;
        }

        $last_resource = $self->_add_singular_resource($name, $options);
    }

    return $last_resource;
}


sub _add_singular_resource {
    my $self = shift;
    my ($resource_name, $options) = @_;

    my $resource = Forward::Routes::Resources::Singular->new($resource_name,
        resource_name => $options->{as} // $resource_name,
        %$options
    );
    $resource->init_options($options);

    $resource->_adjust_nested_resources($self);

    $self->add_child($resource);

    # after _adjust_nested_resources because parent name is needed for route name
    # after add_child because of namespace inheritance for route name
    $resource->preprocess;
   
    $resource->inflate;
    
    return $resource;
}


sub bridge {
    my $self = shift;
    return $self->add_route(@_)->_is_bridge(1);
}


sub children {
    my $self = shift;
    return $self->{children} ||= [];
}


sub parent {
    my $self = shift;
    my ($value) = @_;
    return $self->{parent} unless $value;
    
    $self->{parent} = $value;
    weaken $self->{parent};
    return $self;
}


sub add_child {
    my $self = shift;
    my ($child) = @_;

    # child
    push @{$self->children}, $child;

    # parent
    $child->parent($self);

    # inheritance
    $child->format(        [@{$self->{format}}]   ) if $self->{format}        && $child->_inherit_format;
    $child->via(           [@{$self->{via}}]      ) if $self->{via}           && $child->_inherit_via;
    $child->namespace(     $self->{namespace}     ) if $self->{namespace}     && $child->_inherit_namespace;
    $child->app_namespace( $self->{app_namespace} ) if $self->{app_namespace} && $child->_inherit_app_namespace;

    return $child;
}


## ---------------------------------------------------------------------------
##  Route attributes
## ---------------------------------------------------------------------------

sub app_namespace {
    my $self = shift;
    my (@params) = @_;

    return $self->{app_namespace} unless @params;

    $self->{_inherit_app_namespace} = 0;

    $self->{app_namespace} = $params[0];

    return $self;
}


sub constraints {
    my $self = shift;

    return $self->pattern->constraints unless defined $_[0];

    $self->pattern->constraints(@_);

    return $self;
}


sub defaults {
    my $self = shift;
    my (@params) = @_;

    # Initialize
    my $d = $self->{defaults} ||= {};