factor dispatcher out into Web::Dispatch

[catagits/Web-Simple.git] / lib / Web / Simple / Application.pm

diff --git a/lib/Web/Simple/Application.pm b/lib/Web/Simple/Application.pm
index 4021170..a6ada44 100644 (file)
--- a/lib/Web/Simple/Application.pm
+++ b/lib/Web/Simple/Application.pm
@@ -3,61 +3,6 @@ package Web::Simple::Application;
 use strict;
 use warnings FATAL => 'all';
 
-{
-  package Web::Simple::Dispatcher;
-
-  sub _is_dispatcher {
-    ref($_[1])
-      and "$_[1]" =~ /\w+=[A-Z]/
-      and $_[1]->isa(__PACKAGE__);
-  }
-
-  sub next {
-    @_ > 1
-      ? $_[0]->{next} = $_[1]
-      : shift->{next}
-  }
-
-  sub set_next {
-    $_[0]->{next} = $_[1];
-    $_[0]
-  }
-
-  sub dispatch {
-    my ($self, $env, @args) = @_;
-    my $next = $self->_has_match ? $self->next : undef;
-    if (my ($env_delta, @match) = $self->_match_against($env)) {
-      if (my ($result) = $self->_execute_with(@args, @match, $env)) {
-        if ($self->_is_dispatcher($result)) {
-          $next = $result->set_next($next);
-          $env = { %$env, %$env_delta };
-        } else {
-          return $result;
-        }
-      }
-    }
-    return () unless $next;
-    return $next->dispatch($env, @args);
-  }
-
-  sub call {
-    @_ > 1
-      ? $_[0]->{call} = $_[1]
-      : shift->{call}
-  }
-
-  sub _has_match { $_[0]->{match} }
-
-  sub _match_against {
-     return ({}, $_[1]) unless $_[0]->{match};
-     $_[0]->{match}->($_[1]);
-  }
-
-  sub _execute_with {
-    $_[0]->{call}->(@_);
-  }
-}
-
 sub new {
   my ($class, $data) = @_;
   my $config = { $class->_default_config, %{($data||{})->{config}||{}} };
@@ -107,26 +52,25 @@ sub config {
 }
 
 sub _construct_response_filter {
-  my $code = $_[1];
-  $_[0]->_build_dispatcher({
-    call => sub {
-      my ($d, $self, $env) = (shift, shift, shift);
-      my @next = $d->next->dispatch($env, $self, @_);
-      return unless @next;
-      $self->_run_with_self($code, @next);
-    },
+  my ($class, $code) = @_;
+  my $self = do { no strict 'refs'; ${"${class}::self"} };
+  require Web::Dispatch::Wrapper;
+  Web::Dispatch::Wrapper->from_code(sub {
+    my @result = $_[1]->($_[0]);
+    if (@result) {
+      $self->_run_with_self($code, @result);
+    } else {
+      @result;
+    }
   });
 }
 
 sub _construct_redispatch {
-  my ($self, $new_path) = @_;
-  $self->_build_dispatcher({
-    call => sub {
-      shift;
-      my ($self, $env) = @_;
-      $self->_dispatch({ %{$env}, PATH_INFO => $new_path })
-    }
-  })
+  my ($class, $new_path) = @_;
+  require Web::Dispatch::Wrapper;
+  Web::Dispatch::Wrapper->from_code(sub {
+    $_[1]->({ %{$_[0]}, PATH_INFO => $new_path });
+  });
 }
 
 sub _build_dispatch_parser {
@@ -144,95 +88,21 @@ sub _cannot_call_twice {
 }
 
 sub _setup_dispatcher {
-  my ($class, $dispatch_specs) = @_;
+  my ($class, $dispatcher) = @_;
   {
     no strict 'refs';
     if (${"${class}::_dispatcher"}{CODE}) {
       $class->_cannot_call_twice('_setup_dispatcher', 'dispatch');
     }
   }
-  my $chain = $class->_build_dispatch_chain(
-    [ @$dispatch_specs, $class->_build_final_dispatcher ]
-  );
   {
     no strict 'refs';
-    *{"${class}::_dispatcher"} = sub { $chain };
-  }
-}
-
-sub _construct_subdispatch {
-  my ($class, $dispatch_spec) = @_;
-  my $disp = $class->_build_dispatcher_from_spec($dispatch_spec);
-  my $call = $disp->call;
-  $disp->call(sub {
-    my @res = $call->(@_);
-    return unless @res;
-    my $chain = $class->_build_dispatch_chain(@res);
-    return $class->_build_dispatcher({
-      call => sub {
-        my ($d, $self, $env) = (shift, shift, shift); pop; # lose trailing $env
-        return $chain->dispatch($env, $self, @_);
-      }
-    });
-  });
-  return $class->_build_dispatcher({
-    call => sub {
-      my ($d, $self, $env) = (shift, shift, shift); pop; # lose trailing $env
-      my @sub = $disp->dispatch($env, $self, @_);
-      return @sub if @sub;
-      return unless (my $next = $d->next);
-      return $next->dispatch($env, $self, @_);
-    },
-  });
-}
-
-sub _build_dispatcher_from_spec {
-  my ($class, $spec) = @_;
-  return $spec unless ref($spec) eq 'CODE';
-  my $proto = prototype $spec;
-  my $parser = $class->_build_dispatch_parser;
-  my $matcher = (
-    defined($proto) && length($proto)
-      ? $parser->parse($proto)
-      : sub { ({}, $_[1]) }
-  );
-  return $class->_build_dispatcher({
-    match => $matcher,
-    call => sub { shift;
-      shift->_run_with_self($spec, @_)
-    },
-  });
-}
-
-sub _build_dispatch_chain {
-  my ($class, $dispatch_specs) = @_;
-  my ($root, $last);
-  foreach my $dispatch_spec (@$dispatch_specs) {
-    my $new = $class->_build_dispatcher_from_spec($dispatch_spec);
-    $root ||= $new;
-    $last = $last ? $last->next($new) : $new;
+    *{"${class}::dispatch_request"} = $dispatcher;
   }
-  return $root;
-}
-
-sub _build_dispatcher {
-  bless($_[1], 'Web::Simple::Dispatcher');
 }
 
 sub _build_final_dispatcher {
-  shift->_build_dispatcher({
-    call => sub {
-      [
-        404, [ 'Content-type', 'text/plain' ],
-        [ 'Not found' ]
-      ]
-    }
-  })
-}
-
-sub _dispatch {
-  my ($self, $env) = @_;
-  $self->_dispatcher->dispatch($env, $self);
+  [ 404, [ 'Content-type', 'text/plain' ], [ 'Not found' ] ]
 }
 
 sub _run_with_self {
@@ -264,7 +134,14 @@ sub _run_fcgi {
 
 sub as_psgi_app {
   my $self = ref($_[0]) ? $_[0] : $_[0]->new;
-  sub { $self->_dispatch(@_) };
+  require Web::Dispatch;
+  require Web::Simple::DispatchNode;
+  my $final = $self->_build_final_dispatcher;
+  Web::Dispatch->new(
+    app => sub { $self->dispatch_request(@_), $final },
+    node_class => 'Web::Simple::DispatchNode',
+    node_args => { app_object => $self }
+  )->to_app;
 }
 
 sub run {