rack-app 5.10.2 → 5.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 983dee78b91bcdb205f8897297ef37cd2ebf7e3a
-  data.tar.gz: b25e20aaaac647a04b6559ca59b9d4970f4a7670
+  metadata.gz: 070c847ed07e3494ed51e88ebf084c6eb661a30f
+  data.tar.gz: 4b836fb0a7d4c38491b4d2774b85289d528c1c56
 SHA512:
-  metadata.gz: 05075fc0dc6dad4d1f01f9c3a5b3683c4dd490733db795bffc4b34e192de70b694f0d7faa9c62f30ed097559a5a3e9089a1f4aec365a1a21a1edf3e8075dc644
-  data.tar.gz: 4f5d3a2ccff652a98c2a0369eee4ea7d823ddfc994c7984439620c9563857688ba616a31bedb1ccc658ab859d313cb56e505c114963532a9b8823a3eed63c089
+  metadata.gz: 566de7abd739139b8ac5980bcad9079995892d36c1f7213cadedd2451d62ce6ee7f41a2c23327c7174e0576b20ab1b7d71cbfab0b01a79424bb77ae63e35ade3
+  data.tar.gz: 91ac3f3615722f31dc483aa4cd4845902d8270655cb1a2e96c2fa72d78add151692ed0cc5a6304c6a5ad6f10a06d40e66c589ceb604b188b944d0fda8d18fb38

data/.rspec

@@ -1,2 +1,3 @@
 --color
+--fail-fast
 --require spec_helper

data/VERSION

@@ -1 +1 @@
-5.10.2
+5.11.0

data/lib/rack/app/constants.rb

@@ -51,8 +51,9 @@ module Rack::App::Constants
     PAYLOAD_GETTER = 'rack-app.payload.getter'.freeze
     PARSED_PAYLOAD = 'rack-app.payload.parsed'.freeze
 
+    PATH_PARAMS = 'rack-app.path_params'.freeze
     ORIGINAL_PATH_INFO = 'rack-app.original_path_info'.freeze
-    PATH_PARAMS_MATCHER = 'rack-app.path_params_matcher'.freeze
+    FORMATTED_PATH_INFO = 'rack-app.formatted_path_info'.freeze
     METHODOVERRIDE_ORIGINAL_METHOD = 'rack-app.methodoverride.original_method'.freeze
 
   end

data/lib/rack/app/endpoint.rb

@@ -2,7 +2,7 @@ class Rack::App::Endpoint
 
   require "forwardable"
   extend Forwardable
-  def_delegators :@config, :request_method, :request_path, :description
+  def_delegators :@config, :request_methods, :request_path, :description
 
   require "rack/app/endpoint/config"
   require "rack/app/endpoint/builder"
@@ -26,10 +26,6 @@ class Rack::App::Endpoint
     to_app.call(env)
   end
 
-  def supported_extnames
-    @config.serializer.extnames
-  end
-
   def to_app
     @config.application || self.class::Builder.new(@config).build
   end

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

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
 class Rack::App::Endpoint::Config
-
   def to_hash
     error_handler
     middleware_builders_blocks
     request_path
-    request_method
-    return @raw
+    request_methods
+    defined_request_path
+    @raw
   end
 
   def payload_builder
@@ -48,16 +49,29 @@ class Rack::App::Endpoint::Config
     @raw[:method_name] ||= register_method_to_app_class
   end
 
-  def request_method
-    (@raw[:request_method] || raise('missing request_method!')).to_s.upcase
+  def request_methods
+    case @raw[:request_methods] || raise('missing config: request_methods')
+    when Rack::App::Constants::HTTP::METHOD::ANY
+      Rack::App::Constants::HTTP::METHODS
+    when ::Array
+      @raw[:request_methods].map(&:to_sym)
+    else
+      [@raw[:request_methods]].flatten.map(&:to_sym)
+    end
   end
 
   def request_path
     Rack::App::Utils.normalize_path(@raw[:request_path] || raise('missing request_path!'))
   end
 
+  def defined_request_path
+    Rack::App::Utils.normalize_path(@raw[:defined_request_path] ||= request_path)
+  end
+
   def description
-    @raw[:route][:description] || @raw[:route][:desc] rescue nil
+    @raw[:route][:description] || @raw[:route][:desc]
+  rescue
+    nil
   end
 
   protected
@@ -69,11 +83,10 @@ class Rack::App::Endpoint::Config
   def register_method_to_app_class
     method_name = '__' + ::Rack::App::Utils.uuid
     app_class.__send__(:define_method, method_name, &logic_block)
-    return method_name
+    method_name
   end
 
   def logic_block
     @raw[:user_defined_logic]
   end
-
 end

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

@@ -3,8 +3,6 @@ require "rack/request"
 require "rack/response"
 class Rack::App::Middlewares::Configuration
 
-  require "rack/app/middlewares/configuration/path_params_matcher"
-
   def initialize(app, config)
     @app = app || raise
     @serializer = config.serializer || raise
@@ -13,12 +11,12 @@ class Rack::App::Middlewares::Configuration
   end
 
   def call(env)
-    env[Rack::App::Constants::ENV::REQUEST_HANDLER]= handler(env)
+    env[::Rack::App::Constants::ENV::REQUEST_HANDLER]= handler(env)
     env[::Rack::App::Constants::ENV::SERIALIZER]= @serializer
     env[::Rack::App::Constants::ENV::PAYLOAD_PARSER]= @payload_parser
     env[::Rack::App::Constants::ENV::PAYLOAD_GETTER]= lambda do
-       env[::Rack::App::Constants::ENV::PARSED_PAYLOAD] ||= env[::Rack::App::Constants::ENV::PAYLOAD_PARSER].parse_env(env)
-     end
+      env[::Rack::App::Constants::ENV::PARSED_PAYLOAD] ||= env[::Rack::App::Constants::ENV::PAYLOAD_PARSER].parse_env(env)
+    end
     @app.call(env)
   end
 

data/lib/rack/app/params.rb

@@ -38,32 +38,7 @@ class Rack::App::Params
   end
 
   def request_path_params
-    path_params = {}
-    path_params.merge!(extract_path_params) unless path_params_matcher.empty?
-    path_params
-  end
-
-  def extract_path_params
-    last_index = request_path_parts.length - 1
-    request_path_parts.each.with_index.reduce({}) do |params_col, (path_part, index)|
-      if path_params_matcher[index]
-        if index == last_index && @env[::Rack::App::Constants::ENV::EXTNAME]
-          matcher = Regexp.escape(@env[::Rack::App::Constants::ENV::EXTNAME])
-          path_part = path_part.sub(/#{matcher}$/,'')
-        end
-        params_col[path_params_matcher[index]]= path_part
-      end
-
-      params_col
-    end
-  end
-
-  def request_path_parts
-    @env[::Rack::App::Constants::ENV::PATH_INFO].split('/')
-  end
-
-  def path_params_matcher
-    @env[::Rack::App::Constants::ENV::PATH_PARAMS_MATCHER] || {}
+    @env[::Rack::App::Constants::ENV::PATH_PARAMS]
   end
 
 end

data/lib/rack/app/router.rb

@@ -1,42 +1,35 @@
 class Rack::App::Router
 
-  require 'rack/app/router/base'
-  require 'rack/app/router/static'
-  require 'rack/app/router/dynamic'
-  require 'rack/app/router/not_found'
+  require 'rack/app/router/tree'
+
+  NOT_FOUND_APP = lambda do |env|
+    rack_response = Rack::Response.new
+    rack_response.status = 404
+    rack_response.write('404 Not Found')
+    rack_response.finish
+  end
 
   def call(env)
-    Rack::App::RequestConfigurator.configure(env)
-    @static.call(env) or @dynamic.call(env) or @not_found.call(env)
+    @tree.call(env) || NOT_FOUND_APP.call(env)
   end
 
   def endpoints
-    [@static, @dynamic, @not_found].map(&:endpoints).reduce([], :+)
+    @endpoints ||= []
   end
 
-  def show_endpoints
-
-    endpoints = self.endpoints
-
-    wd0 = endpoints.map { |endpoint| endpoint.request_method.to_s.length }.max
-    wd1 = endpoints.map { |endpoint| endpoint.request_path.to_s.length }.max
-    wd2 = endpoints.map { |endpoint| endpoint.description.to_s.length }.max
-
-    return endpoints.sort_by { |endpoint| [endpoint.request_method, endpoint.request_path] }.map do |endpoint|
-      [
-          endpoint.request_method.to_s.ljust(wd0),
-          endpoint.request_path.to_s.ljust(wd1),
-          endpoint.description.to_s.ljust(wd2)
-      ].join('   ')
-    end
-
+  def register_endpoint!(endpoint)
+    endpoints.push(endpoint)
+    compile_endpoint!(endpoint)
+    return endpoint
   end
 
-  def register_endpoint!(endpoint)
-    router = router_for(endpoint.request_path)
-    router.register_endpoint!(endpoint)
+  # add ! to method name
+  def reset
+    @tree = Rack::App::Router::Tree.new
+    compile_registered_endpoints!
   end
 
+  # rename to merge!
   def merge_router!(router, prop={})
     raise(ArgumentError, 'invalid router object, must implement :endpoints interface') unless router.respond_to?(:endpoints)
     router.endpoints.each do |endpoint|
@@ -47,27 +40,40 @@ class Rack::App::Router
     nil
   end
 
-  def reset
-    [@static, @dynamic].each(&:reset)
+
+  def show_endpoints
+
+    endpoints = self.endpoints
+
+    wd0 = endpoints.map { |endpoint| endpoint.request_methods.first.to_s.length }.max
+    wd1 = endpoints.map { |endpoint| endpoint.request_path.to_s.length }.max
+    wd2 = endpoints.map { |endpoint| endpoint.description.to_s.length }.max
+
+    return endpoints.sort_by { |endpoint| [endpoint.request_methods.first, endpoint.request_path] }.map do |endpoint|
+      [
+        endpoint.request_methods.first.to_s.ljust(wd0),
+        endpoint.request_path.to_s.ljust(wd1),
+        endpoint.description.to_s.ljust(wd2)
+      ].join('   ')
+    end
+
   end
 
   protected
 
+
   def initialize
-    @static = Rack::App::Router::Static.new
-    @dynamic = Rack::App::Router::Dynamic.new
-    @not_found = Rack::App::Router::NotFound.new
+    reset
   end
 
-  def router_for(request_path)
-    defined_path_is_dynamic?(request_path) ? @dynamic : @static
+  def compile_registered_endpoints!
+    endpoints.each do |endpoint|
+      compile_endpoint!(endpoint)
+    end
   end
 
-  def defined_path_is_dynamic?(path_str)
-    path_str = Rack::App::Utils.normalize_path(path_str)
-    !!(path_str.to_s =~ /\/:\w+/i) or
-        !!(path_str.to_s =~ /\/\*/i) or
-        path_str.include?(Rack::App::Constants::RACK_BASED_APPLICATION)
+  def compile_endpoint!(endpoint)
+    @tree.add(endpoint)
   end
 
 end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+class Rack::App::Router::Tree
+
+  require 'rack/app/router/tree/env'
+  require 'rack/app/router/tree/node'
+  require 'rack/app/router/tree/leaf'
+  require 'rack/app/router/tree/mounted'
+
+  def initialize
+    @root = self.class::Node.new
+  end
+
+  def add(endpoint)
+    @root.set(endpoint, *path_info_parts_by(endpoint.request_path))
+  end
+
+  def call(env)
+    self.class::Env.configure(env)
+    @root.get(env, *path_info_parts_by(env[Rack::App::Constants::ENV::FORMATTED_PATH_INFO]))
+  end
+
+  protected
+
+  def request_methods(endpoint)
+    case endpoint.request_method
+    when ::Rack::App::Constants::HTTP::METHOD::ANY
+      ::Rack::App::Constants::HTTP::METHODS.each{|m| yield(m) }
+    else
+      yield(endpoint.request_method)
+    end
+  end
+
+  def cluster(request_method)
+    @methods[request_method.to_s.upcase] ||= Rack::App::Router::Tree::Node.new
+  end
+
+  def path_info_parts_by(path_info)
+    Rack::App::Utils.split_path_info(Rack::App::Utils.normalize_path(path_info))
+  end
+end

data/lib/rack/app/router/tree/env.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module Rack::App::Router::Tree::Env
+  extend(self)
+
+  E = Rack::App::Constants::ENV
+
+  def configure(env)
+    env[E::PATH_PARAMS] ||= {}
+    env[E::FORMATTED_PATH_INFO] = Rack::App::Utils.normalize_path(env[E::PATH_INFO])
+    env[E::EXTNAME] = File.extname(Rack::App::Utils.split_path_info(env[E::FORMATTED_PATH_INFO]).last)
+    env[E::FORMATTED_PATH_INFO].slice!(/#{Regexp.escape(env[E::EXTNAME])}$/)
+  end
+end

data/lib/rack/app/router/tree/leaf.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+class Rack::App::Router::Tree::Leaf < ::Hash
+  require 'rack/app/router/tree/leaf/vein'
+
+  def get(env)
+    vein = vein_by(env)
+    vein && vein.get(env)
+  end
+
+  def set(endpoint)
+    endpoint.request_methods.each do |request_method|
+      vein_for(request_method).set(endpoint)
+    end
+  end
+
+  def struct
+    hash = {}
+    self.each do |request_method, vein|
+      hash[request_method] = vein.struct
+    end
+    hash
+  end
+
+  protected
+
+  def vein_by(env)
+    self[env[Rack::App::Constants::ENV::REQUEST_METHOD].to_sym]
+  end
+
+  def vein_for(request_method)
+    self[request_method] ||= Rack::App::Router::Tree::Leaf::Vein.new
+  end
+
+end

data/lib/rack/app/router/tree/leaf/vein.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+class Rack::App::Router::Tree::Leaf::Vein < ::Hash
+
+  E = Rack::App::Constants::ENV
+
+  def set(endpoint)
+    app = endpoint.to_app
+    endpoint.config.serializer.extnames.each do |extname|
+      self[extname] = app
+    end
+    self[extname_for(endpoint)] = app
+  end
+
+  def get(env)
+    app = self[env[E::EXTNAME]]
+    app && app.call(env)
+  end
+
+  def struct
+    self.reduce({}) do |hash, (extname, app)|
+      hash[extname]= :app
+      hash
+    end
+  end
+
+  protected
+
+  def extname_for(endpoint)
+    File.extname(Rack::App::Utils.split_path_info(endpoint.request_path).last)
+  end
+end

data/lib/rack/app/router/tree/mounted.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+class Rack::App::Router::Tree::Mounted
+
+  require 'rack/app/router/tree/mounted/application'
+
+  def get(env)
+    @app.call(env)
+  end
+
+  protected
+
+  def initialize(endpoint)
+    @app = endpoint.to_app
+  end
+
+end

data/lib/rack/app/router/tree/mounted/application.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+class Rack::App::Router::Tree::Mounted::Application < Rack::App::Router::Tree::Mounted
+  protected
+
+  def initialize(endpoint)
+    @app = build(endpoint)
+  end
+
+  def build(endpoint)
+    builder = Rack::Builder.new
+    builder.use(Rack::App::Middlewares::PathInfoCutter, mount_path(endpoint))
+    builder.run(endpoint.to_app)
+    builder.to_app
+  end
+
+  def mount_path(endpoint)
+    mount_path_parts = (endpoint.request_path.split('/') - [Rack::App::Constants::RACK_BASED_APPLICATION, ''])
+    mount_path_parts.empty? ? '' : Rack::App::Utils.join(mount_path_parts)
+  end
+end

data/lib/rack/app/router/tree/node.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+class Rack::App::Router::Tree::Node < ::Hash
+
+  PARAM = :PARAM
+
+  def set(endpoint, current=nil, *path_info_parts)
+    case type(current)
+    when :NODE
+      node_for(save_key(current)).set(endpoint, *path_info_parts)
+    when :LEAF
+      save_to_leaf(endpoint)
+    when :RACK_BASED_APPLICATION
+      attach(:RACK_BASED_APPLICATION, Rack::App::Router::Tree::Mounted::Application.new(endpoint))
+    when :MOUNTED
+      attach(:MOUNT, Rack::App::Router::Tree::Mounted.new(endpoint))
+    else
+      raise('UNKNOWN')
+    end
+  end
+
+  def get(env, current=nil, *path_info_parts)
+    return app_for(env) if current.nil?
+    node = next_node(env, current)
+    (node && node.get(env, *path_info_parts)) || mounted(env)
+  end
+
+  def struct
+    self.reduce({}) do |hash, (k,v)|
+      if k == PARAM
+        hash[k] = v
+      else
+        hash[k] = v.struct
+      end
+      hash
+    end
+  end
+
+  protected
+
+  def app_for(env)
+    app = self[:LEAF] || mounted_app
+    app && app.get(env)
+  end
+
+  def mounted(env)
+    mounted_app && mounted_app.get(env)
+  end
+
+  def mounted_app
+    self[:MOUNT] || self[:RACK_BASED_APPLICATION]
+  end
+
+  def attach(key, app_or_endpoint)
+    self[key.to_sym] = app_or_endpoint
+  end
+
+  def save_to_leaf(endpoint)
+    self[:LEAF] ||= Rack::App::Router::Tree::Leaf.new
+    self[:LEAF].set(endpoint)
+  end
+
+  def next_node(env, current)
+    self[current] || any_path(env, current)
+  end
+
+  def any_path(env, current)
+    if self[:ANY]
+      env[Rack::App::Constants::ENV::PATH_PARAMS][self[PARAM]] = current
+      self[:ANY]
+    end
+  end
+
+  def node_for(key)
+    self[key] ||= self.class.new
+  end
+
+  def type(current)
+    case current
+    when Rack::App::Constants::RACK_BASED_APPLICATION
+      :RACK_BASED_APPLICATION
+    when '**','*'
+      :MOUNTED
+    when NilClass
+      :LEAF
+    else
+      :NODE
+    end
+  end
+
+  def save_key(path)
+    case path
+    when /^:\w+$/i
+      self[PARAM] = path.sub(/^:/, '')
+      :ANY
+    else
+      extnameless(path)
+    end
+  end
+
+  def extnameless(path)
+    path.sub(/\.\w+$/,'')
+  end
+
+end

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

@@ -54,7 +54,10 @@ module Rack::App::SingletonMethods::Mounting
 
     endpoint = Rack::App::Endpoint.new(
       route_registration_properties.merge(
-        :request_method => 'GET',
+        :request_methods => [
+          Rack::App::Constants::HTTP::METHOD::GET,
+          Rack::App::Constants::HTTP::METHOD::OPTIONS
+        ],
         :request_path => request_path,
         :application => file_server
       )
@@ -66,34 +69,17 @@ module Rack::App::SingletonMethods::Mounting
   end
 
   def mount_rack_interface_compatible_application(rack_based_app, options={})
-    router.register_endpoint!(
-      Rack::App::Endpoint.new(
-        route_registration_properties.merge(
-          :request_method => ::Rack::App::Constants::HTTP::METHOD::ANY,
+    properties = route_registration_properties.merge(
+          :request_methods => ::Rack::App::Constants::HTTP::METHOD::ANY,
           :request_path => Rack::App::Utils.join(
             @namespaces,
             options[:to],
             ::Rack::App::Constants::RACK_BASED_APPLICATION
           ),
           :application => rack_based_app
-        )
-      )
     )
-  end
-
-  alias mount_rack_based_application mount_rack_interface_compatible_application
-  Rack::App::Utils.deprecate(self,:mount_rack_based_application, "mount or mount_rack_interface_compatible_application", 2016,9)
-  alias mount_app mount_rack_interface_compatible_application
-  Rack::App::Utils.deprecate(self,:mount_app, "mount or mount_rack_interface_compatible_application", 2016,9)
 
-  protected
-
-  def on_mounted(&block)
-    @on_mounted ||= []
-    @on_mounted << block unless block.nil?
-    @on_mounted
+    router.register_endpoint!(Rack::App::Endpoint.new(properties))
   end
 
-  alias while_being_mounted on_mounted
-
 end

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

@@ -28,7 +28,7 @@ module Rack::App::SingletonMethods::RouteHandling
         :payload => payload,
         :error_handler => error,
         :user_defined_logic => block,
-        :request_method => request_method,
+        :request_methods => [request_method],
         :route => route_registration_properties.dup,
         :middleware_builders_blocks => next_endpoint_middlewares.dup,
         :request_path => ::Rack::App::Utils.join(@namespaces, request_path)

data/lib/rack/app/utils.rb

@@ -22,6 +22,10 @@ module Rack::App::Utils
     path
   end
 
+  def split_path_info(path_info)
+    path_info.to_s.split('/').tap { |a| a.empty? && a.push('') }
+  end
+
   def snake_case(camel_cased_word)
     word = camel_cased_word.to_s.gsub('::', '/')
     word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')

data/spike/tree.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+rack_api_lib_folder = File.join(File.dirname(__FILE__), '..', 'lib')
+$LOAD_PATH.unshift(rack_api_lib_folder)
+require 'rack/app'
+require 'pp'
+
+tree = Rack::App::Router::Tree.new
+
+APP = Class.new(Rack::App)
+
+payload = Rack::App::Payload::Builder.new
+
+payload.parser_builder do
+  accept :json
+end
+
+serializer = Rack::App::Serializer::FormatsBuilder.new
+serializer.instance_exec do
+    on '.json', 'application/json' do |obj|
+        JSON.dump(obj)
+    end
+end
+
+endpoint = Rack::App::Endpoint.new(
+  :route => {},
+  :app_class => APP,
+  :request_methods => ["GET"],
+  :request_path => '/hello/world/:id',
+  :middleware_builders_blocks => [],
+  :user_defined_logic => proc{ "hy" },
+  :serializer_builder => serializer,
+  :payload => payload,
+  :error_handler => Rack::App::ErrorHandler.new,
+)
+
+
+properties = {
+    :request_methods => ::Rack::App::Constants::HTTP::METHODS,
+    :request_path => Rack::App::Utils.join("hello", ::Rack::App::Constants::RACK_BASED_APPLICATION),
+    :application => proc{|env| Rack::Response.new.finish }
+}
+
+tree.add(Rack::App::Endpoint.new(properties))
+
+endpoint = Rack::App::Endpoint.new(
+  :route => {},
+  :app_class => APP,
+  :request_methods => ["GET"],
+  :request_path => '/hello/world/:id',
+  :middleware_builders_blocks => [],
+  :user_defined_logic => proc{ "hy" },
+  :serializer_builder => serializer,
+  :payload => payload,
+  :error_handler => Rack::App::ErrorHandler.new,
+)
+
+tree.add(endpoint)
+pp tree
+
+require 'rack'
+puts
+
+[
+    "/hello/world/123.json",
+    "/hello/world/123",
+    "/hello/world",
+].each do |path_info|
+    env = Rack::MockRequest.env_for(path_info, :method => 'GET')
+    resp = tree.call(env)
+
+    puts(path_info)
+    p resp.is_a?(Array) && resp.length == 3
+    puts
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-app
 version: !ruby/object:Gem::Version
-  version: 5.10.2
+  version: 5.11.0
 platform: ruby
 authors:
 - Adam Luzsi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-24 00:00:00.000000000 Z
+date: 2017-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -124,7 +124,6 @@ files:
 - lib/rack/app/logger.rb
 - lib/rack/app/middlewares.rb
 - lib/rack/app/middlewares/configuration.rb
-- lib/rack/app/middlewares/configuration/path_params_matcher.rb
 - lib/rack/app/middlewares/header_setter.rb
 - lib/rack/app/middlewares/hooks.rb
 - lib/rack/app/middlewares/hooks/after.rb
@@ -149,10 +148,13 @@ files:
 - lib/rack/app/request_stream.rb
 - lib/rack/app/router.rb
 - lib/rack/app/router/base.rb
-- lib/rack/app/router/dynamic.rb
-- lib/rack/app/router/dynamic/request_path_part_placeholder.rb
-- lib/rack/app/router/not_found.rb
-- lib/rack/app/router/static.rb
+- lib/rack/app/router/tree.rb
+- lib/rack/app/router/tree/env.rb
+- lib/rack/app/router/tree/leaf.rb
+- lib/rack/app/router/tree/leaf/vein.rb
+- lib/rack/app/router/tree/mounted.rb
+- lib/rack/app/router/tree/mounted/application.rb
+- lib/rack/app/router/tree/node.rb
 - lib/rack/app/serializer.rb
 - lib/rack/app/serializer/formats_builder.rb
 - lib/rack/app/singleton_methods.rb
@@ -197,6 +199,7 @@ files:
 - spike/method_vs_instance_exec.rb
 - spike/return_vs_throw.rb
 - spike/slice_vs_sub.rb
+- spike/tree.rb
 - spike/validator_with_minitest.rb
 - spike/xml.rb
 - src/Net__HTTP Cheat Sheet.pdf

data/lib/rack/app/middlewares/configuration/path_params_matcher.rb

@@ -1,14 +0,0 @@
-class Rack::App::Middlewares::Configuration::PathParamsMatcher
-
-  def initialize(app, path_params)
-    @path_params = path_params
-    @app = app
-  end
-
-  def call(env)
-    env[::Rack::App::Constants::ENV::PATH_PARAMS_MATCHER]= @path_params.dup
-
-    @app.call(env)
-  end
-
-end

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

@@ -1,170 +0,0 @@
-class Rack::App::Router::Dynamic < Rack::App::Router::Base
-
-  require 'rack/app/router/dynamic/request_path_part_placeholder'
-  DYNAMIC_REQUEST_PATH_PART = RequestPathPartPlaceholder.new('DYNAMIC_REQUEST_PATH_PART')
-  MOUNTED_DIRECTORY = RequestPathPartPlaceholder.new('MOUNTED_DIRECTORY')
-  MOUNTED_APPLICATION = RequestPathPartPlaceholder.new('MOUNTED_APPLICATION')
-
-  protected
-
-  def initialize
-    @http_method_cluster = {}
-  end
-
-  def path_part_is_dynamic?(path_part_str)
-    !!(path_part_str.to_s =~ /^:\w+$/i)
-  end
-
-  def deep_merge!(hash, other_hash)
-    Rack::App::Utils.deep_merge(hash, other_hash)
-  end
-
-  def main_cluster(request_method)
-    (@http_method_cluster[request_method.to_s.upcase] ||= {})
-  end
-
-  def path_part_is_a_mounted_directory?(path_part)
-    path_part == Rack::App::Constants::MOUNTED_DIRECTORY
-
-    (path_part == '**' or path_part == '*')
-  end
-
-  def path_part_is_a_mounted_rack_based_application?(path_part)
-    path_part == Rack::App::Constants::RACK_BASED_APPLICATION
-  end
-
-  def clean_routes!
-    @http_method_cluster.clear
-  end
-
-  def compile_registered_endpoints!
-    endpoints.each do |endpoint|
-      compile_endpoint!(endpoint)
-    end
-  end
-
-  def compile_endpoint!(endpoint)
-    request_method = endpoint.request_method
-    request_path = endpoint.request_path
-
-    clusters_for(request_method) do |current_cluster|
-
-      break_build = false
-      path_params = {}
-      options = {}
-
-      builder = Rack::Builder.new
-      builder.use(Rack::App::Middlewares::Configuration::PathParamsMatcher, path_params)
-
-      request_path_parts = request_path.split('/')
-      request_path_parts.each.with_index do |path_part, index|
-
-        new_cluster_name = if path_part_is_dynamic?(path_part)
-                             path_params[index]= path_part.sub(/^:/, '')
-                             DYNAMIC_REQUEST_PATH_PART
-
-                           elsif path_part_is_a_mounted_directory?(path_part)
-                             break_build = true
-                             MOUNTED_DIRECTORY
-
-                           elsif path_part_is_a_mounted_rack_based_application?(path_part)
-                             break_build = true
-                             builder.use(
-                              Rack::App::Middlewares::PathInfoCutter,
-                              calculate_mount_path(request_path_parts)
-                             )
-                             MOUNTED_APPLICATION
-
-                           else
-                             path_part
-                           end
-
-        current_cluster = (current_cluster[new_cluster_name] ||= {})
-        break if break_build
-
-      end
-
-
-      builder.run(as_app(endpoint))
-      current_cluster[:app]= builder.to_app
-
-      current_cluster[:endpoint]= endpoint
-      if current_cluster[:endpoint].respond_to?(:register_path_params_matcher)
-        current_cluster[:endpoint].register_path_params_matcher(path_params)
-      end
-
-      current_cluster[:options]= options
-    end
-  end
-
-  def calculate_mount_path(request_path_parts)
-    mount_path_parts = (request_path_parts - [Rack::App::Constants::RACK_BASED_APPLICATION, ''])
-    mount_path_parts.empty? ? '' : Rack::App::Utils.join(mount_path_parts)
-  end
-
-  def clusters_for(request_method)
-    if ::Rack::App::Constants::HTTP::METHOD::ANY == request_method
-      supported_http_protocols.each do |cluster_type|
-        yield(main_cluster(cluster_type))
-      end
-    else
-      yield(main_cluster(request_method))
-    end
-  end
-
-  def supported_http_protocols
-    ::Rack::App::Constants::HTTP::METHODS
-  end
-
-  def get_app(env)
-    find_by_path_infos(env) do |path_info|
-      fetch_context(get_request_method(env), path_info)
-    end
-  end
-
-  def fetch_context(request_method, path_info)
-    current_cluster = main_cluster(request_method)
-
-    last_mounted_app = nil
-    last_mounted_directory = nil
-
-    path_parts = path_info.split('/')
-    path_parts << '' if path_parts.empty?
-    path_parts.each do |path_part|
-
-      last_mounted_directory = current_cluster[MOUNTED_DIRECTORY] || last_mounted_directory
-      last_mounted_app = current_cluster[MOUNTED_APPLICATION] || last_mounted_app
-
-      current_cluster = current_cluster[path_part] || current_cluster[DYNAMIC_REQUEST_PATH_PART]
-
-      last_mounted_directory = (current_cluster || {})[MOUNTED_DIRECTORY] || last_mounted_directory
-      last_mounted_app = (current_cluster || {})[MOUNTED_APPLICATION] || last_mounted_app
-
-      if current_cluster.nil?
-
-
-        if last_mounted_directory
-          current_cluster = last_mounted_directory
-          break
-
-        elsif last_mounted_app
-          current_cluster = last_mounted_app
-          break
-
-        else
-          return nil
-
-        end
-      end
-
-    end
-
-    return extract_app(current_cluster) || extract_app(last_mounted_app) || extract_app(last_mounted_directory)
-
-  end
-
-  def extract_app(hash)
-    hash.is_a?(Hash) ? hash[:app] : nil
-  end
-
-end

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

@@ -1,13 +0,0 @@
-class Rack::App::Router::Dynamic::RequestPathPartPlaceholder
-
-  attr_reader :name
-  def initialize(name)
-    @name = name
-    freeze
-  end
-
-  def ==(oth)
-    oth.respond_to?(:name) && oth.name == @name
-  end
-
-end

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

@@ -1,19 +0,0 @@
-require "rack/response"
-class Rack::App::Router::NotFound < Rack::App::Router::Base
-
-  protected
-
-  NOT_FOUND_APP = lambda do |env|
-    rack_response = Rack::Response.new
-    rack_response.status = 404
-    rack_response.write('404 Not Found')
-    rack_response.finish
-  end
-
-  def get_app(env)
-    NOT_FOUND_APP
-  end
-
-  def compile_registered_endpoints!
-  end
-end

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

@@ -1,32 +0,0 @@
-class Rack::App::Router::Static < Rack::App::Router::Base
-
-  protected
-
-  def get_app(env)
-    request_method= get_request_method(env)
-    find_by_path_infos(env) do |request_path|
-      mapped_endpoint_routes[[request_method, request_path]]
-    end
-  end
-
-  def mapped_endpoint_routes
-    @mapped_endpoint_routes ||= {}
-  end
-
-  def clean_routes!
-    mapped_endpoint_routes.clear
-  end
-
-  def compile_endpoint!(endpoint)
-    routing_key = [endpoint.request_method, endpoint.request_path]
-
-    mapped_endpoint_routes[routing_key]= as_app(endpoint)
-  end
-
-  def compile_registered_endpoints!
-    endpoints.each do |endpoint|
-      compile_endpoint!(endpoint)
-    end
-  end
-
-end