rutter 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7e0af90882ec8c36cf23e278e384a38e38aa3959
-  data.tar.gz: '0387e7a032da114cb32b1635330dd878f207e960'
+SHA256:
+  metadata.gz: 68f5fb5ae85793cb16d135928e3a26cf043a3eda09338f8c2a03117a16985b2d
+  data.tar.gz: c9766d83b10a8b6f103f26cc100ca753ecace464770fb739eccd4ecb2f2a876e
 SHA512:
-  metadata.gz: 236b39818113ff5910c9be230bbb7ec42478c30b891a56ecbfe2083756b5c16299f44b9e603ab0c5d6cbae33643699d988a03f66668c44a2cd9cd401309154c9
-  data.tar.gz: 8ffd27decede4f74d81a374296376692b47918946f9aab638f8369a1d539c088c803a9d3ad5551f6e942ffa0a94344147d251482c78f975b164760745d41e9e7
+  metadata.gz: 1b0bcaae9355facffd058bf84021a4d62d1365312c254fd4e2ead08b6d907c68791572f47dc3451d35fcda32fb777ff3c94c5785b270cc290187aef3ce3e3260
+  data.tar.gz: 10e3b47288658c8dd7068447339fa54981684e225542c4c05ac7440dc2fa3f2112c8461ac849b855e16c740e4357d0f7e673a49eabac946a762c21b028882d3a

data/.gitignore

@@ -5,6 +5,8 @@
 /coverage/
 /pkg/
 /spec/reports/
+/spec/examples.txt
 /tmp/
 .DS_Store
 /doc
+.byebug_history

data/.rubocop.yml

@@ -1,14 +1,21 @@
+require:
+  - rubocop-performance
+
 AllCops:
-  TargetRubyVersion: 2.4
+  TargetRubyVersion: 2.5
   DisplayCopNames: true
   Exclude:
-    - bench/*
+    - "*.gemspec"
+    - "Gemfile"
+
+Performance:
+  Enabled: true
 
 Style/StringLiterals:
   EnforcedStyle: double_quotes
 
-Lint/EndAlignment:
-  EnforcedStyleAlignWith: variable
+Layout/EmptyLineAfterGuardClause:
+  Enabled: false
 
 Metrics/MethodLength:
   Max: 15
@@ -23,3 +30,6 @@ Metrics/ModuleLength:
 
 ClassAndModuleChildren:
   Enabled: false
+
+Naming/UncommunicativeMethodParamName:
+  MinNameLength: 2

data/.travis.yml

@@ -1,19 +1,29 @@
 language: ruby
 script: "bundle exec rake spec:coverage"
 cache: bundler
+env:
+  global:
+    - CC_TEST_REPORTER_ID=c1b17cd36cd4d025298f11b2a3ee678e4977c3969986f9ee497d6984a2c82c56
 before_install:
   - "gem update --system"
+before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
 after_script:
-  - "CODECLIMATE_REPO_TOKEN=05a406e21e530e8210057604aa78eccebb988a8201c6b1e78187dff978bdee07 bundle exec codeclimate-test-reporter"
+  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT
 rvm:
+  - 2.6.0
   - 2.5.0
-  - 2.4.0
+  - jruby-9.2.0.0
   - ruby-head
   - jruby-head
+  - truffleruby
 matrix:
   allow_failures:
     - rvm: jruby-head
     - rvm: ruby-head
+    - rvm: truffleruby
 branches:
   only:
     - master

data/Gemfile

@@ -3,5 +3,8 @@
 source "https://rubygems.org"
 gemspec
 
-gem "codeclimate-test-reporter"
+unless ENV["CI"]
+  gem "byebug", platform: :mri
+end
+
 gem "simplecov"

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018 Tobias Sandelius
+Copyright (c) 2019 Tobias Sandelius
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -4,8 +4,11 @@ HTTP router for Rack.
 
 ## Status
 
+Under development, not ready for prime-time just yet.
+
 [![Build Status](https://travis-ci.org/sandelius/rutter.svg?branch=master)](https://travis-ci.org/sandelius/rutter)
 [![Test Coverage](https://codeclimate.com/github/sandelius/rutter/badges/coverage.svg)](https://codeclimate.com/github/sandelius/rutter/coverage)
+[![Inline docs](http://inch-ci.org/github/sandelius/rutter.svg?branch=master)](http://inch-ci.org/github/sandelius/rutter)
 
 ## Installation
 
@@ -15,126 +18,38 @@ Add this line to your application's Gemfile:
 gem "rutter"
 ```
 
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install rutter
-
 ## Usage
 
-Basic usage
+The main purpose of a router is to map URL's to endpoints. An endpoint needs to
+be either an object that responds to `call(env)` or a string that can be resolved
+to one.
 
-```ruby
-require "rutter"
-
-router = Rutter.new do
-  get "/", to: ->(env) { [200, {}, ["Hello World"]] }
-end
-
-run router.freeze
-```
-
-### HTTP verbs
-
-The router supports most of the verbs available.
+Below are examples of both endpoint styles:
 
 ```ruby
-require "rutter"
-
 Rutter.new do
-  get "/", to: ->(env) {}
-  post "/", to: ->(env) {}
-  put "/", to: ->(env) {}
-  patch "/", to: ->(env) {}
-  delete "/", to: ->(env) {}
-  options "/", to: ->(env) {}
-  head "/", to: ->(env) {}
-  trace "/", to: ->(env) {}
-end
+  # Endpoint that implements #call
+  get "/books", to: ->(env) { [200, {}, ["My Bookshelf"]] }
+end.freeze
 ```
 
-### Named parameters
-
-In the example `:title` is a *named parameter*. The values are accessible via `env["rutter.params"]` and it contains a `Hash<String => String>`.
-
 ```ruby
-require "rutter"
-
-Rutter.new do
-  get "/books/:title", to: ->(env) {}
+class Books
+  def self.call(env)
+    [200, {}, ["My Bookshelf"]]
+  end
 end
-```
-
-Named parameters only match a single path segment:
-
-```
-/books/eloquent-ruby          match
-/books/confident-ruby         match
-/books/confident-ruby.rb      no match
-/books/eloquent-ruby/reviews  no match
-/books/                       no match
-```
-
-### Catch-All parameters
-
-*catch-all* parameters have the form `*title`. Like the name suggests, they match everything, event new `/` segments. Therefore they must always be at the end of the pattern.
-
-```ruby
-require "rutter"
 
 Rutter.new do
-  get "/books/*title", to: ->(env) {}
-end
-```
-
-```
-/books/eloquent-ruby          match
-/books/confident-ruby         match
-/books/confident-ruby.rb      match
-/books/eloquent-ruby/reviews  match
-/books/                       no match
-```
-
-### Optional segments
-
-Support for optional segments have the form `(i-am-optional)`.
-
-```ruby
-require "rutter"
-
-Rutter.new do
-  get "/books(/:title)", to: ->(env) {}
-end
-```
-
-```
-/books/eloquent-ruby          match
-/books/confident-ruby         match
-/books/confident-ruby.rb      no match
-/books/eloquent-ruby/reviews  no match
-/books                        match
-```
-
-### Redirects
-
-Make legacy paths point to a new destination.
-
-```ruby
-require "rutter"
-
-Rutter.new do
-  get "/legacy-path", to: redirect("/new_path")
-end
+  # String that resolves to endpoint
+  get "/books", to: "books" # This will be resolved to <Books>
+end.freeze
 ```
 
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/sandelius/rutter. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,4 +1,3 @@
-
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
@@ -14,3 +13,10 @@ namespace :spec do
 end
 
 task default: :spec
+
+task :clean do
+  FileUtils.rm_r ".yardoc" if Dir.exist?(".yardoc")
+  FileUtils.rm_r "doc" if Dir.exist?("doc")
+  FileUtils.rm_r "pkg" if Dir.exist?("pkg")
+  FileUtils.rm_r "coverage" if Dir.exist?("coverage")
+end

data/bench/config.ru

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
-# $ puma -e production -t 16:16
-# $ wrk -t 2 http://localhost:9292/
+# puma -e production -t 16:16
 
-require "rack"
-require_relative "../lib/rutter"
+require "bundler/setup"
+require "rutter"
 
 router = Rutter.new do
-  root to: lambda { |env|
-    [200, { "Content-Type" => "text/html" }, ["Hello World"]]
-  }
-end
+  # wrk -t 2 http://localhost:9292/
+  get "/", to: ->(_) { [200, {}, ["Hello World"]] }
 
-run router.freeze
+  # wrk -t 2 http://localhost:9292/ruby
+  get "/:lang", to: ->(env) { [200, {}, [env["rutter.params"]["lang"]]] }
+end.freeze
+
+run router

data/lib/rutter.rb

@@ -2,16 +2,19 @@
 
 require_relative "rutter/version"
 require_relative "rutter/builder"
-require_relative "rutter/routes"
 
-# HTTP router for Ramverk and Rack.
+# HTTP router for Rack.
 module Rutter
-  # Creates a new builder object.
+  # Factory method for creating a new builder object.
   #
-  # @return [Rutter::Builder]
+  # @param base [String]
+  #   Base URL, used for generating URLs.
   #
-  # @see Rutter::Builder
-  def self.new(**opts, &block)
-    Builder.new(**opts, &block)
+  # @yield
+  #   Executes the block inside the created builder context.
+  #
+  # @see Rutter::Builder#initialize
+  def self.new(base: "http://localhost:9292", &block)
+    Builder.new(base: base, &block)
   end
 end

data/lib/rutter/builder.rb

@@ -1,150 +1,75 @@
 # frozen_string_literal: true
 
-require "rack"
+require "uri"
 
+require_relative "naming"
+require_relative "verbs"
 require_relative "route"
+require_relative "mount"
 require_relative "scope"
+require_relative "routes"
 
 module Rutter
-  # The router redirect incoming requests to defined endpoints. Most often
-  # it's to a controller and an action or a Rack endpoint.
+  # The builder map URL's to endpoints.
   #
-  # @attr_reader flat_map [Array<Rutter::Route>]
-  #   Defined routes.
-  # @attr_reader verb_map [Hash<String => Array>]
-  #   Routes group by verb.
-  # @attr_reader named_map [Hash<Symbol => Rutter::Route>]
-  #   Named routes.
-  #
-  # @example basic usage
-  #   Rutter.new do
-  #     get "/", to: ->(env) {}
-  #     post "/", to: ->(env) {}
-  #     put "/", to: ->(env) {}
-  #     patch "/", to: ->(env) {}
-  #     delete "/", to: ->(env) {}
-  #     options "/", to: ->(env) {}
-  #     head "/", to: ->(env) {}
-  #     trace "/", to: ->(env) {}
-  #   end.freeze
+  # @!attribute [r] flat_map
+  #   @return [Array]
+  #     Defined routes in a flat map.
+  # @!attribute [r] verb_map
+  #   @return [Hash]
+  #     Defined routes grouped by verb.
+  # @!attribute [r] named_map
+  #   @return [Hash]
+  #     Defined routes grouped by route name.
   class Builder
-    attr_reader :flat_map, :verb_map, :named_map
+    attr_reader :flat_map
+    attr_reader :verb_map
+    attr_reader :named_map
 
-    # Initializes the router.
+    # Initializes the builder.
     #
-    # @param scheme [String]
-    #   URL scheme.
-    # @param host [String]
-    #   URL host.
-    # @param port [Integer]
-    #   URL port.
-    # @param controller_suffix [String]
-    #   Suffix string for controllers (BooksController).
+    # @param base [String]
+    #   Base URL, used for generating URLs.
     #
     # @yield
-    #   Block is run inside the created `Builder` context.
+    #   Executes the block inside the created builder context.
     #
-    # @return [self]
-    def initialize(
-      scheme: "http",
-      host: "example.com",
-      port: 80,
-      controller_suffix: nil,
-      &block
-    )
-      @scheme = scheme
-      @host = host
-      @port = port
-      @controller_suffix = controller_suffix
+    # @return [void]
+    #
+    # @private
+    def initialize(base: "http://localhost:9292", &block)
+      @uri = URI(base).freeze
       @flat_map = []
-      @verb_map = Hash.new { |hash, key| hash[key] = [] }
+      @verb_map = Hash.new { |h, k| h[k] = [] }
       @named_map = {}
 
       instance_eval(&block) if block_given?
     end
 
-    # Mount a Rack application at the specified path.
-    #
-    # @param app [Class, Object]
-    #   A class or an object that responds to `call`.
-    # @param at [String]
-    #   Path prefix to match.
+    # Create a scoped set of routes.
     #
-    # @return [void]
-    def mount(app, at:)
-      Route::VERBS.each { |verb| add verb, "#{at}*_", to: app }
-    end
-
-    # Convenient method to create a redirect endpoint.
-    #
-    # @param destination [String]
-    #   The destination.
-    # @param status [Integer]
-    #   Response status code.
-    #
-    # @return [Proc]
-    #   Redirect endpoint.
-    #
-    # @example basic usage
-    #   Rutter.new do
-    #     get "/legacy-path", to: redirect("/new_path")
-    #   end
+    # @param path [String]
+    #   Scope path prefix.
+    # @param namespace [String, Symbol]
+    #   Scope namespace.
+    # @param as [Symbol]
+    #   Scope name prefix.
     #
-    # @example with custom status
-    #   Rutter.new do
-    #     get "/legacy-path", to: redirect("/new_path", status: 301)
-    #   end
-    def redirect(destination, status: 302)
-      ->(_env) { [status, { "Location" => destination.to_s }, []] }
-    end
-
-    # Defines a root route (a GET route for '/').
+    # @yield
+    #   Block is evaluated inside the created scope context.
     #
-    # @return [Rutter::Route]
+    # @return [Rutter::Scope]
     #
-    # @see Rutter::Builder#add
-    def root(**opts)
-      get "/", **opts.merge(as: :root)
+    # @see Rutter::Scope
+    def scope(path: nil, namespace: nil, as: nil, &block)
+      Scope.new(self, path: path, namespace: namespace, as: as, &block)
     end
 
-    # Adds a new route to the collection.
+    # Creates a scoped collection of routes with the given name as namespace.
     #
-    # @param method [String, Symbol]
-    #   Request method.
-    # @param path [String]
-    #   Path template.
-    # @param as [String, Symbol]
-    #   Route identifier (name).
-    # @param to [String, Proc]
-    #   Route endpoint.
+    # @param name [Symbol, String]
+    #   Scope namespace.
     #
-    # @return [Rutter::Route]
-    def add(method, path, to:, as: nil)
-      route = Route.new(method, path, to, controller_suffix: @controller_suffix)
-
-      flat_map << route
-      verb_map[route.method] << route
-
-      return route unless as
-
-      add_named_route!(as, route)
-    end
-
-    # @see Rutter::Builder#add
-    Route::VERBS.each do |verb|
-      define_method verb.downcase do |path, to:, **opts|
-        add verb, path, to: to, **opts
-      end
-    end
-
-    # Starts a scoped collection of routes.
-    #
-    # @option opts [String] :path (nil)
-    #   Path prefix
-    # @option opts [String] :namespace (nil)
-    #   Namespace prefix
-    # @option opts [String, Symbol] :as (nil)
-    #   Name prefix
     # @yield
     #   Scope context.
     #
@@ -152,155 +77,189 @@ module Rutter
     #
     # @example
     #   Rutter.new do
-    #     scope path: "animals", namespace: "Species", as: "animals" do
-    #       scope path: "mammals", namespace: "Mammals", as: "mammals" do
-    #         get "/cats", to: "Cats#index", as: :cats
-    #       end
+    #     namespace :admin do
+    #       get "/login", to: "sessions#new", as: :login
     #     end
     #   end
+    def namespace(name, &block)
+      scope path: name, namespace: name, as: name, &block
+    end
+
+    # Mount a Rack compatible at the given path prefix.
     #
-    # @example with subdomain
-    #   Rutter.new do
-    #     scope path: "v1", namespace: "Api::V1", subdomain: "api" do
-    #       get "/books", to: "Books#index"
-    #     end
-    #   end
-    def scope(**opts, &block)
-      Scope.new(self, **opts, &block)
+    # @param app [#call]
+    #   Application to mount.
+    # @param at [String]
+    #   Path prefix to match.
+    #
+    # @return [Rutter::Mount]
+    def mount(app, at:)
+      route = Mount.new(at, app)
+      @flat_map << route
+      VERBS.each { |verb| @verb_map[verb] << route }
+      route
     end
 
-    # Transforms a named route into a URL path.
+    # Generates a path from the given arguments.
     #
     # @param name [Symbol]
-    #   Name of the route.
-    # @param params [Hash]
-    #   Route paremeters.
+    #   Name of the route to generate path from.
+    #
+    # @overload path(name, key: value)
+    #   @param key [String, Integer, Array]
+    #     Key value.
+    # @overload path(name, key: value, key2: value2)
+    #   @param key2 [String, Integer, Array]
+    #     Key value.
     #
     # @return [String]
+    #   Generated path.
     #
-    # @raise [ArgumentError]
-    #   if route not found.
-    def path(name, params = {})
-      route = named_map[name]
-
-      raise ArgumentError, "no route called '#{name}'" unless route
+    # @raise [RuntimeError]
+    #   If the route cannot be found.
+    #
+    # @see Rutter::Route#expand
+    #
+    # @example
+    #   router = Rutter.new(base: "http://rutter.org")
+    #   router.get "/login", to: "sessions#new", as: :login
+    #   router.get "/books/:id", to: "books#show", as: :book
+    #
+    #   router.path(:login)
+    #     # => "/login"
+    #   router.path(:login, return_to: "/")
+    #     # => "/login?return_to=/"
+    #   router.path(:book, id: 82)
+    #     # => "/books/82"
+    def path(name, *args)
+      unless (route = @named_map[name])
+        raise "No route called '#{name}' was found"
+      end
 
-      path = route.expand(params)
-      path = path.gsub(%r{\A[\/]+|[\/]+\z}, "")
-      "/#{path}"
+      route.expand(*args)
     end
 
-    # Transforms a named route into a full URL with scheme and host.
+    # Generates a full URL from the given arguments.
     #
     # @param name [Symbol]
-    #   Name of the route.
-    # @option params [String] :_scheme (configuration.scheme)
-    #   Override scheme.
-    # @option params [String] :_host (configuration.host)
-    #   Override host.
-    # @option params [String] :_subdomain (nil)
-    #   Set a specific subdomain for the URL.
-    # @option params [Symbol] :_port (configuration.port)
-    #   Override port. The port will only be visible unless it's set to `80`
-    #   or `443`.
+    #   Name of the route to generate URL from.
+    #
+    # @overload expand(name, subdomain: value)
+    #   @param subdomain [String, Symbol]
+    #     Subdomain to be added to the host.
+    # @overload expand(name, key: value)
+    #   @param key [String, Integer, Array]
+    #     Key value.
+    # @overload expand(name, key: value, key2: value2)
+    #   @param key2 [String, Integer, Array]
+    #     Key value.
     #
     # @return [String]
+    #   Generated URL.
     #
-    # @raise [ArgumentError]
-    #   If route not found.
-    def url(name, params = {})
-      scheme = params.delete(:_scheme) || @scheme
-      host = params.delete(:_host) || @host
-      port = (params.delete(:_port) || @port).to_i
-      host = "#{host}:#{port}" unless [80, 443].include?(port)
-      subdomain = params.delete(:_subdomain)
-      host = "#{subdomain}.#{host}" if subdomain
-      "#{scheme}://#{host}#{path(name, params)}"
+    # @raise [RuntimeError]
+    #   If the route cannot be found.
+    #
+    # @see Rutter::Builder#path
+    #
+    # @example
+    #   router = Rutter.new(base: "http://rutter.org")
+    #   router.get "/login", to: "sessions#new", as: :login
+    #   router.get "/books/:id", to: "books#show", as: :book
+    #
+    #   router.url(:login)
+    #     # => "http://rutter.org/login"
+    #   router.url(:login, return_to: "/")
+    #     # => "http://rutter.org/login?return_to=/"
+    #   router.url(:book, id: 82)
+    #     # => "http://rutter.org/books/82"
+    def url(name, **args)
+      host = @uri.scheme + "://"
+      host += "#{args.delete(:subdomain)}." if args.key?(:subdomain)
+      host += @uri.host
+      host += ":#{@uri.port}" if @uri.port != 80 && @uri.port != 443
+      host + path(name, args)
     end
 
-    # Process the request and is compatible with the Rack protocol.
+    # Add a new, frozen, route to the map.
     #
-    # @param env [Hash]
-    #   Rack environment hash.
+    # @param verb [String]
+    #   Request verb to match.
+    # @param path [String]
+    #   Path template to match.
+    # @param to [#call]
+    #   Rack endpoint.
+    # @param as [Symbol, String]
+    #   Route name/identifier.
+    # @param constraints [Hash]
+    #   Route segment constraints.
     #
-    # @return [Array]
-    #   Serialized Rack response.
+    # @return [Rutter::Route]
     #
-    # @see http://rack.github.io
+    # @raise [ArgumentError]
+    #   If verb is unsupported.
     #
     # @private
-    def call(env)
-      if (route = match(env))
-        env["rutter.action"] = route.endpoint[:action]
-        env["rutter.params"] = route.params(env["PATH_INFO"])
-        ctrl = route.endpoint[:controller]
-        ctrl = Object.const_get(ctrl) if ctrl.is_a?(String)
-        return ctrl.call(env)
+    def add(verb, path, to:, as: nil, constraints: nil)
+      verb = verb.to_s.upcase
+
+      unless VERBS.include?(verb)
+        raise ArgumentError, "Unsupported verb '#{verb}'"
       end
 
-      NOT_FOUND_RESPONSE
+      route = Route.new(path, to, constraints)
+      @flat_map << route
+      @verb_map[verb] << route
+      return route unless as
+
+      named_map[Naming.route_name(as)] = route
     end
 
-    # Freezes the router and its routes.
+    # Freeze the state of the router.
     #
     # @return [self]
     def freeze
-      flat_map.freeze
-      verb_map.freeze
-      named_map.freeze
+      @flat_map.freeze
+      @verb_map.freeze
+      @verb_map.each_value(&:freeze)
+      @named_map.freeze
 
       super
     end
 
-    private
+    # @see #add
+    VERBS.each do |verb|
+      define_method verb.downcase do |path, to:, as: nil, constraints: nil|
+        add verb, path, to: to, as: as, constraints: constraints
+      end
+    end
 
-    # Matches the incoming request with the routes.
+    # Process the request and is compatible with the Rack protocol.
+    #
+    # @param env [Hash]
+    #   Rack environment hash.
     #
-    # @param env [Hash] Rack's environment hash.
+    # @return [Array]
+    #   Serialized Rack response.
     #
-    # @return [Rutter::Route, false]
+    # @see http://rack.github.io
     #
     # @private
-    def match(env)
-      path = (env["PATH_INFO"] || "/").downcase
-      path = path.chomp("/") if path != "/" && path.end_with?("/")
-
-      routes = verb_map[env["REQUEST_METHOD"]]
-      routes.each do |route|
-        return route if route.match?(path)
-      end
-
-      false
-    end
+    def call(env)
+      request_method = env["REQUEST_METHOD"]
 
-    # @private
-    def add_named_route!(name, route)
-      name = normalize_route_name(name)
+      return NOT_FOUND_RESPONSE unless @verb_map.key?(request_method)
 
-      if named_map.key?(name)
-        raise "a route called '#{name}' has already been defined"
+      routes = @verb_map[request_method]
+      routes.each do |route|
+        next unless route.match?(env)
+        return route.call(env)
       end
 
-      named_map[name] = route
-    end
-
-    # @private
-    def normalize_route_name(name)
-      name.to_s
-          .tr("/", "_")
-          .gsub(/[_]{2,}/, "_")
-          .gsub(/\A_|_\z/, "")
-          .downcase
-          .to_sym
+      NOT_FOUND_RESPONSE
     end
 
-    # Response returned when no route matched the request.
-    #
     # @private
-    NOT_FOUND_RESPONSE = [
-      404,
-      { "X-Cascade" => "pass" },
-      ["Route Not Found"]
-    ].freeze
+    NOT_FOUND_RESPONSE = [404, { "X-Cascade" => "pass" }, ["Not Found"]].freeze
   end
 end