pakyow-routing 1.0.0.rc2 → 1.0.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03a293a804dec482d43a8d9b780bc8cabb82c2f89de3f1e6f80cdba49b70873e
-  data.tar.gz: 0d77d9f5aa487a5331fd1ba69a1411f5369386feff0e3a9d3b1fe0eeeb5079e8
+  metadata.gz: 52a52fa15197c4a3509beb255ae01273b7872478f60e19c5ec5833413ebb48c4
+  data.tar.gz: 9379faaa3d68a7cf1ded42adf87b6de01ed1616f591e565f4f374684fbc3fc04
 SHA512:
-  metadata.gz: 16aa58f093586062b904ef2bf4fdb5b2e0576e4d3dd41bb4adf7981e49cef31976f1c7049cd2f117cb91fed99c92ce825fe61c715094e272111094b32d843194
-  data.tar.gz: 21ecd4b69fe8039bda853c3a2e61e96d8f4fd27caf0be8d8669ce339cd68d8f58e99d355638b7d3f1a2f5d360e5965a40ad930d7c4f8871b9cd5d795d92a705b
+  metadata.gz: 519751841aba45aa608ef7cdc9767b798b79897d14cc4384fd9bda08472442d45177f68a2c616d75f07cd6b20bc3546dd8e814a6c446be0110bde259917522bd
+  data.tar.gz: 2f7ca81b72afd2b670a884e0b0383d77c1bb0111ae1a6f786797089e8a5fca15494f0f8e553ed1f7d7a7c969f6b06d647206e3092f386e0a003cdff79189397f

data/lib/pakyow/{routing/actions → actions/routing}/respond_missing.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Pakyow
-  module Routing
-    module Actions
+  module Actions
+    module Routing
       class RespondMissing
         def call(connection)
           connection.app.controller_for_connection(connection).trigger(404)

data/lib/pakyow/routing/controller.rb

@@ -19,754 +19,766 @@ require "pakyow/routing/controller/behavior/error_handling"
 require "pakyow/routing/controller/behavior/param_verification"
 
 module Pakyow
-  # Executes code for particular requests. For example:
-  #
-  #   Pakyow::App.controller do
-  #     get "/" do
-  #       # called for GET / requests
-  #     end
-  #   end
-  #
-  # A +Class+ is created dynamically for each defined controller. When matched, a route is called in
-  # context of its controller. This means that any method defined in a controller is available to be
-  # called from within a route. For example:
-  #
-  #   Pakyow::App.controller do
-  #     def foo
-  #     end
-  #
-  #     get :foo, "/foo" do
-  #       foo
-  #     end
-  #   end
-  #
-  # Including modules works as expected:
-  #
-  #   module AuthHelpers
-  #     def current_user
-  #     end
-  #   end
-  #
-  #   Pakyow::App.controller do
-  #     include AuthHelpers
-  #
-  #     get :foo, "/foo" do
-  #       current_user
-  #     end
-  #   end
-  #
-  # See {App.controller} for more details on defining controllers.
-  #
-  # = Supported HTTP methods
-  #
-  # - +GET+
-  # - +POST+
-  # - +PUT+
-  # - +PATCH+
-  # - +DELETE+
-  #
-  # See {get}, {post}, {put}, {patch}, and {delete}.
-  #
-  # +HEAD+ requests are handled automatically via {Rack::Head}.
-  #
-  # = Building paths for named routes
-  #
-  # Path building is supported via {Controller#path} and {Controller#path_to}.
-  #
-  # = Reusing logic with actions
-  #
-  # Methods can be defined as additional actions for a route. For example:
-  #
-  #   Pakyow::App.controller do
-  #     action :called_before
-  #
-  #     def called_before
-  #       ...
-  #     end
-  #
-  #     get :foo, "/foo" do
-  #       ...
-  #     end
-  #   end
-  #
-  # = Extending controllers
-  #
-  # Extensions can be defined and used to add shared routes to one or more controllers.
-  # See {Routing::Extension}.
-  #
-  # = Other routing features
-  #
-  # More advanced route features are available, including groups, namespaces, and templates. See
-  # {group}, {namespace}, and {template}.
-  #
-  # = Controller subclasses
-  #
-  # It's possible to work with controllers outside of Pakyow's DSL. For example:
-  #
-  #   class FooController < Pakyow::Controller("/foo")
-  #     default do
-  #       # available at GET /foo
-  #     end
-  #   end
-  #
-  #   Pakyow::App.controller << FooController
-  #
-  # = Custom matchers
-  #
-  # Controllers and routes can be defined with a matcher rather than a path. The matcher could be a
-  # +Regexp+ or any custom object that implements +match?+. For example:
-  #
-  #   class CustomMatcher
-  #     def match?(path)
-  #       path == "/custom"
-  #     end
-  #   end
-  #
-  #   Pakyow::App.controller CustomMatcher.new do
-  #   end
-  #
-  # Custom matchers can also make data available in +params+ by implementing +match+ and returning
-  # an object that implements +named_captures+. For example:
-  #
-  #   class CustomMatcher
-  #     def match?(path)
-  #       path == "/custom"
-  #     end
-  #
-  #     def match(path)
-  #       return self if match?(path)
-  #     end
-  #
-  #     def named_captures
-  #       { foo: "bar" }
-  #     end
-  #   end
-  #
-  #   Pakyow::App.controller CustomMatcher.new do
-  #   end
-  #
-  class Controller
-    using Support::DeepDup
-    extend Support::Makeable
-    extend Support::ClassState
-
-    include Support::Hookable
-    events :dispatch
-
-    include Routing::Behavior::ErrorHandling
-    include Routing::Behavior::ParamVerification
-
-    include Support::Pipeline
-
-    using Support::Refinements::String::Normalization
-
-    controller = self
-    Pakyow.singleton_class.class_eval do
-      define_method :Controller do |path|
-        controller.Controller(path)
-      end
-    end
-
-    METHOD_GET    = :get
-    METHOD_HEAD   = :head
-    METHOD_POST   = :post
-    METHOD_PUT    = :put
-    METHOD_PATCH  = :patch
-    METHOD_DELETE = :delete
-
-    DEFINABLE_HTTP_METHODS = [
-      METHOD_GET,
-      METHOD_POST,
-      METHOD_PUT,
-      METHOD_PATCH,
-      METHOD_DELETE
-    ].freeze
-
-    CONTENT_DISPOSITION = "Content-Disposition".freeze
-
-    require "pakyow/routing/expansion"
-
-    # Controllers must be initialized with an argument, even though the argument
-    # isn't actually used. This is a side-effect of allowing templates to define
-    # a route named "new". In the expansion, we differentiate between expanding
-    # and initializing by whether an argument is present, which works because
-    # arguments aren't passed for expansions.
-    #
-    def initialize(app)
-      @children = self.class.children.map { |child|
-        child.new(app)
-      }
-
-      self.class.routes.values.flatten.each do |route|
-        route.pipeline = self.class.__pipeline.dup
-
-        self.class.limit_by_route[route.name].to_a.reverse.each do |limit|
-          if index = route.pipeline.actions.index(limit[:after])
-            route.pipeline.actions.insert(index + 1, limit[:insert])
-          else
-            route.pipeline.actions << limit[:insert]
-          end
-        end
-
-        route.pipeline.actions.delete_if do |action|
-          self.class.global_skips.to_a.include?(action.name) ||
-            self.class.skips_by_route[route.name].to_a.include?(action.name)
-        end
-
-        route.pipeline.actions << Support::Pipeline::Action.new(:dispatch)
-      end
-    end
-
-    def call(connection, request_path = connection.path)
-      request_method = connection.method
-      if request_method == METHOD_HEAD
-        request_method = METHOD_GET
-      end
-
-      matcher = self.class.matcher
-      if match = matcher.match(request_path)
-        match_data = match.named_captures
-        connection.params.merge!(match_data)
-
-        if matcher.is_a?(Regexp)
-          request_path = String.normalize_path(request_path.sub(matcher, ""))
-        end
-
-        @children.each do |child_controller|
-          child_controller.call(connection, request_path)
-          break if connection.halted?
-        end
-
-        unless connection.halted?
-          self.class.routes[request_method].to_a.each do |route|
-            catch :reject do
-              if route_match = route.match(request_path)
-                connection.params.merge!(route_match.named_captures)
-
-                connection.set(
-                  :__endpoint_path,
-                  String.normalize_path(
-                    File.join(
-                      self.class.path_to_self.to_s, route.path.to_s
-                    )
-                  )
-                )
-
-                connection.set(:__endpoint_name, route.name)
-
-                dup.call_route(connection, route)
-              end
-            end
-
-            break if connection.halted?
-          end
-        end
-      end
-    end
-
-    def call_route(connection, route)
-      @connection, @route = connection, route
-      @route.pipeline.callable(self).call(connection); halt
-    rescue StandardError => error
-      @connection.logger.houston(error)
-      handle_error(error)
-    end
-
-    def dispatch
-      halted = false
-      performing :dispatch do
-        halted = catch :halt do
-          @route.call(self)
-        end
-      end
-
-      # Catching the halt then re-halting lets us call after dispatch hooks in non-error cases.
-      #
-      halt if halted
-    end
-
-    # Redirects to +location+ and immediately halts request processing.
+  module Routing
+    # Executes code for particular requests. For example:
     #
-    # @param location [String] what url the request should be redirected to
-    # @param as [Integer, Symbol] the status to redirect with
-    # @param trusted [Boolean] whether or not the location is trusted
-    #
-    # @example Redirecting:
     #   Pakyow::App.controller do
-    #     default do
-    #       redirect "/foo"
+    #     get "/" do
+    #       # called for GET / requests
     #     end
     #   end
     #
-    # @example Redirecting with a status code:
+    # A +Class+ is created dynamically for each defined controller. When matched, a route is called in
+    # context of its controller. This means that any method defined in a controller is available to be
+    # called from within a route. For example:
+    #
     #   Pakyow::App.controller do
-    #     default do
-    #       redirect "/foo", as: 301
+    #     def foo
+    #     end
+    #
+    #     get :foo, "/foo" do
+    #       foo
+    #     end
+    #   end
+    #
+    # Including modules works as expected:
+    #
+    #   module AuthHelpers
+    #     def current_user
     #     end
     #   end
     #
-    # @example Redirecting to a remote location:
     #   Pakyow::App.controller do
-    #     default do
-    #       redirect "http://foo.com/bar", trusted: true
+    #     include AuthHelpers
+    #
+    #     get :foo, "/foo" do
+    #       current_user
     #     end
     #   end
     #
-    def redirect(location, as: 302, trusted: false, **params)
-      location = case location
-      when Symbol
-        app.endpoints.path(location, **params)
-      else
-        location
-      end
-
-      if trusted || URI(location).host.nil?
-        @connection.status = Connection::Statuses.code(as)
-        @connection.set_header("location", location)
-        halt
-      else
-        raise Security::InsecureRedirect.new_with_message(
-          location: location
-        )
-      end
-    end
-
-    # Reroutes the request to a different location. Instead of an http redirect, the request will
-    # continued to be handled in the current request lifecycle.
+    # See {App.controller} for more details on defining controllers.
+    #
+    # = Supported HTTP methods
+    #
+    # - +GET+
+    # - +POST+
+    # - +PUT+
+    # - +PATCH+
+    # - +DELETE+
+    #
+    # See {get}, {post}, {put}, {patch}, and {delete}.
+    #
+    # +HEAD+ requests are handled automatically via {Rack::Head}.
+    #
+    # = Building paths for named routes
     #
-    # @param location [String] what url the request should be rerouted to
-    # @param method [Symbol] the http method to reroute as
+    # Path building is supported via {Controller#path} and {Controller#path_to}.
     #
-    # @example
-    #   Pakyow::App.resource :posts, "/posts" do
-    #     edit do
-    #       @post ||= find_post_by_id(params[:post_id])
+    # = Reusing logic with actions
     #
-    #       # render the form for @post
+    # Methods can be defined as additional actions for a route. For example:
+    #
+    #   Pakyow::App.controller do
+    #     action :called_before
+    #
+    #     def called_before
+    #       ...
     #     end
     #
-    #     update do
-    #       if post_fails_to_create
-    #         @post = failed_post_object
-    #         reroute path(:posts_edit, post_id: @post.id), method: :get
-    #       end
+    #     get :foo, "/foo" do
+    #       ...
     #     end
     #   end
     #
-    def reroute(location, method: connection.method, as: nil, **params)
-      connection = @connection.__getobj__
-
-      # Make sure the endpoint is set.
-      #
-      connection.endpoint
-
-      connection.instance_variable_set(:@method, method)
-      connection.instance_variable_set(:@path, location.is_a?(Symbol) ? app.endpoints.path(location, **params) : location)
-
-      # Change the response status, if set.
-      #
-      connection.status = Connection::Statuses.code(as) if as
-
-      @connection.set(:__endpoint_path, nil)
-      @connection.set(:__endpoint_name, nil)
-
-      app.perform(@connection); halt
-    end
-
-    # Responds to a specific request format.
+    # = Extending controllers
     #
-    # The +Content-Type+ header will be set on the response based on the format that is being
-    # responded to.
+    # Extensions can be defined and used to add shared routes to one or more controllers.
+    # See {Routing::Extension}.
     #
-    # After yielding, request processing will be halted.
+    # = Other routing features
     #
-    # @example
-    #   Pakyow::App.controller do
-    #     get "/foo.txt|html" do
-    #       respond_to :txt do
-    #         send "foo"
-    #       end
+    # More advanced route features are available, including groups, namespaces, and templates. See
+    # {group}, {namespace}, and {template}.
+    #
+    # = Controller subclasses
     #
-    #       # do something for html format
+    # It's possible to work with controllers outside of Pakyow's DSL. For example:
+    #
+    #   class FooController < Pakyow::Routing::Controller("/foo")
+    #     default do
+    #       # available at GET /foo
     #     end
     #   end
     #
-    def respond_to(format)
-      return unless @connection.format == format.to_sym
-      @connection.format = format
-      yield
-      halt
-    end
-
-    DEFAULT_SEND_TYPE = "application/octet-stream".freeze
-
-    # Sends a file or other data in the response.
+    #   Pakyow::App.controller << FooController
     #
-    # Accepts data as a +String+ or +IO+ object. When passed a +File+ object, the mime type will be
-    # determined automatically. The type can be set explicitly with the +type+ option.
+    # = Custom matchers
     #
-    # Passing +name+ sets the +Content-Disposition+ header to "attachment". Otherwise, the
-    # disposition will be set to "inline".
+    # Controllers and routes can be defined with a matcher rather than a path. The matcher could be a
+    # +Regexp+ or any custom object that implements +match?+. For example:
     #
-    # @example Sending data:
-    #   Pakyow::App.controller do
-    #     default do
-    #       send "foo", type: "text/plain"
+    #   class CustomMatcher
+    #     def match?(path)
+    #       path == "/custom"
     #     end
     #   end
     #
-    # @example Sending a file:
-    #   Pakyow::App.controller do
-    #     default do
-    #       filename = "foo.txt"
-    #       send File.open(filename), name: filename
+    #   Pakyow::App.controller CustomMatcher.new do
+    #   end
+    #
+    # Custom matchers can also make data available in +params+ by implementing +match+ and returning
+    # an object that implements +named_captures+. For example:
+    #
+    #   class CustomMatcher
+    #     def match?(path)
+    #       path == "/custom"
     #     end
+    #
+    #     def match(path)
+    #       return self if match?(path)
+    #     end
+    #
+    #     def named_captures
+    #       { foo: "bar" }
+    #     end
+    #   end
+    #
+    #   Pakyow::App.controller CustomMatcher.new do
     #   end
     #
-    def send(file_or_data, type: nil, name: nil)
-      if file_or_data.is_a?(IO) || file_or_data.is_a?(StringIO)
-        data = file_or_data
+    class Controller
+      using Support::DeepDup
+      extend Support::Makeable
+      extend Support::ClassState
 
-        if file_or_data.is_a?(File)
-          @connection.set_header(Rack::CONTENT_LENGTH, file_or_data.size)
-          type ||= Rack::Mime.mime_type(File.extname(file_or_data.path))
-        end
+      include Support::Hookable
+      events :dispatch
 
-        @connection.set_header(Rack::CONTENT_TYPE, type || DEFAULT_SEND_TYPE)
-      elsif file_or_data.is_a?(String)
-        @connection.set_header(Rack::CONTENT_LENGTH, file_or_data.bytesize)
-        @connection.set_header(Rack::CONTENT_TYPE, type) if type
-        data = StringIO.new(file_or_data)
-      else
-        raise ArgumentError, "expected an IO or String object"
-      end
+      include Routing::Behavior::ErrorHandling
+      include Routing::Behavior::ParamVerification
 
-      @connection.set_header(CONTENT_DISPOSITION, name ? "attachment; filename=#{name}" : "inline")
-      halt(data)
-    end
+      include Support::Pipeline
 
-    # Halts request processing, immediately returning the response.
-    #
-    # The response body will be set to +body+ prior to halting (if it's a non-nil value).
-    #
-    def halt(body = nil, status: nil)
-      @connection.body = body if body
-      @connection.status = Connection::Statuses.code(status) if status
-      @connection.halt
-    end
+      using Support::Refinements::String::Normalization
 
-    # Rejects the request, calling the next matching route.
-    #
-    def reject
-      throw :reject
-    end
+      controller = self
+      Pakyow::Routing.singleton_class.class_eval do
+        define_method :Controller do |path|
+          controller.Controller(path)
+        end
+      end
 
-    class_state :children, default: [], inheritable: false
-    class_state :templates, default: {}, inheritable: true
-    class_state :expansions, default: [], inheritable: false
-    class_state :routes, default: DEFINABLE_HTTP_METHODS.each_with_object({}) { |supported_method, routes_hash|
-                                    routes_hash[supported_method] = []
-                                  }, inheritable: false
+      METHOD_GET    = :get
+      METHOD_HEAD   = :head
+      METHOD_POST   = :post
+      METHOD_PUT    = :put
+      METHOD_PATCH  = :patch
+      METHOD_DELETE = :delete
+
+      DEFINABLE_HTTP_METHODS = [
+        METHOD_GET,
+        METHOD_POST,
+        METHOD_PUT,
+        METHOD_PATCH,
+        METHOD_DELETE
+      ].freeze
+
+      CONTENT_DISPOSITION = "Content-Disposition".freeze
+
+      require "pakyow/routing/expansion"
+
+      # Controllers must be initialized with an argument, even though the argument
+      # isn't actually used. This is a side-effect of allowing templates to define
+      # a route named "new". In the expansion, we differentiate between expanding
+      # and initializing by whether an argument is present, which works because
+      # arguments aren't passed for expansions.
+      #
+      def initialize(app)
+        @children = self.class.children.map { |child|
+          child.new(app)
+        }
+
+        self.class.routes.values.flatten.each do |route|
+          route.pipeline = self.class.__pipeline.dup
+
+          self.class.limit_by_route[route.name].to_a.reverse.each do |limit|
+            if index = route.pipeline.actions.index(limit[:after])
+              route.pipeline.actions.insert(index + 1, limit[:insert])
+            else
+              route.pipeline.actions << limit[:insert]
+            end
+          end
 
-    class_state :limit_by_route, default: {}, inheritable: false
-    class_state :skips_by_route, default: {}, inheritable: false
+          route.pipeline.actions.delete_if do |action|
+            self.class.global_skips.to_a.include?(action.name) ||
+              self.class.skips_by_route[route.name].to_a.include?(action.name)
+          end
 
-    # Global rules should be inherited by children, but route-specific rules
-    # shouldn't be since they refer to a specific route in the current context.
-    #
-    class_state :global_skips, default: [], inheritable: true
+          route.pipeline.actions << Support::Pipeline::Action.new(:dispatch)
+        end
+      end
 
-    class << self
-      def action(name, only: [], skip: [], &block)
-        @__pipeline.actions.delete_if do |action|
-          action.name == name
+      def call(connection, request_path = connection.path)
+        request_method = connection.method
+        if request_method == METHOD_HEAD
+          request_method = METHOD_GET
         end
 
-        if only.any?
-          only.each do |route_name|
-            (@limit_by_route[route_name] ||= []) << {
-              insert: Support::Pipeline::Action.new(name, &block),
-              after: @__pipeline.actions.last
-            }
+        matcher = self.class.matcher
+        if match = matcher.match(request_path)
+          match_data = match.named_captures
+          connection.params.merge!(match_data)
+
+          if matcher.is_a?(Regexp)
+            request_path = String.normalize_path(request_path.sub(matcher, ""))
           end
-        else
-          super(name, &block)
-        end
 
-        skip.each do |route_name|
-          (@skips_by_route[route_name] ||= []) << name
-        end
-      end
+          @children.each do |child_controller|
+            child_controller.call(connection, request_path)
+            break if connection.halted?
+          end
 
-      def skip(name, only: [])
-        if only.empty?
-          @global_skips << name
-        else
-          only.each do |route_name|
-            (@skips_by_route[route_name] ||= []) << name
+          unless connection.halted?
+            self.class.routes[request_method].to_a.each do |route|
+              catch :reject do
+                if route_match = route.match(request_path)
+                  connection.params.merge!(route_match.named_captures)
+
+                  connection.set(
+                    :__endpoint_path,
+                    String.normalize_path(
+                      File.join(
+                        self.class.path_to_self.to_s, route.path.to_s
+                      )
+                    )
+                  )
+
+                  connection.set(:__endpoint_name, route.name)
+
+                  dup.call_route(connection, route)
+                end
+              end
+
+              break if connection.halted?
+            end
           end
         end
       end
 
-      def use_pipeline(*)
-        super
-
-        @limit_by_route = {}
+      # @api private
+      def call_route(connection, route)
+        @connection, @route = connection, route
+        @route.pipeline.callable(self).call(connection); halt
+      rescue StandardError => error
+        @connection.logger.houston(error)
+        handle_error(error)
       end
 
-      # Conveniently define defaults when subclassing +Pakyow::Controller+.
-      #
-      # @example
-      #   class MyController < Pakyow::Controller("/foo")
-      #     # more routes here
-      #   end
-      #
-      # rubocop:disable Naming/MethodName
-      def Controller(matcher)
-        make(matcher)
-      end
-      # rubocop:enabled Naming/MethodName
+      # @api private
+      def dispatch
+        halted = false
+        performing :dispatch do
+          halted = catch :halt do
+            @route.call(self)
+          end
+        end
 
-      # Create a default route. Shorthand for +get "/"+.
-      #
-      # @see get
-      #
-      def default(&block)
-        get :default, "/", &block
+        # Catching the halt then re-halting lets us call after dispatch hooks in non-error cases.
+        #
+        halt if halted
       end
 
-      # @!method get
-      #   Create a route that matches +GET+ requests at +path+. For example:
-      #
-      #     Pakyow::App.controller do
-      #       get "/foo" do
-      #         # do something
-      #       end
-      #     end
+      # Redirects to +location+ and immediately halts request processing.
       #
-      #   Routes can be named, making them available for path building via {Controller#path}. For
-      #   example:
+      # @param location [String] what url the request should be redirected to
+      # @param as [Integer, Symbol] the status to redirect with
+      # @param trusted [Boolean] whether or not the location is trusted
       #
-      #     Pakyow::App.controller do
-      #       get :foo, "/foo" do
-      #         # do something
-      #       end
+      # @example Redirecting:
+      #   Pakyow::App.controller do
+      #     default do
+      #       redirect "/foo"
       #     end
+      #   end
       #
-      # @!method post
-      #   Create a route that matches +POST+ requests at +path+.
-      #
-      #   @see get
-      #
-      # @!method put
-      #   Create a route that matches +PUT+ requests at +path+.
-      #
-      #   @see get
-      #
-      # @!method patch
-      #   Create a route that matches +PATCH+ requests at +path+.
-      #
-      #   @see get
-      #
-      # @!method delete
-      #   Create a route that matches +DELETE+ requests at +path+.
+      # @example Redirecting with a status code:
+      #   Pakyow::App.controller do
+      #     default do
+      #       redirect "/foo", as: 301
+      #     end
+      #   end
       #
-      #   @see get
+      # @example Redirecting to a remote location:
+      #   Pakyow::App.controller do
+      #     default do
+      #       redirect "http://foo.com/bar", trusted: true
+      #     end
+      #   end
       #
-      DEFINABLE_HTTP_METHODS.each do |http_method|
-        define_method http_method.downcase.to_sym do |name_or_matcher = nil, matcher_or_name = nil, &block|
-          build_route(http_method, name_or_matcher, matcher_or_name, &block)
+      def redirect(location, as: 302, trusted: false, **params)
+        location = case location
+        when Symbol
+          app.endpoints.path(location, **params)
+        else
+          location
+        end
+
+        if trusted || URI(location).host.nil?
+          @connection.status = Connection::Statuses.code(as)
+          @connection.set_header("location", location)
+          halt
+        else
+          raise Security::InsecureRedirect.new_with_message(
+            location: location
+          )
         end
       end
 
-      # Creates a nested group of routes, with an optional name.
-      #
-      # Named groups make the routes available for path building. Paths to routes defined in unnamed
-      # groups are referenced by the most direct parent group that is named.
+      # Reroutes the request to a different location. Instead of an http redirect, the request will
+      # continued to be handled in the current request lifecycle.
       #
-      # @example Defining a group:
-      #   Pakyow::App.controller do
-      #
-      #     def foo
-      #       logger.info "foo"
-      #     end
+      # @param location [String] what url the request should be rerouted to
+      # @param method [Symbol] the http method to reroute as
       #
-      #     group :foo do
-      #       action :foo
-      #       action :bar
-      #
-      #       def bar
-      #         logger.info "bar"
-      #       end
+      # @example
+      #   Pakyow::App.resource :posts, "/posts" do
+      #     edit do
+      #       @post ||= find_post_by_id(params[:post_id])
       #
-      #       get :bar, "/bar" do
-      #         # "foo" and "bar" have both been logged
-      #         send "foo.bar"
-      #       end
+      #       # render the form for @post
       #     end
       #
-      #     group do
-      #       action :foo
-      #
-      #       get :baz, "/baz" do
-      #         # "foo" has been logged
-      #         send "baz"
+      #     update do
+      #       if post_fails_to_create
+      #         @post = failed_post_object
+      #         reroute path(:posts_edit, post_id: @post.id), method: :get
       #       end
       #     end
       #   end
       #
-      # @example Building a path to a route within a named group:
-      #   path :foo_bar
-      #   # => "/foo/bar"
-      #
-      # @example Building a path to a route within an unnamed group:
-      #   path :foo_baz
-      #   # => nil
-      #
-      #   path :baz
-      #   # => "/baz"
-      #
-      def group(name = nil, **kwargs, &block)
-        make_child(name, nil, **kwargs, &block)
+      def reroute(location, method: connection.method, as: nil, **params)
+        connection = @connection.__getobj__
+
+        # Make sure the endpoint is set.
+        #
+        connection.endpoint
+
+        connection.instance_variable_set(:@method, method)
+        connection.instance_variable_set(:@path, location.is_a?(Symbol) ? app.endpoints.path(location, **params) : location)
+
+        # Change the response status, if set.
+        #
+        connection.status = Connection::Statuses.code(as) if as
+
+        @connection.set(:__endpoint_path, nil)
+        @connection.set(:__endpoint_name, nil)
+
+        app.perform(@connection); halt
       end
 
-      # Creates a group of routes and mounts them at a path, with an optional name. A namespace
-      # behaves just like a group with regard to path lookup and action inheritance.
+      # Responds to a specific request format.
+      #
+      # The +Content-Type+ header will be set on the response based on the format that is being
+      # responded to.
       #
-      # @example Defining a namespace:
+      # After yielding, request processing will be halted.
+      #
+      # @example
       #   Pakyow::App.controller do
-      #     namespace :api, "/api" do
-      #       def auth
-      #         handle 401 unless authed?
+      #     get "/foo.txt|html" do
+      #       respond_to :txt do
+      #         send "foo"
       #       end
       #
-      #       namespace :project, "/projects" do
-      #         get :list, "/" do
-      #           # route is accessible via 'GET /api/projects'
-      #           send projects.to_json
-      #         end
-      #       end
+      #       # do something for html format
       #     end
       #   end
       #
-      def namespace(*args, **kwargs, &block)
-        name, matcher = parse_name_and_matcher_from_args(*args)
-        make_child(name, matcher, **kwargs, &block)
+      def respond_to(format)
+        return unless @connection.format == format.to_sym
+        @connection.format = format
+        yield
+        halt
       end
 
-      # Creates a route template with a name and block. The block is evaluated within a
-      # {Routing::Expansion} instance when / if it is later expanded at some endpoint (creating a
-      # namespace).
+      DEFAULT_SEND_TYPE = "application/octet-stream".freeze
+
+      # Sends a file or other data in the response.
       #
-      # Route templates are used to define a scaffold of default routes that will later be expanded
-      # at some path. During expansion, the scaffolded routes are also mapped to routing logic.
+      # Accepts data as a +String+ or +IO+ object. When passed a +File+ object, the mime type will be
+      # determined automatically. The type can be set explicitly with the +type+ option.
       #
-      # Because routes can be referenced by name during expansion, route templates provide a way to
-      # create a domain-specific-language, or DSL, around a routing concern. This is used within
-      # Pakyow itself to define the resource template ({Routing::Extension::Resource}).
+      # Passing +name+ sets the +Content-Disposition+ header to "attachment". Otherwise, the
+      # disposition will be set to "inline".
       #
-      # @example Defining a template:
+      # @example Sending data:
       #   Pakyow::App.controller do
-      #     template :talkback do
-      #       get :hello, "/hello"
-      #       get :goodbye, "/goodbye"
+      #     default do
+      #       send "foo", type: "text/plain"
       #     end
       #   end
       #
-      # @example Expanding a template:
-      #
+      # @example Sending a file:
       #   Pakyow::App.controller do
-      #     talkback :en, "/en" do
-      #       hello do
-      #         send "hello"
-      #       end
-      #
-      #       goodbye do
-      #         send "goodbye"
-      #       end
-      #
-      #       # we can also extend the expansion
-      #       # for our particular use-case
-      #       get "/thanks" do
-      #         send "thanks"
-      #       end
-      #     end
-      #
-      #     talkback :fr, "/fr" do
-      #       hello do
-      #         send "bonjour"
-      #       end
-      #
-      #       # `goodbye` will not be an endpoint
-      #       # since we did not expand it here
+      #     default do
+      #       filename = "foo.txt"
+      #       send File.open(filename), name: filename
       #     end
       #   end
       #
-      def template(name, &template_block)
-        templates[name] = template_block
+      def send(file_or_data, type: nil, name: nil)
+        if file_or_data.is_a?(IO) || file_or_data.is_a?(StringIO)
+          data = file_or_data
+
+          if file_or_data.is_a?(File)
+            @connection.set_header("content-length", file_or_data.size)
+            type ||= MiniMime.lookup_by_filename(file_or_data.path)&.content_type.to_s
+          end
+
+          @connection.set_header("content-type", type || DEFAULT_SEND_TYPE)
+        elsif file_or_data.is_a?(String)
+          @connection.set_header("content-length", file_or_data.bytesize)
+          @connection.set_header("content-type", type) if type
+          data = StringIO.new(file_or_data)
+        else
+          raise ArgumentError, "expected an IO or String object"
+        end
+
+        @connection.set_header(CONTENT_DISPOSITION, name ? "attachment; filename=#{name}" : "inline")
+        halt(data)
       end
 
-      # Expands a defined route template, or raises +NameError+.
+      # Halts request processing, immediately returning the response.
       #
-      # @see template
+      # The response body will be set to +body+ prior to halting (if it's a non-nil value).
       #
-      def expand(name, *args, **options, &block)
-        make_child(*args).expand_within(name, **options, &block)
+      def halt(body = nil, status: nil)
+        @connection.body = body if body
+        @connection.status = Connection::Statuses.code(status) if status
+        @connection.halt
       end
 
-      # Attempts to find and expand a template, avoiding the need to call {expand} explicitly. For
-      # example, these calls are identical:
-      #
-      #   Pakyow::App.controller do
-      #     resource :posts, "/posts" do
-      #     end
+      # Rejects the request, calling the next matching route.
       #
-      #     expand :resource, :posts, "/posts" do
-      #     end
-      #   end
+      def reject
+        throw :reject
+      end
+
+      class_state :children, default: [], inheritable: false
+      class_state :templates, default: {}, inheritable: true
+      class_state :expansions, default: [], inheritable: false
+      class_state :routes, default: DEFINABLE_HTTP_METHODS.each_with_object({}) { |supported_method, routes_hash|
+                                      routes_hash[supported_method] = []
+                                    }, inheritable: false
+
+      class_state :limit_by_route, default: {}, inheritable: false
+      class_state :skips_by_route, default: {}, inheritable: false
+
+      # Global rules should be inherited by children, but route-specific rules
+      # shouldn't be since they refer to a specific route in the current context.
       #
-      def method_missing(name, *args, &block)
-        if templates.include?(name)
-          expand(name, *args, &block)
-        else
+      class_state :global_skips, default: [], inheritable: true
+
+      class << self
+        def action(name, only: [], skip: [], &block)
+          @__pipeline.actions.delete_if do |action|
+            action.name == name
+          end
+
+          if only.any?
+            only.each do |route_name|
+              (@limit_by_route[route_name] ||= []) << {
+                insert: Support::Pipeline::Action.new(name, &block),
+                after: @__pipeline.actions.last
+              }
+            end
+          else
+            super(name, &block)
+          end
+
+          skip.each do |route_name|
+            (@skips_by_route[route_name] ||= []) << name
+          end
+        end
+
+        def skip(name, only: [])
+          if only.empty?
+            @global_skips << name
+          else
+            only.each do |route_name|
+              (@skips_by_route[route_name] ||= []) << name
+            end
+          end
+        end
+
+        def use_pipeline(*)
           super
+
+          @limit_by_route = {}
         end
-      end
 
-      def respond_to_missing?(method_name, include_private = false)
-        templates.include?(method_name) || super
-      end
+        # Conveniently define defaults when subclassing +Pakyow::Routing::Controller+.
+        #
+        # @example
+        #   class MyController < Pakyow::Routing::Controller("/foo")
+        #     # more routes here
+        #   end
+        #
+        # rubocop:disable Naming/MethodName
+        def Controller(matcher)
+          make(matcher)
+        end
+        # rubocop:enabled Naming/MethodName
 
-      # @api private
-      attr_reader :path, :matcher
+        # Create a default route. Shorthand for +get "/"+.
+        #
+        # @see get
+        #
+        def default(&block)
+          get :default, "/", &block
+        end
 
-      # @api private
-      attr_accessor :parent
+        # @!method get
+        #   Create a route that matches +GET+ requests at +path+. For example:
+        #
+        #     Pakyow::App.controller do
+        #       get "/foo" do
+        #         # do something
+        #       end
+        #     end
+        #
+        #   Routes can be named, making them available for path building via {Controller#path}. For
+        #   example:
+        #
+        #     Pakyow::App.controller do
+        #       get :foo, "/foo" do
+        #         # do something
+        #       end
+        #     end
+        #
+        # @!method post
+        #   Create a route that matches +POST+ requests at +path+.
+        #
+        #   @see get
+        #
+        # @!method put
+        #   Create a route that matches +PUT+ requests at +path+.
+        #
+        #   @see get
+        #
+        # @!method patch
+        #   Create a route that matches +PATCH+ requests at +path+.
+        #
+        #   @see get
+        #
+        # @!method delete
+        #   Create a route that matches +DELETE+ requests at +path+.
+        #
+        #   @see get
+        #
+        DEFINABLE_HTTP_METHODS.each do |http_method|
+          define_method http_method.downcase.to_sym do |name_or_matcher = nil, matcher_or_name = nil, &block|
+            build_route(http_method, name_or_matcher, matcher_or_name, &block)
+          end
+        end
 
-      def path_to_self
-        return path unless parent
-        File.join(parent.path_to_self.to_s, path.to_s)
-      end
+        # Creates a nested group of routes, with an optional name.
+        #
+        # Named groups make the routes available for path building. Paths to routes defined in unnamed
+        # groups are referenced by the most direct parent group that is named.
+        #
+        # @example Defining a group:
+        #   Pakyow::App.controller do
+        #
+        #     def foo
+        #       logger.info "foo"
+        #     end
+        #
+        #     group :foo do
+        #       action :foo
+        #       action :bar
+        #
+        #       def bar
+        #         logger.info "bar"
+        #       end
+        #
+        #       get :bar, "/bar" do
+        #         # "foo" and "bar" have both been logged
+        #         send "foo.bar"
+        #       end
+        #     end
+        #
+        #     group do
+        #       action :foo
+        #
+        #       get :baz, "/baz" do
+        #         # "foo" has been logged
+        #         send "baz"
+        #       end
+        #     end
+        #   end
+        #
+        # @example Building a path to a route within a named group:
+        #   path :foo_bar
+        #   # => "/foo/bar"
+        #
+        # @example Building a path to a route within an unnamed group:
+        #   path :foo_baz
+        #   # => nil
+        #
+        #   path :baz
+        #   # => "/baz"
+        #
+        def group(name = nil, **kwargs, &block)
+          make_child(name, nil, **kwargs, &block)
+        end
 
-      def name_of_self
-        return __object_name.name unless parent
-        [parent.name_of_self.to_s, __object_name.name.to_s].join("_").to_sym
-      end
+        # Creates a group of routes and mounts them at a path, with an optional name. A namespace
+        # behaves just like a group with regard to path lookup and action inheritance.
+        #
+        # @example Defining a namespace:
+        #   Pakyow::App.controller do
+        #     namespace :api, "/api" do
+        #       def auth
+        #         handle 401 unless authed?
+        #       end
+        #
+        #       namespace :project, "/projects" do
+        #         get :list, "/" do
+        #           # route is accessible via 'GET /api/projects'
+        #           send projects.to_json
+        #         end
+        #       end
+        #     end
+        #   end
+        #
+        def namespace(*args, **kwargs, &block)
+          name, matcher = parse_name_and_matcher_from_args(*args)
+          make_child(name, matcher, **kwargs, &block)
+        end
 
-      def endpoints
-        self_name = __object_name&.name
+        # Creates a route template with a name and block. The block is evaluated within a
+        # {Routing::Expansion} instance when / if it is later expanded at some endpoint (creating a
+        # namespace).
+        #
+        # Route templates are used to define a scaffold of default routes that will later be expanded
+        # at some path. During expansion, the scaffolded routes are also mapped to routing logic.
+        #
+        # Because routes can be referenced by name during expansion, route templates provide a way to
+        # create a domain-specific-language, or DSL, around a routing concern. This is used within
+        # Pakyow itself to define the resource template ({Routing::Extension::Resource}).
+        #
+        # @example Defining a template:
+        #   Pakyow::App.controller do
+        #     template :talkback do
+        #       get :hello, "/hello"
+        #       get :goodbye, "/goodbye"
+        #     end
+        #   end
+        #
+        # @example Expanding a template:
+        #
+        #   Pakyow::App.controller do
+        #     talkback :en, "/en" do
+        #       hello do
+        #         send "hello"
+        #       end
+        #
+        #       goodbye do
+        #         send "goodbye"
+        #       end
+        #
+        #       # we can also extend the expansion
+        #       # for our particular use-case
+        #       get "/thanks" do
+        #         send "thanks"
+        #       end
+        #     end
+        #
+        #     talkback :fr, "/fr" do
+        #       hello do
+        #         send "bonjour"
+        #       end
+        #
+        #       # `goodbye` will not be an endpoint
+        #       # since we did not expand it here
+        #     end
+        #   end
+        #
+        def template(name, &template_block)
+          templates[name] = template_block
+        end
 
-        # Ignore member and collection namespaces for endpoint building.
+        # Expands a defined route template, or raises +NameError+.
         #
-        self_name = nil if self_name == :member || self_name == :collection
+        # @see template
+        #
+        def expand(name, *args, **options, &block)
+          make_child(*args).expand_within(name, **options, &block)
+        end
+
+        # Attempts to find and expand a template, avoiding the need to call {expand} explicitly. For
+        # example, these calls are identical:
+        #
+        #   Pakyow::App.controller do
+        #     resource :posts, "/posts" do
+        #     end
+        #
+        #     expand :resource, :posts, "/posts" do
+        #     end
+        #   end
+        #
+        def method_missing(name, *args, &block)
+          if templates.include?(name)
+            expand(name, *args, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          templates.include?(method_name) || super
+        end
+
+        # @api private
+        attr_reader :path, :matcher
+
+        # @api private
+        attr_accessor :parent
+
+        def path_to_self
+          return path unless parent
+          File.join(parent.path_to_self.to_s, path.to_s)
+        end
+
+        def name_of_self
+          return __object_name.name unless parent
+          [parent.name_of_self.to_s, __object_name.name.to_s].join("_").to_sym
+        end
+
+        def endpoints
+          self_name = __object_name&.name
+
+          # Ignore member and collection namespaces for endpoint building.
+          #
+          self_name = nil if self_name == :member || self_name == :collection
+
+          [].tap do |endpoints|
+            @routes.values.flatten.each do |route|
+              if route.name == :default && self_name
+                # Register the endpoint without the default name for easier lookup.
+                #
+                endpoints << Endpoint.new(
+                  name: self_name,
+                  method: route.method,
+                  builder: Routing::Route::EndpointBuilder.new(
+                    route: route, path: path_to_self
+                  )
+                )
+              end
 
-        [].tap do |endpoints|
-          @routes.values.flatten.each do |route|
-            if route.name == :default && self_name
-              # Register the endpoint without the default name for easier lookup.
-              #
               endpoints << Endpoint.new(
-                name: self_name,
+                name: [self_name, route.name.to_s].compact.join("_"),
                 method: route.method,
                 builder: Routing::Route::EndpointBuilder.new(
                   route: route, path: path_to_self
@@ -774,97 +786,90 @@ module Pakyow
               )
             end
 
-            endpoints << Endpoint.new(
-              name: [self_name, route.name.to_s].compact.join("_"),
-              method: route.method,
-              builder: Routing::Route::EndpointBuilder.new(
-                route: route, path: path_to_self
+            children.flat_map(&:endpoints).each do |child_endpoint|
+              endpoints << Endpoint.new(
+                name: [self_name, child_endpoint.name].compact.join("_"),
+                method: child_endpoint.method,
+                builder: child_endpoint.builder
               )
-            )
-          end
-
-          children.flat_map(&:endpoints).each do |child_endpoint|
-            endpoints << Endpoint.new(
-              name: [self_name, child_endpoint.name].compact.join("_"),
-              method: child_endpoint.method,
-              builder: child_endpoint.builder
-            )
+            end
           end
         end
-      end
 
-      def make(*args, **kwargs, &block)
-        name, matcher = parse_name_and_matcher_from_args(*args)
+        # @api private
+        def make(*args, **kwargs, &block)
+          name, matcher = parse_name_and_matcher_from_args(*args)
 
-        path = path_from_matcher(matcher)
-        matcher = finalize_matcher(matcher || "/")
+          path = path_from_matcher(matcher)
+          matcher = finalize_matcher(matcher || "/")
 
-        super(name, path: path, matcher: matcher, **kwargs, &block)
-      end
+          super(name, path: path, matcher: matcher, **kwargs, &block)
+        end
 
-      # @api private
-      def make_child(*args, **kwargs, &block)
-        name, matcher = parse_name_and_matcher_from_args(*args)
+        # @api private
+        def make_child(*args, **kwargs, &block)
+          name, matcher = parse_name_and_matcher_from_args(*args)
 
-        if name && name.is_a?(Symbol) && child = children.find { |possible_child| possible_child.__object_name.name == name }
-          if block_given?
-            child.instance_exec(&block)
-          end
+          if name && name.is_a?(Symbol) && child = children.find { |possible_child| possible_child.__object_name.name == name }
+            if block_given?
+              child.instance_exec(&block)
+            end
 
-          child
-        else
-          if name && name.is_a?(Symbol) && __object_name
-            name = __object_name.isolated(name)
-          end
+            child
+          else
+            if name && name.is_a?(Symbol) && __object_name
+              name = __object_name.isolated(name)
+            end
 
-          make(name, matcher, parent: self, **kwargs, &block).tap do |controller|
-            children << controller
+            make(name, matcher, parent: self, **kwargs, &block).tap do |controller|
+              children << controller
+            end
           end
         end
-      end
 
-      # @api private
-      def expand_within(name, **options, &block)
-        raise NameError, "unknown template `#{name}'" unless template = templates[name]
-        Routing::Expansion.new(name, self, options, &template)
-        class_eval(&block)
-        self
-      end
+        # @api private
+        def expand_within(name, **options, &block)
+          raise NameError, "unknown template `#{name}'" unless template = templates[name]
+          Routing::Expansion.new(name, self, options, &template)
+          class_eval(&block)
+          self
+        end
 
-      protected
+        private
 
-      def parse_name_and_matcher_from_args(name_or_matcher = nil, matcher_or_name = nil)
-        Support::Aargv.normalize([name_or_matcher, matcher_or_name].compact, name: [Symbol, Support::ObjectName], matcher: Object).values_at(:name, :matcher)
-      end
+        def parse_name_and_matcher_from_args(name_or_matcher = nil, matcher_or_name = nil)
+          Support::Aargv.normalize([name_or_matcher, matcher_or_name].compact, name: [Symbol, Support::ObjectName], matcher: Object).values_at(:name, :matcher)
+        end
 
-      def finalize_matcher(matcher)
-        if matcher.is_a?(String)
-          converted_matcher = String.normalize_path(matcher.split("/").map { |segment|
-            if segment.include?(":")
-              "(?<#{segment[1..-1]}>(\\w|[-.~:@!$\\'\\(\\)\\*\\+,;])+)"
-            else
-              segment
-            end
-          }.join("/"))
+        def finalize_matcher(matcher)
+          if matcher.is_a?(String)
+            converted_matcher = String.normalize_path(matcher.split("/").map { |segment|
+              if segment.include?(":")
+                "(?<#{segment[1..-1]}>(\\w|[-.~:@!$\\'\\(\\)\\*\\+,;])+)"
+              else
+                segment
+              end
+            }.join("/"))
 
-          Regexp.new("^#{String.normalize_path(converted_matcher)}")
-        else
-          matcher
+            Regexp.new("^#{String.normalize_path(converted_matcher)}")
+          else
+            matcher
+          end
         end
-      end
 
-      def path_from_matcher(matcher)
-        if matcher.is_a?(String)
-          matcher
-        else
-          nil
+        def path_from_matcher(matcher)
+          if matcher.is_a?(String)
+            matcher
+          else
+            nil
+          end
         end
-      end
 
-      def build_route(method, *args, &block)
-        name, matcher = parse_name_and_matcher_from_args(*args)
-        Routing::Route.new(matcher, name: name, method: method, &block).tap do |route|
-          routes[method] << route
+        def build_route(method, *args, &block)
+          name, matcher = parse_name_and_matcher_from_args(*args)
+          Routing::Route.new(matcher, name: name, method: method, &block).tap do |route|
+            routes[method] << route
+          end
         end
       end
     end