tynn 2.0.0.alpha → 2.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3428a8bf437b03bf9e9dc2d2568143010f5a8be7
-  data.tar.gz: 9a36c6091a73ced16b4b5a5e9f8cec60fa6fd39e
+  metadata.gz: 2017e12fdca96b52fb5c2f954307b33e208c2ecb
+  data.tar.gz: 02cc565109da5f90593c370f818f213969c63c86
 SHA512:
-  metadata.gz: 25196be28e4b69d4d0ea609bcdfa7fa08276716c6e94753347ac17c8dfad6d6c9f9b390559b79ca9c9f67fbec78dec2379a481c21497460768502649bc95c63e
-  data.tar.gz: a5bdf9e80a0d95d9d172264a00612dc0c86666a1c25c761598363e100279f6c32d09d20235d3d1a0216a0ed29f2890a80da263e431c9e30f125aaa3081a418fc
+  metadata.gz: afcf9ebeb3457d3a7a9bd06878aa98cd9c88f8bf47dc1ecfeea008e4ad7571f3a9d1b0abff93b8ea68073edce4d2e0d59de72ce479c89e2fff458b4d5d954cfd
+  data.tar.gz: 4da2694ca6ec7484471c7c3ae51ca4406be40e0663ba6dce147adc2cc38d5d0abef0b88a214bc81cc8efe7334b2adcde456f6fe5e93ff66bbdc4921c094b8338

data/README.md

@@ -3,7 +3,6 @@
 [![Build Status](https://travis-ci.org/frodsan/tynn.svg?branch=master)](https://travis-ci.org/frodsan/tynn)
 [![Dependency Status](https://gemnasium.com/badges/github.com/frodsan/tynn.svg)](https://gemnasium.com/github.com/frodsan/tynn)
 [![Code Climate](https://codeclimate.com/github/frodsan/tynn/badges/gpa.svg)](https://codeclimate.com/github/frodsan/tynn)
-[![Join the chat at https://gitter.im/frodsan/tynn](https://badges.gitter.im/frodsan/tynn.svg)](https://gitter.im/frodsan/tynn?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 A thin library for web development in Ruby.
 
@@ -14,9 +13,20 @@ A thin library for web development in Ruby.
   * [Under the Hood](#under-the-hood)
   * [Tynn on Rack](#tynn-on-rack)
 * [Routing Basics](#routing-basics)
+  * [HTTP Verbs](#http-verbs)
+  * [Matching path segments](#matching-path-segments)
+  * [Capturing path segments](#capturing-path-segments)
+  * [Matching more than paths](#matching-more-than-paths)
+  * [Routing rules](#routing-rules)
+  * [Composing Applications](#composing-applications)
 * [Managing Request and Response](#managing-request-and-response)
+  * [Accessing Request Parameters](#accessing-request-parameters)
+  * [Setting a Status Code](#setting-a-status-code)
+  * [Writting to the Response Body](#writting-to-the-response-body)
+  * [Setting HTTP Headers](#setting-http-headers)
   * [Redirecting a Request](#redirecting-a-request)
   * [Halting a Request](#halting-a-request)
+  * [Cookies](#cookies)
 * [Extending Tynn](#extending-tynn)
   * [Middleware](#middleware)
   * [Plugins](#plugins)
@@ -24,8 +34,13 @@ A thin library for web development in Ruby.
 * [Default Plugins](#default-plugins)
   * [Environments](#environments)
   * [Method Override](#method-override)
+  * [JSON](#json)
+  * [Rendering Templates](#rendering-templates)
   * [Static Files](#static-files)
+  * [Sessions](#sessions)
 * [Security](#security)
+  * [Secure Headers](#secure-headers)
+  * [HTTPS](#https)
 * [Testing](#testing)
 * [API Reference](http://api.tynn.xyz/2.0.0)
 * [Changelog](#changelog)
@@ -46,7 +61,7 @@ Tynn is not a framework. There is no built-in support for connecting to database
 
 Like most web libraries in Ruby, Tynn is built on top of [Rack], a Ruby webserver interface. Because of this, it has the benefits of using existing libraries and a variety of web servers for free.
 
-Tynn takes design cues from other web libraries like [Rails], [Sinatra], and [Cuba]. Under the hood, it uses [Syro], a fast router for web applications.
+Tynn takes design cues from other web libraries like [Rails], [Sinatra], and [Cuba].
 
 ### Assumptions
 
@@ -91,7 +106,7 @@ require "tynn"
 
 Tynn.define do
   on root? do
-    get do
+    on get do
       res.write("Hello World!")
     end
   end
@@ -133,7 +148,7 @@ That's a little taste of what we call routing matchers in Tynn. The purpose of t
 One line below there is another type of matcher:
 
 ```ruby
-get do
+on get do
   res.write("Hello World!")
 end
 ```
@@ -142,7 +157,7 @@ Tynn also includes methods for matching all the HTTP verbs (GET, POST, etc.). By
 
 ```ruby
 Tynn.define do
-  get do
+  on get do
     res.write("Hello World!")
   end
 end
@@ -175,10 +190,72 @@ Most popular web servers, like [Puma], [Unicorn] or [Thin], have built-in suppor
 
 This section covers the routing features of Tynn, such as route definitions, composing applications, and so on.
 
+### HTTP Verbs
+
+TODO.
+
+### Matching path segments
+
+TODO.
+
+### Capturing path segments
+
+TODO.
+
+### Matching more than paths
+
+TODO.
+
+### Routing rules
+
+TODO.
+
+### Composing Applications
+
+TODO.
+
 ## Managing Request and Response
 
 This section covers the many features Tynn provides to handle requests and responses.
 
+### Accessing Request Parameters
+
+TODO.
+
+### Setting a Status Code
+
+TODO.
+
+### Writting to the Response Body
+
+TODO.
+
+### Setting HTTP Headers
+
+To set HTTP headers in the response, use the `res.headers` hash.
+
+```ruby
+Tynn.define do
+  on get do
+    res.headers["Content-Type"] = "application/json"
+
+    res.write(JSON.generate(status: "ok"))
+  end
+end
+```
+
+Default headers for the application can be set through the `:default_headers` setting.
+
+```ruby
+Tynn.set(:default_headers, "Content-Type" => "application/json")
+
+Tynn.define do
+  on get do
+    res.write(JSON.generate(status: "ok"))
+  end
+end
+```
+
 ### Redirecting a Request
 
 To redirect a request to a different location, use `res.redirect`.
@@ -219,8 +296,14 @@ end
 # This won't be reached if current_user is nil
 ```
 
+### Cookies
+
+TODO.
+
 ## Extending Tynn
 
+TODO.
+
 ### Middleware
 
 Tynn runs on [Rack](https://github.com/rack/rack). Therefore it is possible
@@ -286,7 +369,7 @@ Here is the plugin in action:
 App.currency # => "$"
 
 App.define do
-  get do
+  on get do
     res.write(to_currency(4567))
   end
 end
@@ -330,17 +413,7 @@ end
 
 ## Default Plugins
 
-Tynn ships with a set of default plugins:
-
-| Name                  | Description
-| --------------------- | -----------------------------------------------------------------
-| [Tynn::Environment]   | Adds helper methods to get and check the current environment.
-| [Tynn::JSON]          | Adds helper methods for json generation.
-| [Tynn::Render]        | Adds support for rendering templates through different engines.
-| [Tynn::Session]       | Adds simple cookie based session management.
-| [Tynn::Static]        | Adds support for static files (javascript files, images, etc.).
-
-The following sections cover the default plugins and extensions shipped with Tynn.
+Tynn ships with a set of default plugins. The following sections cover the default plugins and extensions shipped with Tynn.
 
 ### Environments
 
@@ -398,6 +471,33 @@ Tynn.configure(:production) do |app|
 end
 ```
 
+### JSON
+
+Tynn ships with [Tynn::JSON] to serve JSON resources. It adds a helper method, called `json`, that generates a JSON document and writes it to the response body. This also automatically sets the content type header to `application/json`.
+
+```ruby
+require "tynn"
+require "tynn/json"
+
+Tynn.define do
+  on "array" do
+    on get do
+      json(["foo", "bar", "baz"])
+    end
+  end
+
+  on "object" do
+    on get do
+      json(foo: "bar")
+    end
+  end
+end
+```
+
+### Rendering Templates
+
+TODO.
+
 ### Method Override
 
 HTML Forms only support GET and POST requests. To perform other actions such as PUT, PATCH or DELETE, use the [Rack::MethodOverride] middleware. Note that there is no need to add any new dependencies to the application as it's included in Rack already.
@@ -420,7 +520,7 @@ Now, this will trigger the `put` matcher in the application.
 
 ```ruby
 Posts.define do
-  put do
+  on put do
     post.update(req.params["post"])
   end
 end
@@ -462,8 +562,45 @@ Tynn.plugin(
 )
 ```
 
+### Sessions
+
+TODO.
+
 ## Security
 
+Many of the default plugins include secure default options. Here are some plugins that can improve the security of your web application.
+
+### Secure Headers
+
+Tynn ships with the [Tynn::SecureHeaders] plugin.
+
+```ruby
+require "tynn"
+require "tynn/secure_headers"
+
+Tynn.plugin(Tynn::SecureHeaders)
+```
+
+This plugins adds the following security related HTTP headers to each response.
+
+- **X-Content-Type-Options:** Prevents IE and Chrome from [Content Type Sniffing][sniffing]. Defaults to `"nosniff"`.
+
+- **X-Frame-Options:** Provides [Clickjacking] protection. Defaults to `"deny"`.
+
+- **X-XSS-Protection:** Enables the XSS protection filter built into IE, Chrome and Safari. This filter is usually enabled by default, the use of this header is to re-enable it if it was turned off by the user. Defaults to `"1; mode=block"</tt`.
+
+You can configure the default headers through the `:default_headers` setting.
+
+```ruby
+Tynn.set(:default_headers, {
+  "X-Frame-Options" => "sameorigin"
+})
+```
+
+### HTTTPS
+
+TODO.
+
 ## Testing
 
 Tynn ships with [Tynn::Test], a simple helper class to simulate requests to your application.
@@ -473,16 +610,16 @@ require "tynn"
 require "tynn/test"
 
 Tynn.define do
-  root do
+  on get do
     res.write("hei")
   end
 end
 
-app = Tynn::Test.new
-app.get("/")
+ts = Tynn::Test.new
+ts.get("/")
 
-200   == app.res.status # => true
-"hei" == app.res.body   # => true
+200   == ts.res.status    # => true
+"hei" == ts.res.body.join # => true
 ```
 
 [Tynn::Test] is test-framework agnostic. The following example uses [Minitest]:
@@ -493,15 +630,15 @@ require "tynn/test"
 
 class GuestsRouteTest < Minitest::Test
   def setup
-    @app = Tynn::Test.new
+    @ts = Tynn::Test.new
   end
 
   def test_home
-    @app.get("/")
+    @ts.get("/")
 
-    assert_equal 200, @app.res.status
-    assert_equal "Hello World!", @app.res.body
-    assert_equal "text/html", @app.res["Content-Type"]
+    assert_equal 200, @ts.res.status
+    assert_equal "Hello World!", @ts.res.body.join
+    assert_equal "text/html", @ts.res.headers["Content-Type"]
   end
 end
 ```
@@ -546,6 +683,7 @@ Tynn is released under the [MIT License](http://www.opensource.org/licenses/MIT)
 
 [bundler]: http://bundler.io/
 [capybara]: https://github.com/jnicklas/capybara
+[clickjacking]: https://www.owasp.org/index.php/Clickjacking
 [cuba]: http://cuba.is/
 [minitest]: https://github.com/seattlerb/minitest
 [puma]: http://puma.io/
@@ -554,11 +692,12 @@ Tynn is released under the [MIT License](http://www.opensource.org/licenses/MIT)
 [rack::methodoverride]: http://www.rubydoc.info/github/rack/rack/Rack/MethodOverride
 [rails]: http://rubyonrails.org/
 [sinatra]: http://www.sinatrarb.com/
-[syro]: http://soveran.github.io/syro/
+[sniffing]: https://msdn.microsoft.com/library/gg622941(v=vs.85).aspx
 [thin]: http://code.macournoyer.com/thin/
 [tynn::environment]: http://api.tynn.xyz/2.0.0/Tynn/Environment.html
 [tynn::json]: http://api.tynn.xyz/2.0.0/Tynn/JSON.html
 [tynn::render]: http://api.tynn.xyz/2.0.0/Tynn/Render.html
+[tynn::secureheaders]: http://api.tynn.xyz/2.0.0/Tynn/SecureHeaders.html
 [tynn::session]: http://api.tynn.xyz/2.0.0/Tynn/Session.html
 [tynn::static]: http://api.tynn.xyz/2.0.0/Tynn/Static.html
 [tynn::test]: http://api.tynn.xyz/2.0.0/Tynn/Test.html

data/lib/tynn.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "tynn/base"
-require_relative "tynn/default_headers"
-require_relative "tynn/settings"
 require_relative "tynn/version"
 
 class Tynn
@@ -69,6 +67,4 @@ class Tynn
   end
 
   plugin(Tynn::Base)
-  plugin(Tynn::Settings)
-  plugin(Tynn::DefaultHeaders)
 end

data/lib/tynn/base.rb

@@ -1,8 +1,32 @@
 # frozen_string_literal: true
 
-require "syro"
+# Copyright (c) 2016      Francesco Rodriguez
+# Copyright (c) 2015-2016 Michel Martens (Portions of https://github.com/soveran/syro)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require "rack"
+require "seg"
+require_relative "errors"
 require_relative "request"
 require_relative "response"
+require_relative "utils"
 
 class Tynn
   module Base
@@ -13,19 +37,19 @@ class Tynn
       #   end
       #
       #   Users.define do
-      #     on(:id) do |id|
-      #       get do
+      #     on :id do |id|
+      #       on get do
       #         res.write("GET /users/#{ id }")
       #       end
       #
-      #       post do
+      #       on post do
       #         res.write("POST /users/#{ id }")
       #       end
       #     end
       #   end
       #
       def define(&block)
-        @__app = build_app(Syro.new(self, &block))
+        @__app = build_app(proc { |env| new(block).call(env) })
       end
 
       def build_app(app) # :nodoc:
@@ -44,8 +68,27 @@ class Tynn
       #   Tynn.use(Rack::CommonLogger)
       #   Tynn.use(Rack::ShowExceptions)
       #
+      # If applications handler is already set, it raises an error.
+      #
+      #   Tynn.define {}
+      #
+      #   Tynn.use(Rack::CommonLogger)
+      #   # => Application middleware is frozen.
+      #
       def use(middleware, *args, &block)
-        self.middleware.push(proc { |app| middleware.new(app, *args, &block) })
+        if self.middleware.frozen?
+          raise Tynn::Error, <<~MSG
+            Application middleware is frozen and cannot be changed.
+
+            Please, set the middleware before setting the application handler:
+
+            #{ self }.use(#{ middleware })
+
+            #{ self }.define { ... }
+          MSG
+        else
+          self.middleware.push(proc { |app| middleware.new(app, *args, &block) })
+        end
       end
 
       def middleware # :nodoc:
@@ -58,39 +101,340 @@ class Tynn
 
       def app # :nodoc:
         (defined?(@__app) && @__app) or
-          raise("Application handler is missing. Try #{ self }.define {}")
+          raise(Tynn::Error, "Application handler is missing. Try #{ self }.define {}")
+      end
+
+      # Copies settings into the subclass. If a setting is not found,
+      # checks parent's settings.
+      def inherited(subclass) # :nodoc:
+        subclass.settings.replace(Tynn::Utils.deepclone_hash(settings))
+        subclass.settings.default_proc = proc { |h, k| h[k] = settings[k] }
+      end
+
+      # Returns a Hash with the application settings.
+      #
+      #   Tynn.set(:environment, :development)
+      #
+      #   Tynn.settings
+      #   # => { :environment => :development }
+      #
+      def settings
+        @settings ||= {}
+      end
+
+      # Sets an <tt>option</tt> to the given </tt>value</tt>. If a setting
+      # with the <tt>option</tt> key exists and is a hash value, it merges
+      # the stored hash with <tt>value</tt>.
+      #
+      #   Tynn.set(:environment, :staging)
+      #
+      #   Tynn.settings[:environment]
+      #   # => :staging
+      #
+      #   Tynn.default_headers
+      #   # => { "Content-Type" => "text/html" }
+      #
+      #   Tynn.set(:default_headers, "X-Frame-Options" => "DENY")
+      #
+      #   Tynn.default_headers
+      #   # => { "Content-Type" => "text/html", "X-Frame-Options" => "DENY" }
+      #
+      def set(option, value)
+        v = settings[option]
+
+        if Hash === v
+          set!(option, v.merge(value))
+        else
+          set!(option, value)
+        end
+      end
+
+      # Sets an <tt>option</tt> to the given </tt>value</tt>.
+      #
+      #   Tynn.set!(:environment, :staging)
+      #
+      #   Tynn.settings[:environment]
+      #   # => :staging
+      #
+      #   Tynn.default_headers
+      #   # => { "Content-Type" => "text/html" }
+      #
+      #   Tynn.set!(:default_headers, "X-Frame-Options" => "DENY")
+      #
+      #   Tynn.default_headers
+      #   # => { "X-Frame-Options" => "DENY" }
+      #
+      def set!(option, value)
+        settings[option] = value
+      end
+
+      # Returns a Hash with the default headers.
+      #
+      #   Tynn.set(:default_headers, {
+      #     "Content-Type" => "application/json"
+      #   })
+      #
+      #   Tynn.default_headers["Content-Type"]
+      #   # => "application/json"
+      #
+      def default_headers
+        settings.fetch(:default_headers, {})
       end
     end
 
-    module InstanceMethods # :nodoc:
-      include Syro::Deck::API
+    # Monkey-patches capture to return the path segment instead of storing it
+    # in a hash.
+    class Seg < ::Seg # :nodoc:
+      def capture
+        return nil if root?
+
+        len = (@path.index(SLASH, @pos) || @size) - @pos
+
+        segment = @path[@pos, len]
+
+        move(len)
+
+        segment
+      end
+    end
+
+    module InstanceMethods
+      def initialize(code) # :nodoc:
+        @__code = code
+      end
+
+      def call(env) # :nodoc:
+        @__env = env
+        @__req = Tynn::Request.new(env)
+        @__res = Tynn::Response.new(Hash[self.class.default_headers])
+        @__seg = Tynn::Base::Seg.new(env["PATH_INFO"])
+
+        catch(:halt) do
+          instance_eval(&@__code)
+
+          @__res.finish
+        end
+      end
 
-      # Overrides Syro::Deck::API#on to support passing the receiver to
-      # the capturing matchers.
+      # Returns the incoming request object. This object is an instance of
+      # Tynn::Request.
       #
-      #   on :name do |name|
+      #   req.post?
+      #   # => true
+      #
+      #   req.params
+      #   # => { "username" => "bob", "password" => "secret" }
+      #
+      #   req.headers["Content-Type"]
+      #   # => "application/x-www-form-urlencoded"
+      #
+      def req
+        @__req
+      end
+
+      # Returns the current response object. This object is an instance of
+      # Tynn::Response.
+      #
+      #     res.status = 200
+      #     res.headers["Content-Type"] = "text/html"
+      #     res.write("<h1>Welcome back!</h1>")
+      #
+      def res
+        @__res
+      end
+
+      # Executes a given block if <tt>arg</tt> matches one of these conditions.
+      #
+      # If <tt>arg</tt> is a string, it matches a path segment.
+      #
+      #   Tynn.define do
+      #     # Matches if /foo
+      #     on "foo" do
+      #       # Matches if /foo/bar/baz
+      #       on "bar/baz" do
+      #         res.write("/foo/bar/baz")
+      #       end
+      #     end
       #   end
       #
-      #   # instead of
+      # If <tt>arg</tt> is a symbol, it matches and capture a path segment.
       #
-      #   on :name do
-      #     name = inbox[:name]
+      #   Tynn.define do
+      #     # Matches if /users
+      #     on "users" do
+      #       # Captures id if matches /users/id
+      #       on :id do |id|
+      #         res.write("/users/#{ id }")
+      #       end
+      #     end
+      #   end
+      #
+      # Finally, if <tt>arg</tt> is <tt>true</tt>, it executes the given block
+      # inconditionally.
+      #
+      #   Tynn.define do
+      #     on current_user.nil? do
+      #       res.status = 401
+      #       res.write("Unauthorized")
+      #     end
       #   end
       #
       def on(arg)
-        default { yield((arg.is_a?(Symbol) ? inbox[arg] : nil)) } if match(arg)
+        (v = match(arg)) && yield(v)
+      end
+
+      def match(arg)
+        case arg
+        when String then @__seg.consume(arg)
+        when Symbol then @__seg.capture
+        when true   then true
+        else false
+        end
+      end
+
+      private :match
+
+      # Immediately stops the request and returns <tt>response</tt>
+      # as per Rack's specification.
+      #
+      #     halt([200, { "Content-Type" => "text/html" }, ["hello"]])
+      #     halt(res.finish)
+      #
+      def halt(response)
+        throw(:halt, response)
+      end
+
+      # Runs a Tynn <tt>app</tt> and pass an optional hash of values to it.
+      #
+      #   Tynn.define do
+      #     on "admin" do
+      #       run(Admin, subdomain: subdomain)
+      #     end
+      #   end
+      #
+      def run(app, inbox = nil)
+        path, script = @__env["PATH_INFO"], @__env["SCRIPT_NAME"]
+
+        @__env["PATH_INFO"] = @__seg.curr
+        @__env["SCRIPT_NAME"] = @__seg.prev
+        @__env["tynn.inbox"] = inbox
+
+        halt(app.call(@__env))
+      ensure
+        @__env["PATH_INFO"], @__env["SCRIPT_NAME"] = path, script
+      end
+
+      # Returns a hash with variables passed to the application.
+      #
+      #   Tynn.define do
+      #     on "api/v1" do
+      #       run(API, version: 1)
+      #     end
+      #
+      #     on "api/v2" do
+      #       run(API, version: 2)
+      #     end
+      #   end
+      #
+      #   API.define do
+      #     version = inbox[:version]
+      #   end
+      #
+      def inbox
+        @__env["tynn.inbox"] || {}
+      end
+
+      # Returns <tt>true</tt> if the request method is <tt>GET</tt> and
+      # the path yet to be consumed is empty. Otherwise, returns <tt>false</tt>.
+      #
+      #   Tynn.define do
+      #     on "users" do
+      #       on get do
+      #         res.write("GET /users")
+      #       end
+      #     end
+      #   end
+      #
+      def get
+        root? && req.get?
       end
 
-      # Overrides request class used by Syro's router.
-      # See Tynn::Request for more information.
-      def request_class
-        Tynn::Request
+      # Returns <tt>true</tt> if the request method is <tt>POST</tt> and
+      # the path yet to be consumed is empty. Otherwise, returns <tt>false</tt>.
+      #
+      #   Tynn.define do
+      #     on "users" do
+      #       post do
+      #         res.write("POST /users")
+      #       end
+      #     end
+      #   end
+      #
+      def post
+        root? && req.post?
       end
 
-      # Overrides response class used by Syro's router.
-      # See Tynn::Response for more information.
-      def response_class
-        Tynn::Response
+      # Returns <tt>true</tt> if the request method is <tt>PATCH</tt> and
+      # the path yet to be consumed is empty. Otherwise, returns <tt>false</tt>.
+      #
+      #   Tynn.define do
+      #     on "users" do
+      #       on :id do |id|
+      #         on patch do
+      #           res.write("PATCH /users/#{ id }")
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      def patch
+        root? && req.patch?
+      end
+
+      # Returns <tt>true</tt> if the request method is <tt>PUT</tt> and
+      # the path yet to be consumed is empty. Otherwise, returns <tt>false</tt>.
+      #
+      #   Tynn.define do
+      #     on "users" do
+      #       on :id do |id|
+      #         on put do
+      #           res.write("PUT /users/#{ id }")
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      def put
+        root? && req.put?
+      end
+
+      # Returns <tt>true</tt> if the request method is <tt>DELETE</tt> and
+      # the path yet to be consumed is empty. Otherwise, returns <tt>false</tt>.
+      #
+      #   Tynn.define do
+      #     on "users" do
+      #       on :id do |id|
+      #         on delete do
+      #           res.write("DELETE /users/#{ id }")
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      def delete
+        root? && req.delete?
+      end
+
+      # Returns <tt>true</tt> if the path yet to be consumed is empty.
+      #
+      #   Tynn.define do
+      #     on root? do
+      #       res.write("/")
+      #     end
+      #   end
+      #
+      def root?
+        @__seg.root?
       end
     end
   end