rack-app 5.0.0.rc1 → 5.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 401d8f6ab979fa3f44891018a61dcf640d45b488
-  data.tar.gz: 5d02724b737e668072d4ca5972d76d043cf854a5
+  metadata.gz: 4b130d9458099d27fab690cf3db1597ada7cac19
+  data.tar.gz: b05e1b11630efd3ced90361372634d121db73c25
 SHA512:
-  metadata.gz: 010fcc827baf6f48e2ed0882a8d0b17052afc2dd11ae20659b722b91720f06a9bf161e4560d804b9f83b3e7c58c803cab8e1765719b6a312e45fd6479f7efcba
-  data.tar.gz: ab3f8dec6d35b7c3ec9570d9af48a10d2ab9ff2e027755bd9dedded3648017ec5d5dd359d7becf3f4cd70688744b3164496328b190749fdfca91cd710956e13c
+  metadata.gz: d431d736219cce600153c1357dccb58742ac39babdaafadb3a0377954b55a56d5cca796e7c0dcc26dcfa105c4c21003c54b853a71bb3f78ef37e9983600fee3c
+  data.tar.gz: a8da83f4a90063bb491be7803615d05f795ccea24676700ba9b47073199730e4c6658a3868c59eb3b77508627a2db04e55ab25b45352a8b6280e62067acb2a70

data/.ruby-version

@@ -0,0 +1 @@
+2.3.0

data/VERSION

@@ -1 +1 @@
-5.0.0.rc1
+5.0.0.rc2

data/lib/rack/app.rb

@@ -19,7 +19,6 @@ class Rack::App
   require 'rack/app/file_server'
   require 'rack/app/error_handler'
   require 'rack/app/bundled_extensions'
-  require 'rack/app/endpoint/not_found'
   require 'rack/app/request_configurator'
 
   require 'rack/app/singleton_methods'

data/lib/rack/app/constants.rb

@@ -1,21 +1,34 @@
 module Rack::App::Constants
 
   module HTTP
-    ANY = 'ANY'.freeze
-    GET='GET'.freeze
-    POST = 'POST'.freeze
-    PUT = 'PUT'.freeze
-    DELETE = 'DELETE'.freeze
-    PATCH = 'PATCH'.freeze
-    HEAD = 'HEAD'.freeze
-    OPTIONS = 'OPTIONS'.freeze
+
+    module METHOD
+      ANY     = 'ANY'.freeze
+      GET     = 'GET'.freeze
+      POST    = 'POST'.freeze
+      PUT     = 'PUT'.freeze
+      PATCH   = 'PATCH'.freeze
+      DELETE  = 'DELETE'.freeze
+      HEAD    = 'HEAD'.freeze
+      OPTIONS = 'OPTIONS'.freeze
+      LINK    = 'LINK'.freeze
+      UNLINK  = 'UNLINK'.freeze
+      TRACE   = 'TRACE'.freeze
+    end
+
+    METHODS = (METHOD.constants - [:ANY]).map(&:to_s).freeze
+
+  end
+
+  module ENV
+    PARSED_PARAMS = 'rack-app.parsed_params'
+    VALIDATED_PARAMS = 'rack-app.validated_params'
+    ORIGINAL_PATH_INFO = 'rack-app.original_path_info'.freeze
+    PATH_PARAMS_MATCHER = 'rack-app.path_params_matcher'.freeze
+    METHODOVERRIDE_ORIGINAL_METHOD = 'rack-app.methodoverride.original_method'.freeze
   end
 
-  ORIGINAL_PATH_INFO = 'rack-app.original_path_info'.freeze
-  PATH_PARAMS_MATCHER = 'rack-app.path_params_matcher'.freeze
-  RACK_BASED_APPLICATION = '[Mounted Rack Application]'.freeze
   MOUNTED_DIRECTORY = '[Mounted Directory]'.freeze
-  VALIDATED_PARAMS = 'rack-app.validated_params'
-  PARSED_PARAMS = 'rack-app.parsed_params'
-  
+  RACK_BASED_APPLICATION = '[Mounted Rack Application]'.freeze
+
 end

data/lib/rack/app/endpoint.rb

@@ -1,25 +1,39 @@
+require "rack/builder"
 class Rack::App::Endpoint
+  require "rack/app/endpoint/properties"
 
-  attr_reader :properties
+  def properties
+    @properties.to_hash
+  end
 
   LAST_MODIFIED_HEADER = "Last-Modified".freeze
 
   def initialize(properties)
-    @properties = properties
+    @properties = Rack::App::Endpoint::Properties.new(properties)
+    @endpoint_method_name = register_method_to_app_class(properties[:user_defined_logic])
+  end
 
-    @app_class = properties[:app_class]
-    @error_handler = properties[:error_handler] || Rack::App::ErrorHandler.new
-    @serializer = properties[:serializer] || Rack::App::Serializer.new
+  def call(env)
+    to_app.call(env)
+  end 
 
-    middleware = (properties[:middleware] || Rack::Builder.new).dup
-    middleware.run(lambda { |env| self.call_without_middlewares(env) })
-    @endpoint_method_name = register_method_to_app_class(properties[:user_defined_logic])
+  def to_app
+    builder = Rack::Builder.new
+    apply_middleware_build_blocks(builder)
+    builder.run(lambda { |env| self.call_without_middlewares(env) })
+    builder.to_app
+  end
 
-    @app = middleware.to_app
+  protected
+
+  def apply_middleware_build_blocks(builder)
+    builder_blocks.each do |builder_block|
+      builder_block.call(builder)
+    end
   end
 
-  def call(env)
-    @app.call(env)
+  def builder_blocks
+    @properties.app_class.middlewares + @properties.middleware_builders_blocks
   end
 
   def call_without_middlewares(env)
@@ -28,10 +42,8 @@ class Rack::App::Endpoint
     return catch(:rack_response){ execute(request, response) }.finish
   end
 
-  protected
-
   def execute(request,response)
-    request_handler = @app_class.new
+    request_handler = @properties.app_class.new
     request_handler.request = request
     request_handler.response = response
     set_response_body(response, get_response_body(request_handler))
@@ -41,24 +53,24 @@ class Rack::App::Endpoint
   def get_response_body(request_handler)
     catch :response_body do
       evaluated_value = evaluate_value(request_handler)
-      
+
       evaluated_value
     end
   end
 
   def set_response_body(response, response_body)
-    response.write(String(@serializer.serialize(response_body)))
+    response.write(String(@properties.serializer.serialize(response_body)))
   end
 
   def evaluate_value(request_handler)
-    @error_handler.execute_with_error_handling_for(request_handler) do
+    @properties.error_handler.execute_with_error_handling_for(request_handler) do
       request_handler.__send__(@endpoint_method_name)
     end
   end
 
   def register_method_to_app_class(proc)
     method_name = '__' + ::Rack::App::Utils.uuid
-    @app_class.__send__(:define_method, method_name, &proc)
+    @properties.app_class.__send__(:define_method, method_name, &proc)
     return method_name
   end
 end

data/lib/rack/app/endpoint/properties.rb

@@ -0,0 +1,29 @@
+class Rack::App::Endpoint::Properties
+
+  def to_hash 
+    @raw
+  end
+
+  def app_class
+    @raw[:app_class] || raise('missing app class')
+  end
+
+  def serializer
+    @raw[:serializer] ||= Rack::App::Serializer.new
+  end
+
+  def error_handler
+    @raw[:error_handler] ||= Rack::App::ErrorHandler.new
+  end
+
+  def middleware_builders_blocks
+    @raw[:middleware_builders_blocks] ||= []
+  end
+
+  protected
+
+  def initialize(raw)
+    @raw = raw
+  end
+
+end

data/lib/rack/app/instance_methods/core.rb

@@ -3,11 +3,11 @@ module Rack::App::InstanceMethods::Core
   attr_writer :request, :response
 
   def params
-    request.env[::Rack::App::Constants::PARSED_PARAMS] ||= Rack::App::Params.new(request.env).to_hash
+    request.env[::Rack::App::Constants::ENV::PARSED_PARAMS] ||= Rack::App::Params.new(request.env).to_hash
   end
 
   def validated_params
-    request.env[::Rack::App::Constants::VALIDATED_PARAMS]
+    request.env[::Rack::App::Constants::ENV::VALIDATED_PARAMS]
   end
 
   def request

data/lib/rack/app/middlewares.rb

@@ -1,4 +1,5 @@
 module Rack::App::Middlewares
   require 'rack/app/middlewares/header_setter'
+  require 'rack/app/middlewares/method_override'
   require 'rack/app/middlewares/params'
 end

data/lib/rack/app/middlewares/method_override.rb

@@ -0,0 +1,55 @@
+class Rack::App::Middlewares::MethodOverride
+
+  ALLOWED_METHODS = %w[GET POST].freeze
+  METHOD_OVERRIDE_PARAM_KEY = "_method".freeze
+  HTTP_METHOD_OVERRIDE_HEADER = "HTTP_X_HTTP_METHOD_OVERRIDE".freeze
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    if affected_request?(env)
+      try_override(env)
+    end
+
+    @app.call(env)
+  end
+
+  protected
+
+  def try_override(env)
+    method = method_override(env)
+    if valid_https_method?(method)
+      set_request_method(method, env)
+    end
+  end
+
+  def set_request_method(method, env)
+    env[Rack::App::Constants::ENV::METHODOVERRIDE_ORIGINAL_METHOD] = env[Rack::REQUEST_METHOD]
+    env[Rack::REQUEST_METHOD] = method
+  end
+
+  def valid_https_method?(method)
+    Rack::App::Constants::HTTP::METHODS.include?(method)
+  end
+
+  def affected_request?(env)
+    ALLOWED_METHODS.include?(env[Rack::REQUEST_METHOD])
+  end
+
+  def method_override(env)
+    req = Rack::Request.new(env)
+    method = env[HTTP_METHOD_OVERRIDE_HEADER] ||
+              method_override_param(req,:POST) ||
+                method_override_param(req,:GET)
+
+    method.to_s.upcase
+  end
+
+  def method_override_param(req, http_method)
+    req.__send__(http_method)[METHOD_OVERRIDE_PARAM_KEY]
+  rescue Rack::Utils::InvalidParameterError, Rack::Utils::ParameterTypeError
+  end
+
+end

data/lib/rack/app/middlewares/params/parser.rb

@@ -16,7 +16,7 @@ class Rack::App::Middlewares::Params::Parser
 
   def set_params(env)
     params = Rack::App::Params.new(env).to_hash
-    validated_params = (env[::Rack::App::Constants::VALIDATED_PARAMS] ||= {})
+    validated_params = (env[::Rack::App::Constants::ENV::VALIDATED_PARAMS] ||= {})
     parse_params(validated_params, params)
   end
 

data/lib/rack/app/middlewares/params/setter.rb

@@ -5,7 +5,7 @@ class Rack::App::Middlewares::Params::Setter
   end
 
   def call(env)
-    env[::Rack::App::Constants::PARSED_PARAMS] ||= params_hash(env)
+    env[::Rack::App::Constants::ENV::PARSED_PARAMS] ||= params_hash(env)
 
     @app.call(env)
   end

data/lib/rack/app/params.rb

@@ -2,8 +2,8 @@ require 'cgi'
 class Rack::App::Params
 
   def to_hash
-    if @request_env[::Rack::App::Constants::PARSED_PARAMS]
-      @request_env[::Rack::App::Constants::PARSED_PARAMS]
+    if @request_env[::Rack::App::Constants::ENV::PARSED_PARAMS]
+      @request_env[::Rack::App::Constants::ENV::PARSED_PARAMS]
     else
       query_params.merge(request_path_params)
     end
@@ -58,7 +58,7 @@ class Rack::App::Params
   end
 
   def path_params_matcher
-    @request_env[::Rack::App::Constants::PATH_PARAMS_MATCHER] || {}
+    @request_env[::Rack::App::Constants::ENV::PATH_PARAMS_MATCHER] || {}
   end
 
 end

data/lib/rack/app/request_configurator.rb

@@ -11,7 +11,7 @@ module Rack::App::RequestConfigurator
 
   def path_info(env)
     path_info = env[::Rack::PATH_INFO]
-    env[::Rack::App::Constants::ORIGINAL_PATH_INFO]= path_info
+    env[::Rack::App::Constants::ENV::ORIGINAL_PATH_INFO]= path_info
     env[::Rack::PATH_INFO]= Rack::App::Utils.normalize_path(path_info)
   end
 

data/lib/rack/app/router.rb

@@ -51,6 +51,10 @@ class Rack::App::Router
     nil
   end
 
+  def reset
+    [@static, @dynamic].each(&:reset)
+  end 
+
   protected
 
   def initialize

data/lib/rack/app/router/base.rb

@@ -6,10 +6,10 @@ class Rack::App::Router::Base
     path_info= env[Rack::PATH_INFO]
 
     context = fetch_context(request_method, path_info)
-    return unless context.is_a?(Hash) and not context[:endpoint].nil?
+    return unless context.is_a?(Hash) and not context[:app].nil?
 
     format_env(context, env)
-    context[:endpoint].call(env)
+    context[:app].call(env)
 
   end
 
@@ -34,14 +34,26 @@ class Rack::App::Router::Base
     return endpoint
   end
 
+  def reset
+    compile_registered_endpoints!
+  end
+
   protected
 
-  def fetch_context(request_method, request_path)
+  def compile_registered_endpoints!
     raise('IMPLEMENTATION MISSING ERROR')
   end
 
-  def compile_registered_endpoints!
+  def fetch_context(request_method, request_path)
     raise('IMPLEMENTATION MISSING ERROR')
   end
 
+  def as_app(endpoint_or_app)
+    if endpoint_or_app.respond_to?(:to_app)
+      endpoint_or_app.to_app
+    else
+      endpoint_or_app
+    end
+  end
+
 end

data/lib/rack/app/router/dynamic.rb

@@ -73,6 +73,7 @@ class Rack::App::Router::Dynamic < Rack::App::Router::Base
 
       end
 
+      current_cluster[:app]= as_app(endpoint)
       current_cluster[:endpoint]= endpoint
       if current_cluster[:endpoint].respond_to?(:register_path_params_matcher)
         current_cluster[:endpoint].register_path_params_matcher(path_params)
@@ -91,7 +92,7 @@ class Rack::App::Router::Dynamic < Rack::App::Router::Base
   end
 
   def clusters_for(request_method)
-    if ::Rack::App::Constants::HTTP::ANY == request_method
+    if ::Rack::App::Constants::HTTP::METHOD::ANY == request_method
       supported_http_protocols.each do |cluster_type|
         yield(main_cluster(cluster_type))
       end
@@ -101,7 +102,7 @@ class Rack::App::Router::Dynamic < Rack::App::Router::Base
   end
 
   def supported_http_protocols
-    (::Rack::App::Constants::HTTP.constants - [:ANY]).map(&:to_s)
+    ::Rack::App::Constants::HTTP::METHODS
   end
 
 
@@ -111,7 +112,6 @@ class Rack::App::Router::Dynamic < Rack::App::Router::Base
     last_mounted_directory = nil
     last_mounted_app = nil
     current_cluster = main_cluster(request_method)
-
     normalized_request_path.split('/').each do |path_part|
 
       last_mounted_directory = current_cluster[MOUNTED_DIRECTORY] || last_mounted_directory
@@ -145,8 +145,8 @@ class Rack::App::Router::Dynamic < Rack::App::Router::Base
 
   def format_env(context, env)
     mount_path = context[:options][:mount_path] rescue ''
-    env[::Rack::App::Constants::PATH_PARAMS_MATCHER]= context[:options][:path_params].dup
+    env[::Rack::App::Constants::ENV::PATH_PARAMS_MATCHER]= context[:options][:path_params].dup
     env[::Rack::PATH_INFO].sub!(mount_path, '')
   end
 
-end
+end

data/lib/rack/app/router/not_found.rb

@@ -1,11 +1,23 @@
+require "rack/response"
 class Rack::App::Router::NotFound < Rack::App::Router::Base
 
   def fetch_context(request_method, path_info)
-    {:endpoint => ::Rack::App::Endpoint::NOT_FOUND}
+    {:app => lambda{|env| not_found_response }}
   end
 
   def fetch_endpoint(request_method, path_info)
     ::Rack::App::Endpoint::NOT_FOUND
   end
 
-end
+  protected
+
+  def not_found_response
+    rack_response = Rack::Response.new
+    rack_response.status = 404
+    rack_response.write('404 Not Found')
+    rack_response.finish
+  end
+  
+  def compile_registered_endpoints!
+  end
+end

data/lib/rack/app/router/static.rb

@@ -1,22 +1,21 @@
 class Rack::App::Router::Static < Rack::App::Router::Base
 
-  def compile_registered_endpoints!
-    mapped_endpoint_routes.clear
-    endpoints.each do |endpoint|
-      request_method, request_path, endpoint_object = endpoint[:request_method], endpoint[:request_path], endpoint[:endpoint]
-      mapped_endpoint_routes[[request_method.to_s.upcase, request_path]]= endpoint_object
-    end
-  end
-
   protected
 
   def fetch_context(request_method, request_path)
-    endpoint = mapped_endpoint_routes[[request_method, request_path]]
-    endpoint && {:endpoint => endpoint}
+    app = mapped_endpoint_routes[[request_method, request_path]]
+    app && {:app => app}
   end
 
   def mapped_endpoint_routes
     @mapped_endpoint_routes ||= {}
   end
 
-end
+  def compile_registered_endpoints!
+    mapped_endpoint_routes.clear
+    endpoints.each do |endpoint|
+      app = as_app(endpoint[:endpoint])
+      mapped_endpoint_routes[[endpoint[:request_method].to_s.upcase, endpoint[:request_path]]]= app
+    end
+  end
+end

data/lib/rack/app/singleton_methods/http_methods.rb

@@ -3,31 +3,43 @@ module Rack::App::SingletonMethods::HttpMethods
   protected
 
   def get(path = '/', &block)
-    add_route(::Rack::App::Constants::HTTP::GET, path, &block)
+    add_route(::Rack::App::Constants::HTTP::METHOD::GET, path, &block)
   end
 
   def post(path = '/', &block)
-    add_route(::Rack::App::Constants::HTTP::POST, path, &block)
+    add_route(::Rack::App::Constants::HTTP::METHOD::POST, path, &block)
   end
 
   def put(path = '/', &block)
-    add_route(::Rack::App::Constants::HTTP::PUT, path, &block)
+    add_route(::Rack::App::Constants::HTTP::METHOD::PUT, path, &block)
   end
 
   def delete(path = '/', &block)
-    add_route(::Rack::App::Constants::HTTP::DELETE, path, &block)
+    add_route(::Rack::App::Constants::HTTP::METHOD::DELETE, path, &block)
   end
 
   def head(path = '/', &block)
-    add_route(::Rack::App::Constants::HTTP::HEAD, path, &block)
+    add_route(::Rack::App::Constants::HTTP::METHOD::HEAD, path, &block)
   end
 
   def options(path = '/', &block)
-    add_route(::Rack::App::Constants::HTTP::OPTIONS, path, &block)
+    add_route(::Rack::App::Constants::HTTP::METHOD::OPTIONS, path, &block)
   end
 
   def patch(path = '/', &block)
-    add_route(::Rack::App::Constants::HTTP::PATCH, path, &block)
+    add_route(::Rack::App::Constants::HTTP::METHOD::PATCH, path, &block)
+  end
+
+  def link(path = '/', &block)
+    add_route(::Rack::App::Constants::HTTP::METHOD::LINK, path, &block)
+  end
+  
+  def unlink(path = '/', &block)
+    add_route(::Rack::App::Constants::HTTP::METHOD::UNLINK, path, &block)
+  end
+
+  def trace(path = '/', &block)
+    add_route(::Rack::App::Constants::HTTP::METHOD::TRACE, path, &block)
   end
 
   def alias_endpoint(new_request_path, original_request_path)

data/lib/rack/app/singleton_methods/middleware.rb

@@ -1,10 +1,11 @@
 module Rack::App::SingletonMethods::Middleware
 
-  protected
-  
   def middlewares(&block)
     @middlewares ||= []
-    @middlewares << block unless block.nil?
+    unless block.nil?
+      @middlewares << block
+      router.reset
+    end
     @middlewares
   end
 
@@ -14,6 +15,8 @@ module Rack::App::SingletonMethods::Middleware
     middlewares{ |b| b.use(*args) }
   end
 
+  protected
+
   def only_next_endpoint_middlewares(&block)
     @only_next_endpoint_middlewares ||= []
     @only_next_endpoint_middlewares << block unless block.nil?

data/lib/rack/app/singleton_methods/mounting.rb

@@ -40,18 +40,15 @@ module Rack::App::SingletonMethods::Mounting
     file_server = Rack::App::FileServer.new(Rack::App::Utils.expand_path(file_path))
     request_path = Rack::App::Utils.join(@namespaces, options[:to], '**', '*')
     router.register_endpoint!('GET', request_path, file_server, route_registration_properties)
-    @last_description = nil
   end
 
   def mount_rack_based_application(rack_based_app, options={})
     router.register_endpoint!(
-      ::Rack::App::Constants::HTTP::ANY,
+      ::Rack::App::Constants::HTTP::METHOD::ANY,
       Rack::App::Utils.join(@namespaces, options[:to], ::Rack::App::Constants::RACK_BASED_APPLICATION),
       rack_based_app,
       route_registration_properties
     )
-
-    @last_description = nil
   end
 
   alias mount_app mount_rack_based_application

data/lib/rack/app/singleton_methods/route_handling.rb

@@ -24,30 +24,21 @@ module Rack::App::SingletonMethods::RouteHandling
 
     request_path = ::Rack::App::Utils.join(@namespaces, request_path)
 
-    builder = Rack::Builder.new
-    (middlewares + only_next_endpoint_middlewares).each do |builder_block|
-      builder_block.call(builder)
-    end
-
-    only_next_endpoint_middlewares.clear
-
     properties = {
         :user_defined_logic => block,
         :request_method => request_method,
         :request_path => request_path,
-
         :error_handler => error,
         :serializer => serializer,
-        :middleware => builder,
+        :middleware_builders_blocks => only_next_endpoint_middlewares.dup,
         :app_class => self
     }
 
+    only_next_endpoint_middlewares.clear
 
     endpoint = Rack::App::Endpoint.new(properties)
     router.register_endpoint!(request_method, request_path, endpoint, route_registration_properties)
-
     @route_registration_properties = nil
-    @last_description = nil
     return endpoint
 
   end
@@ -57,8 +48,8 @@ module Rack::App::SingletonMethods::RouteHandling
     @namespaces ||= []
     @namespaces.push(request_path_namespace)
     yield
+  ensure
     @namespaces.pop
-    nil
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-app
 version: !ruby/object:Gem::Version
-  version: 5.0.0.rc1
+  version: 5.0.0.rc2
 platform: ruby
 authors:
 - Adam Luzsi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-16 00:00:00.000000000 Z
+date: 2016-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -78,6 +78,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- ".ruby-version"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - CONTRIBUTING.md
@@ -105,7 +106,7 @@ files:
 - lib/rack/app/cli/runner.rb
 - lib/rack/app/constants.rb
 - lib/rack/app/endpoint.rb
-- lib/rack/app/endpoint/not_found.rb
+- lib/rack/app/endpoint/properties.rb
 - lib/rack/app/error_handler.rb
 - lib/rack/app/extension.rb
 - lib/rack/app/file_server.rb
@@ -116,6 +117,7 @@ files:
 - lib/rack/app/instance_methods/serve_file.rb
 - lib/rack/app/middlewares.rb
 - lib/rack/app/middlewares/header_setter.rb
+- lib/rack/app/middlewares/method_override.rb
 - lib/rack/app/middlewares/params.rb
 - lib/rack/app/middlewares/params/definition.rb
 - lib/rack/app/middlewares/params/definition/options.rb

data/lib/rack/app/endpoint/not_found.rb

@@ -1,13 +0,0 @@
-app_class = Class.new(Rack::App)
-not_found_properties = {
-    :user_defined_logic => lambda {
-      response.status= 404
-      return '404 Not Found'
-    },
-    :request_method => 'GET',
-    :request_path => '\404',
-    :description => 'page not found',
-    :app_class => app_class
-}
-
-Rack::App::Endpoint::NOT_FOUND = Rack::App::Endpoint.new(not_found_properties)