rack-app 5.11.0 → 5.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 070c847ed07e3494ed51e88ebf084c6eb661a30f
-  data.tar.gz: 4b836fb0a7d4c38491b4d2774b85289d528c1c56
+  metadata.gz: 4d2a02f6b4e7653fa9647f92c3aff43878fd64c2
+  data.tar.gz: e262d7601e24a4f451ffa43dcabfd1ca0bab0220
 SHA512:
-  metadata.gz: 566de7abd739139b8ac5980bcad9079995892d36c1f7213cadedd2451d62ce6ee7f41a2c23327c7174e0576b20ab1b7d71cbfab0b01a79424bb77ae63e35ade3
-  data.tar.gz: 91ac3f3615722f31dc483aa4cd4845902d8270655cb1a2e96c2fa72d78add151692ed0cc5a6304c6a5ad6f10a06d40e66c589ceb604b188b944d0fda8d18fb38
+  metadata.gz: bb38fe1f45db780873148bdf662baa41bc0cf84762204aa3be46ee8ffaa7495b6bfa707dc8a93069ee3f6509271bed3f70734491c331fa9cee5348544a12403c
+  data.tar.gz: 3177c3c9643288694a0d8ec3f51ec644cf5e9ee3a9e787e8169952b850e97df51af114dd20f3b02056fa059c02eb6bb1ca9f30d192882835febda8147eb85539

data/README.md

@@ -68,10 +68,10 @@ Yes, in fact it's already powering heroku hosted micro-services.
   * syntax sugar for default header definitions
   * namespaces for endpoint request path declarations so it can be dry and unified
 * no Class method bloat, so you can enjoy pure ruby without any surprises
-* App mounting so you can crete separated controllers for different task  
+* App mounting so you can crete separated controllers for different task
 * Streaming
-* Null time look up routing
-  * allows as many endpoint registration to you as you want, without impact on route look up speed
+* O(log(n)) lookup routing
+  * allows as many endpoint registration to you as you want, without impact on route lookup speed
 * only basic sets for instance method lvl for the must need tools, such as params, payload
 * simple to use class level response serializer
   * so you can choose what type of serialization you want without any enforced convention
@@ -100,7 +100,7 @@ Yes, in fact it's already powering heroku hosted micro-services.
 
 * **[David Bush](https://github.com/disavowd)**
 
-  * [wrote an article](https://www.sitepoint.com/rack-app-a-performant-and-pragmatic-web-microframework/) about the project
+  * [wrote an awesome article](https://www.sitepoint.com/rack-app-a-performant-and-pragmatic-web-microframework/) about the project
 
 ## [Contributing](CONTRIBUTING.md)
 
@@ -133,7 +133,7 @@ require 'rack/app'
 
 class App < Rack::App
 
-  apply_extensions :front_end  
+  apply_extensions :front_end
 
   mount SomeAppClass
 

data/VERSION

@@ -1 +1 @@
-5.11.0
+5.11.1

data/lib/rack/app/constants.rb

@@ -54,11 +54,14 @@ module Rack::App::Constants
     PATH_PARAMS = 'rack-app.path_params'.freeze
     ORIGINAL_PATH_INFO = 'rack-app.original_path_info'.freeze
     FORMATTED_PATH_INFO = 'rack-app.formatted_path_info'.freeze
+    SPLITTED_PATH_INFO = 'rack-app.splitted_path_info'.freeze
     METHODOVERRIDE_ORIGINAL_METHOD = 'rack-app.methodoverride.original_method'.freeze
 
   end
 
-  MOUNTED_DIRECTORY = '[Mounted Directory]'.freeze
-  RACK_BASED_APPLICATION = '[Mounted Rack Application]'.freeze
+  module PATH
+    MOUNT_POINT = "[MOUNT_POINT]".freeze
+    APPLICATION = "[Mounted Application]".freeze
+  end
 
 end

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

@@ -0,0 +1,35 @@
+class Rack::App::Middlewares::SetPathParams
+
+  def initialize(app, params_lookup_hash)
+    @params_lookup_hash = params_lookup_hash
+    @app = app
+  end
+
+  E = Rack::App::Constants::ENV
+
+  def call(env)
+    populate_path_params(env)
+    correct_last_value_from_extensions(env)
+    @app.call(env)
+  end
+
+  protected
+
+  def populate_path_params(env)
+    @params_lookup_hash.each do |index, key|
+      env[E::PATH_PARAMS][key] = env[E::SPLITTED_PATH_INFO][index]
+    end
+  end
+
+  def correct_last_value_from_extensions(env)
+    last_index = env[E::SPLITTED_PATH_INFO].length - 1
+    return if @params_lookup_hash[last_index].nil?
+    extless(env[E::PATH_PARAMS][@params_lookup_hash[last_index]])
+  end
+
+  def extless(value)
+    extname = File.extname(value)
+    value.slice!(/#{Regexp.escape(extname)}$/) unless extname.empty?
+  end
+
+end

data/lib/rack/app/middlewares.rb

@@ -1,5 +1,6 @@
 module Rack::App::Middlewares
   require 'rack/app/middlewares/path_info_cutter'
+  require 'rack/app/middlewares/set_path_params'
   require 'rack/app/middlewares/configuration'
   require 'rack/app/middlewares/header_setter'
   require 'rack/app/middlewares/payload'

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+class Rack::App::Router::Tree::Branch < ::Hash
+
+  def set(env)
+    if env.branch?
+      branch_for(env.save_key).set(env.next)
+    else
+      leaf.set(env)
+    end
+  end
+
+  def call(env, current, *path_info_parts)
+    if path_info_parts.empty?
+      try_leaf { |l| l.call_endpoint(env, current) || l.call_mount(env)  }
+    else
+      next_branch = self[current] || self[:ANY]
+      resp = next_branch && next_branch.call(env, *path_info_parts)
+      resp || try_leaf { |l| l.call_mount(env) }
+    end
+  end
+
+  protected
+
+  def try_leaf
+    leaf = self[:LEAF]
+    leaf && yield(leaf)
+  end
+
+  def branch_for(save_key)
+    self[save_key] ||= self.class.new
+  end
+
+  def leaf
+    self[:LEAF] ||= Rack::App::Router::Tree::Leaf.new
+  end
+
+end

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

@@ -1,13 +1,67 @@
 # frozen_string_literal: true
-module Rack::App::Router::Tree::Env
-  extend(self)
+class Rack::App::Router::Tree::Env
 
-  E = Rack::App::Constants::ENV
+  attr_reader :request_path_parts, :endpoint, :params
 
-  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])}$/)
+  def current
+    @request_path_parts[@index]
   end
+
+  def branch?
+    !clean_request_path_parts[@index..-2].empty?
+  end
+
+  def type
+    case @request_path_parts.last
+    when Rack::App::Constants::PATH::APPLICATION
+      :APPLICATION
+    when Rack::App::Constants::PATH::MOUNT_POINT
+      :MOUNT_POINT
+    else
+      :ENDPOINT
+    end
+  end
+
+  def save_key
+    if current =~ /^:\w+$/i
+      @params[@index]= current.sub(/^:/, '')
+      :ANY
+    else
+      current
+    end
+  end
+
+  def next
+    env = self.dup
+    env.inc_index!
+    env
+  end
+
+  protected
+
+  def initialize(endpoint)
+    @index = 0
+    @params = {}
+    @endpoint = endpoint
+    @request_path_parts = request_path_parts_by(endpoint).freeze
+  end
+
+  def request_path_parts_by(endpoint)
+    u = Rack::App::Utils
+    u.split_path_info(u.normalize_path(endpoint.request_path))
+  end
+
+  def inc_index!
+    @index += 1
+  end
+
+  SPECIAL_PATH_ELEMENTS = [
+    Rack::App::Constants::PATH::APPLICATION,
+    Rack::App::Constants::PATH::MOUNT_POINT
+  ].freeze
+
+  def clean_request_path_parts
+    @request_path_parts - SPECIAL_PATH_ELEMENTS
+  end
+
 end

data/lib/rack/app/router/tree/{mounted → leaf/mounted}/application.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-class Rack::App::Router::Tree::Mounted::Application < Rack::App::Router::Tree::Mounted
+class Rack::App::Router::Tree::Leaf::Mounted::Application < Rack::App::Router::Tree::Leaf::Mounted
   protected
 
   def initialize(endpoint)
@@ -14,7 +14,7 @@ class Rack::App::Router::Tree::Mounted::Application < Rack::App::Router::Tree::M
   end
 
   def mount_path(endpoint)
-    mount_path_parts = (endpoint.request_path.split('/') - [Rack::App::Constants::RACK_BASED_APPLICATION, ''])
+    mount_path_parts = (endpoint.request_path.split('/') - [Rack::App::Constants::PATH::APPLICATION, ''])
     mount_path_parts.empty? ? '' : Rack::App::Utils.join(mount_path_parts)
   end
 end

data/lib/rack/app/router/tree/{mounted.rb → leaf/mounted.rb}

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
-class Rack::App::Router::Tree::Mounted
+class Rack::App::Router::Tree::Leaf::Mounted
 
-  require 'rack/app/router/tree/mounted/application'
+  require 'rack/app/router/tree/leaf/mounted/application'
 
-  def get(env)
+  def call(env)
     @app.call(env)
   end
 

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

@@ -1,34 +1,52 @@
 # 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
+  require 'rack/app/router/tree/leaf/mounted'
+
+  E = Rack::App::Constants::ENV
 
-  def set(endpoint)
-    endpoint.request_methods.each do |request_method|
-      vein_for(request_method).set(endpoint)
+  def set(env)
+    case env.type
+    when :APPLICATION
+      self[env.type] = Rack::App::Router::Tree::Leaf::Mounted::Application.new(env.endpoint)
+    when :MOUNT_POINT
+      self[env.type] = Rack::App::Router::Tree::Leaf::Mounted.new(env.endpoint)
+    else
+      save_endpoint(env)
     end
   end
 
-  def struct
-    hash = {}
-    self.each do |request_method, vein|
-      hash[request_method] = vein.struct
-    end
-    hash
+  def call_endpoint(env, current_path)
+    app = self[current_path] || self[:ANY]
+    (app && app.call(env)) || call_mount(env)
+  end
+
+  def call_mount(env)
+    app = self[:MOUNT_POINT] || self[:APPLICATION]
+    app && app.call(env)
   end
 
   protected
 
-  def vein_by(env)
-    self[env[Rack::App::Constants::ENV::REQUEST_METHOD].to_sym]
+  def save_endpoint(env)
+    if env.save_key.is_a?(Symbol)
+      vein_for(env.save_key).set(env)
+    else
+      split_save_to_extnames(env)
+    end
   end
 
-  def vein_for(request_method)
-    self[request_method] ||= Rack::App::Router::Tree::Leaf::Vein.new
+  def split_save_to_extnames(env)
+    save_key = env.save_key
+    env.endpoint.config.serializer.extnames.each do |extname|
+      vein_for(save_key + extname).set(env)
+    end
+    vein_for(save_key).set(env)
   end
 
+  def vein_for(path_part)
+    self[path_part] ||= Rack::App::Router::Tree::Vein.new
+  end
+
+
 end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+class Rack::App::Router::Tree::Vein < ::Hash
+
+  def set(env)
+    app = create_app(env)
+    env.endpoint.request_methods.each do |request_method|
+      self[request_method.to_s.upcase] = app
+    end
+  end
+
+  def call(env)
+    app = app_by(env)
+    app && app.call(env)
+  end
+
+  protected
+
+  def app_by(env)
+    self[env[Rack::App::Constants::ENV::REQUEST_METHOD]]
+  end
+
+  def create_app(env)
+    app = env.endpoint.to_app
+    env.params.empty? ? app : wrap(app, env.params)
+  end
+
+  def wrap(app, params)
+    builder = Rack::Builder.new
+    builder.use(Rack::App::Middlewares::SetPathParams, params)
+    builder.run(app)
+    builder.to_app
+  end
+
+end

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

@@ -2,39 +2,49 @@
 class Rack::App::Router::Tree
 
   require 'rack/app/router/tree/env'
-  require 'rack/app/router/tree/node'
+
+  require 'rack/app/router/tree/branch'
   require 'rack/app/router/tree/leaf'
-  require 'rack/app/router/tree/mounted'
+  require 'rack/app/router/tree/vein'
+
+  attr_reader :root
 
   def initialize
-    @root = self.class::Node.new
+    @root = self.class::Branch.new
   end
 
   def add(endpoint)
-    @root.set(endpoint, *path_info_parts_by(endpoint.request_path))
+    @root.set(self.class::Env.new(endpoint))
   end
 
   def call(env)
-    self.class::Env.configure(env)
-    @root.get(env, *path_info_parts_by(env[Rack::App::Constants::ENV::FORMATTED_PATH_INFO]))
+    configure_request(env)
+    @root.call(env, *env[Rack::App::Constants::ENV::SPLITTED_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
+  E = Rack::App::Constants::ENV
+
+  def configure_request(env)
+    env[E::PATH_PARAMS] ||= {}
+    fpi = format_path_info(env).freeze
+    env[E::FORMATTED_PATH_INFO] = fpi
+    spi = split_path_info(fpi).freeze
+    env[E::SPLITTED_PATH_INFO] = spi
+    env[E::EXTNAME] = extname(spi)
   end
 
-  def cluster(request_method)
-    @methods[request_method.to_s.upcase] ||= Rack::App::Router::Tree::Node.new
+  def format_path_info(env)
+    Rack::App::Utils.normalize_path(env[E::PATH_INFO])
   end
 
-  def path_info_parts_by(path_info)
-    Rack::App::Utils.split_path_info(Rack::App::Utils.normalize_path(path_info))
+  def split_path_info(formatted_path_info)
+    Rack::App::Utils.split_path_info(formatted_path_info)
   end
+
+  def extname(splitted_path_info)
+    File.extname(splitted_path_info.last)
+  end
+
 end

data/lib/rack/app/router.rb

@@ -2,6 +2,8 @@ class Rack::App::Router
 
   require 'rack/app/router/tree'
 
+  attr_reader :tree
+
   NOT_FOUND_APP = lambda do |env|
     rack_response = Rack::Response.new
     rack_response.status = 404
@@ -61,7 +63,6 @@ class Rack::App::Router
 
   protected
 
-
   def initialize
     reset
   end

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

@@ -31,18 +31,14 @@ module Rack::App::SingletonMethods::Mounting
     directory_full_path = ::Rack::App::Utils.expand_path(directory_path)
 
     namespace options[:to] do
-
       Dir.glob(File.join(directory_full_path, '**', '*')).each do |file_path|
-
         request_path = file_path.sub(/^#{Regexp.escape(directory_full_path)}/, '')
         get(request_path) { serve_file(file_path) }
         options(request_path) { '' }
-
       end
-
     end
-    nil
 
+    nil
   end
 
   alias create_endpoints_for_files_in mount_directory
@@ -50,7 +46,7 @@ module Rack::App::SingletonMethods::Mounting
 
   def serve_files_from(file_path, options={})
     file_server = Rack::App::FileServer.new(Rack::App::Utils.expand_path(file_path))
-    request_path = Rack::App::Utils.join(@namespaces, options[:to], '**', '*')
+    request_path = Rack::App::Utils.join(@namespaces, options[:to], Rack::App::Constants::PATH::MOUNT_POINT)
 
     endpoint = Rack::App::Endpoint.new(
       route_registration_properties.merge(
@@ -74,7 +70,7 @@ module Rack::App::SingletonMethods::Mounting
           :request_path => Rack::App::Utils.join(
             @namespaces,
             options[:to],
-            ::Rack::App::Constants::RACK_BASED_APPLICATION
+            Rack::App::Constants::PATH::APPLICATION
           ),
           :application => rack_based_app
     )

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-app
 version: !ruby/object:Gem::Version
-  version: 5.11.0
+  version: 5.11.1
 platform: ruby
 authors:
 - Adam Luzsi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-31 00:00:00.000000000 Z
+date: 2017-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -138,6 +138,7 @@ files:
 - lib/rack/app/middlewares/path_info_cutter.rb
 - lib/rack/app/middlewares/payload.rb
 - lib/rack/app/middlewares/payload/parser_setter.rb
+- lib/rack/app/middlewares/set_path_params.rb
 - lib/rack/app/params.rb
 - lib/rack/app/payload.rb
 - lib/rack/app/payload/builder.rb
@@ -149,12 +150,12 @@ files:
 - lib/rack/app/router.rb
 - lib/rack/app/router/base.rb
 - lib/rack/app/router/tree.rb
+- lib/rack/app/router/tree/branch.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/router/tree/leaf/mounted.rb
+- lib/rack/app/router/tree/leaf/mounted/application.rb
+- lib/rack/app/router/tree/vein.rb
 - lib/rack/app/serializer.rb
 - lib/rack/app/serializer/formats_builder.rb
 - lib/rack/app/singleton_methods.rb

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

@@ -1,31 +0,0 @@
-# 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/node.rb

@@ -1,104 +0,0 @@
-# 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