view release on metacpan or  search on metacpan

t/at.t  view on Meta::CPAN

At(./:action/{}/)

Under(root) At(a/b/c/{id}/...)
Under(root) At($action/{id}/{date}
/)


sub myaction($view, $model) :At($local/{id}) {
  $view->ok($model->find($id));
}

  NamedFields(id=>$args[0])
  
sub myaction :At($local/{id:Int}?{page}{order:Int}) {
  $_->view->ok($_->model->find($_{id})
    || $_->detach('/not_found'));
}

  sub notfound :At($local/{id:Int}?{page}&{order:Int}) {
    $_->view->not_found(message => "Id $_{id} is not in the database");
  }

  sub myaction :At($local/{u:User}?{page}&{order:Int}) {
    $_->view->ok($_{u});
  }

sub myaction($view, $model M::Schema::User::Result) :At($local/{id}) {
  $view->ok($model->find($id));
}


Via(action)
Via(/path/to)
Via(../to)
Via(../:action)
Via(:up/:action)


At(:action/{id:Int}?{sort='desc':SortEnum})


Take what is inside Via, expand placeholders, and set Chained($val);
Take what is inside At
  - if Via doesn't exist, do Chained(/)
  - figure out any pathparts (after expanding placeholders
  - figure out any Args(X), Args or CaptureArgs(x) (including Constraints).
  - Add actionroles for  Named Args as need,

An At has a path part section an args or capture args section (look for trailing ...)
  and a query section.

package MyApp::Controller::Example;

use Moose;
use MooseX::MethodAttributes;

extends 'Catalyst::Controller';

sub root :At($controller/...) { }

  sub endpoint :Via(root) At({id}) {
    my ($self, $c, $id) = @_;
  }

  sub endpoin2 :Under(root) At({id}/{@}) {
    my ($self, $c, @args) = @_;
  }

__PACKAGE__->meta->make_immutable;

package MyApp::Controller::Example;

use Moose;
use MooseX::MethodAttributes;

extends 'Catalyst::Controller';

sub root Chained(/) PathPrefix CaptureArgs(0) { }

  sub endpoint :Chained(root) PathPrefix('') Args(1) {
    my ($self, $c, $id) = @_;
  }

  sub endpoin2 :Chained(root) PathPrefix('') Args {
    my ($self, $c, @args) = @_;
  }

__PACKAGE__->meta->make_immutable;


__END__

?? What URL paths are mapped here
?? what does 'warn $_{id}' do?
?? Would :Via work as well as :Under?


At(/foo/{$:User.0}/{$:User.1}%{$:User.age}{$:User.name}
At(/user/{id:User}%{params*:User}

If a Type::Foo accepts context, then $c is part of any coercions

sub myaction(User $u) :At(/user/{id:User}) {

}


sub foo :Local Named(foo=>$arg[0],bar=>$query{id}) 


sub foo :At(./{id:User}) { ... }
sub foo :At(./{id:User,User.email}) { ... }
sub foo :At(./{id:User,User.email}) { ... }


sub user :At(./{id:User} { }
  sub friend :Via(user) At({id:Friend[user:User.id


#######

sub myaction([$id1,$id2]->User $u) At(users/{id1:Int}/{id2:Int})
sub myaction([Arg,Arg]->User $u) At(users/{id1:Int}/{id2:Int})

# User isa Model::Type::User

sub myaction(User $u) Via(root) At(users/{User.0:id1}/{User.1:id2})
{
  $_{User} isa Model::Schema::User::Result
}

OR

sub myaction([id1,id2]->User $u ==> UserResultSet) 
    Via(root) At(users/{id1:Int}/{id2:Int})
{
  $_{User} isa Model::Schema::User::Result
}

is User->coerce([id1,id2])