rack-app 3.0.0.alpha → 3.0.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ebb99d6cbc443f59e0f17c2d1216ed44ae7d8b5f
-  data.tar.gz: cb9d4c1a858802c241c76fcc4ba48c113b06b5e9
+  metadata.gz: 115055ba41521d7fee618f4d2fe57b624471a39e
+  data.tar.gz: 40fab600f70f7b89622a40106e94323e19b40d67
 SHA512:
-  metadata.gz: 6398d60c1909301924d191e4875e81c945c8ec06cd41b3e2158a87744bd2080e1c0a3c9074a7ff6f3cdb3f7e217eefa60976a432259cb7bdfd6f48cb96d1dcae
-  data.tar.gz: bb3c51ab85a38d507f685ebe3c7d61f1936f354c0cce2d1009072fa45ca1ee488f583805f75ede3c5c3b22957abeed9a6d6adc42cb73a79ab23185608e51508e
+  metadata.gz: b8bb4760e69bc2815fc09664845dd7b172ade97d3723667c48166553bb8c994a534adbf430498e46f9f75f2e39320c6544cdb3238e6042fb1da43aef716181a5
+  data.tar.gz: 333055adc24a03df566b36065931f921000901fc3f217204397964f96c1169d7140dbf28fc1b047079ef76486fa3186cac07d972fe8b64cfd2247c659d80de67

data/.travis.yml

@@ -29,6 +29,8 @@ env:
   global:
     - VERBOSE=true
     - TIMEOUT=1
+    - BENCHMARK_QUANTITY=100000
+    - STREAM_FILE_SIZE=1024
 
 branches:
   only:

data/VERSION

@@ -1 +1 @@
-3.0.0.alpha
+3.0.0.beta

data/lib/rack/app/constants.rb

@@ -1,4 +1,19 @@
 module Rack::App::Constants
-  NORMALIZED_PATH_INFO = 'rack-app.path_info'.freeze
+
+  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
+  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
+
 end

data/lib/rack/app/params.rb

@@ -50,7 +50,7 @@ class Rack::App::Params
   end
 
   def request_path_parts
-    @request_env[::Rack::App::Constants::NORMALIZED_PATH_INFO].split('/')
+    @request_env[::Rack::PATH_INFO].split('/')
   end
 
   def path_params_matcher

data/lib/rack/app/request_configurator.rb

@@ -2,9 +2,17 @@ module Rack::App::RequestConfigurator
 
   extend self
 
-  def configure(request_env)
-    request_env[Rack::App::Constants::NORMALIZED_PATH_INFO]= Rack::App::Utils.normalize_path(request_env[::Rack::PATH_INFO])
-    request_env
+  def configure(env)
+    path_info(env)
+    env
+  end
+
+  protected
+
+  def path_info(env)
+    path_info = env[::Rack::PATH_INFO]
+    env[::Rack::App::Constants::ORIGINAL_PATH_INFO]= path_info
+    env[::Rack::PATH_INFO]= Rack::App::Utils.normalize_path(path_info)
   end
 
 end

data/lib/rack/app/router.rb

@@ -3,14 +3,24 @@ 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'
+
+  def call(env)
+    response = nil
+    registered_endpoint_routers.find do |router|
+      response = router.call(env)
+    end
+    return response
+  end
 
   def endpoints
-    (@static.endpoints + @dynamic.endpoints)
+    registered_endpoint_routers.map(&:endpoints).reduce([],:+)
   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
@@ -26,18 +36,11 @@ class Rack::App::Router
   end
 
   def register_endpoint!(request_method, request_path, description, endpoint)
-    router = defined_path_is_dynamic?(request_path) ? @dynamic : @static
+    router = router_for(request_path)
     router.register_endpoint!(request_method, request_path, description, endpoint)
   end
 
-  def fetch_endpoint(request_method, request_path)
-    @static.fetch_endpoint(request_method, request_path) or
-        @dynamic.fetch_endpoint(request_method, request_path) or
-        Rack::App::Endpoint::NOT_FOUND
-
-  end
-
-  def merge_router!(router,prop={})
+  def merge_router!(router, prop={})
     raise(ArgumentError, 'invalid router object, must implement :endpoints interface') unless router.respond_to?(:endpoints)
     router.endpoints.each do |endpoint|
       request_path = ::Rack::App::Utils.join(prop[:namespaces], endpoint[:request_path])
@@ -57,11 +60,22 @@ class Rack::App::Router
   def initialize
     @static = Rack::App::Router::Static.new
     @dynamic = Rack::App::Router::Dynamic.new
+    @not_found = Rack::App::Router::NotFound.new
+  end
+
+  def registered_endpoint_routers
+    [@static, @dynamic, @not_found]
+  end
+
+  def router_for(request_path)
+    defined_path_is_dynamic?(request_path) ? @dynamic : @static
   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)
+    !!(path_str.to_s =~ /\/:\w+/i) or
+        !!(path_str.to_s =~ /\/\*/i) or
+        path_str.include?(Rack::App::Constants::RACK_BASED_APPLICATION)
   end
 
 end

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

@@ -1,5 +1,21 @@
 class Rack::App::Router::Base
 
+  def call(env)
+
+    request_method= env[Rack::REQUEST_METHOD]
+    path_info= env[Rack::PATH_INFO]
+
+    context = fetch_context(request_method, path_info)
+    return unless context.is_a?(Hash) and not context[:endpoint].nil?
+
+    format_env(context, env)
+    context[:endpoint].call(env)
+
+  end
+
+  def format_env(context, env)
+  end
+
   def endpoints
     @endpoints ||= []
   end
@@ -7,7 +23,7 @@ class Rack::App::Router::Base
   def register_endpoint!(request_method, request_path, description, endpoint)
     endpoints.push(
         {
-            :request_method => request_method.to_s.upcase,
+            :request_method => request_method,
             :request_path => Rack::App::Utils.normalize_path(request_path),
             :description => description,
             :endpoint => endpoint
@@ -18,12 +34,12 @@ class Rack::App::Router::Base
     return endpoint
   end
 
-  def fetch_endpoint(request_method, request_path)
+  protected
+
+  def fetch_context(request_method, request_path)
     raise('IMPLEMENTATION MISSING ERROR')
   end
 
-  protected
-
   def compile_registered_endpoints!
     raise('IMPLEMENTATION MISSING ERROR')
   end

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

@@ -1,27 +1,9 @@
 class Rack::App::Router::Dynamic < Rack::App::Router::Base
 
-  PATH_PARAM = :"#{self}::PATH_PARAM".freeze
-  PARTIAL = :"#{self}::PARTIAL".freeze
-
-  def fetch_endpoint(request_method, request_path)
-    normalized_request_path = Rack::App::Utils.normalize_path(request_path)
-
-    current_cluster = main_cluster(request_method)
-    normalized_request_path.split('/').each do |path_part|
-      previous_cluster = current_cluster
-      current_cluster = current_cluster[path_part] || current_cluster[PATH_PARAM]
-      if current_cluster.nil?
-        if previous_cluster[PARTIAL]
-          current_cluster = previous_cluster[PARTIAL]
-          break
-        else
-          return nil
-        end
-      end
-    end
-
-    current_cluster[:endpoint]
-  end
+  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
 
@@ -34,66 +16,136 @@ class Rack::App::Router::Dynamic < Rack::App::Router::Base
   end
 
   def deep_merge!(hash, other_hash)
-    other_hash.each_pair do |current_key, other_value|
-
-      this_value = hash[current_key]
-
-      hash[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
-                            deep_merge!(this_value, other_value)
-                          else
-                            other_value
-                          end
-    end
-
-    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_partial?(path_part)
+  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 compile_registered_endpoints!
     @http_method_cluster.clear
     endpoints.each do |endpoint_prop|
-      compile_endpoint(endpoint_prop[:request_method],endpoint_prop[:request_path],endpoint_prop[:endpoint])
+      compile_endpoint(endpoint_prop[:request_method], endpoint_prop[:request_path], endpoint_prop[:endpoint])
     end
   end
 
   def compile_endpoint(request_method, request_path, endpoint)
+    clusters_for(request_method) do |current_cluster|
 
-    current_cluster = main_cluster(request_method)
-    path_params = {}
-    break_build = false
+      break_build = false
+      path_params = {}
+      mount_path = ''
+      options = {}
 
-    request_path.split('/').each.with_index do |path_part, index|
+      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(/^:/, '')
-                           PATH_PARAM
+        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_partial?(path_part)
-                           break_build = true
-                           PARTIAL
+                           elsif path_part_is_a_mounted_directory?(path_part)
+                             break_build = true
+                             MOUNTED_DIRECTORY
 
-                         else
-                           path_part
-                         end
+                           elsif path_part_is_a_mounted_rack_based_application?(path_part)
+                             break_build = true
+                             mount_path = calculate_mount_path(request_path_parts)
+                             MOUNTED_APPLICATION
 
-      current_cluster = (current_cluster[new_cluster_name] ||= {})
-      break if break_build
+                           else
+                             path_part
+                           end
+
+        current_cluster = (current_cluster[new_cluster_name] ||= {})
+        break if break_build
+
+      end
+
+      current_cluster[:endpoint]= endpoint
+      if current_cluster[:endpoint].respond_to?(:register_path_params_matcher)
+        current_cluster[:endpoint].register_path_params_matcher(path_params)
+      end
+
+      options[:mount_path]= mount_path
+      options[:path_params]= path_params
+      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
 
-    current_cluster[:endpoint]= endpoint
-    if current_cluster[:endpoint].respond_to?(:register_path_params_matcher)
-      current_cluster[:endpoint].register_path_params_matcher(path_params)
+  def clusters_for(request_method)
+    if ::Rack::App::Constants::HTTP::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.constants - [:ANY]).map(&:to_s)
+  end
+
+
+  def fetch_context(request_method, path_info)
+    normalized_request_path = Rack::App::Utils.normalize_path(path_info)
+
+    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
+      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 current_cluster
+
+  end
 
-    endpoint
+  def format_env(context, env)
+    mount_path = context[:options][:mount_path] rescue ''
+    env[::Rack::PATH_INFO].sub!(mount_path, '')
   end
 
 end

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

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

@@ -0,0 +1,11 @@
+class Rack::App::Router::NotFound < Rack::App::Router::Base
+
+  def fetch_context(request_method, path_info)
+    {:endpoint => ::Rack::App::Endpoint::NOT_FOUND}
+  end
+
+  def fetch_endpoint(request_method, path_info)
+    ::Rack::App::Endpoint::NOT_FOUND
+  end
+
+end

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

@@ -1,9 +1,5 @@
 class Rack::App::Router::Static < Rack::App::Router::Base
 
-  def fetch_endpoint(request_method, request_path)
-    mapped_endpoint_routes[[request_method, request_path]]
-  end
-
   def compile_registered_endpoints!
     mapped_endpoint_routes.clear
     endpoints.each do |endpoint|
@@ -14,6 +10,11 @@ class Rack::App::Router::Static < Rack::App::Router::Base
 
   protected
 
+  def fetch_context(request_method, request_path)
+    endpoint = mapped_endpoint_routes[[request_method, request_path]]
+    endpoint && {:endpoint => endpoint}
+  end
+
   def mapped_endpoint_routes
     @mapped_endpoint_routes ||= {}
   end

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

@@ -3,34 +3,37 @@ module Rack::App::SingletonMethods::HttpMethods
   protected
 
   def get(path = '/', &block)
-    add_route('GET', path, &block)
+    add_route(::Rack::App::Constants::HTTP::GET, path, &block)
   end
 
   def post(path = '/', &block)
-    add_route('POST', path, &block)
+    add_route(::Rack::App::Constants::HTTP::POST, path, &block)
   end
 
   def put(path = '/', &block)
-    add_route('PUT', path, &block)
+    add_route(::Rack::App::Constants::HTTP::PUT, path, &block)
   end
 
-  def head(path = '/', &block)
-    add_route('HEAD', path, &block)
+  def delete(path = '/', &block)
+    add_route(::Rack::App::Constants::HTTP::DELETE, path, &block)
   end
 
-  def delete(path = '/', &block)
-    add_route('DELETE', path, &block)
+  def head(path = '/', &block)
+    add_route(::Rack::App::Constants::HTTP::HEAD, path, &block)
   end
 
   def options(path = '/', &block)
-    add_route('OPTIONS', path, &block)
+    add_route(::Rack::App::Constants::HTTP::OPTIONS, path, &block)
   end
 
   def patch(path = '/', &block)
-    add_route('PATCH', path, &block)
+    add_route(::Rack::App::Constants::HTTP::PATCH, path, &block)
   end
 
   def alias_endpoint(new_request_path, original_request_path)
+    new_request_path = Rack::App::Utils.normalize_path(new_request_path)
+    original_request_path = Rack::App::Utils.normalize_path(original_request_path)
+
     router.endpoints.select { |ep| ep[:request_path] == original_request_path }.each do |endpoint|
       router.register_endpoint!(endpoint[:request_method], new_request_path, endpoint[:description], endpoint[:endpoint])
     end

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

@@ -47,6 +47,18 @@ module Rack::App::SingletonMethods::Mounting
     @last_description = nil
   end
 
+  def mount_rack_based_application(rack_based_app, options={})
+    router.register_endpoint!(
+        ::Rack::App::Constants::HTTP::ANY,
+        Rack::App::Utils.join(@namespaces, options[:to], ::Rack::App::Constants::RACK_BASED_APPLICATION),
+        @last_description,
+        rack_based_app)
+
+    @last_description = nil
+  end
+
+  alias mount_app mount_rack_based_application
+
   protected
 
   def on_mounted(&block)

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

@@ -2,12 +2,9 @@ module Rack::App::SingletonMethods::RackInterface
 
   public
 
-  def call(request_env)
-    Rack::App::RequestConfigurator.configure(request_env)
-    endpoint = router.fetch_endpoint(
-        request_env[::Rack::REQUEST_METHOD],
-        request_env[Rack::App::Constants::NORMALIZED_PATH_INFO])
-    endpoint.call(request_env)
+  def call(env)
+    Rack::App::RequestConfigurator.configure(env)
+    return router.call(env)
   end
 
 end

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

@@ -7,11 +7,7 @@ module Rack::App::SingletonMethods::RouteHandling
   protected
 
   def root(endpoint_path)
-    %W[GET POST PUT DELETE OPTIONS PATCH HEAD].each do |request_method|
-      endpoint = router.fetch_endpoint(request_method, endpoint_path)
-      next if endpoint == Rack::App::Endpoint::NOT_FOUND
-      router.register_endpoint!(request_method, '/', 'Root endpoint', endpoint)
-    end
+    alias_endpoint '/', endpoint_path
   end
 
   def description(*description_texts)

data/lib/rack/app/test.rb

@@ -11,7 +11,7 @@ module Rack::App::Test
 
   attr_reader :last_response
 
-  [:get, :post, :put, :delete, :options, :patch].each do |request_method|
+  [:get, :post, :put, :delete, :options, :patch, :head].each do |request_method|
     define_method(request_method) do |*args|
 
       properties = args.select { |e| e.is_a?(Hash) }.reduce({}, &:merge!)
@@ -24,4 +24,12 @@ module Rack::App::Test
     end
   end
 
+  def rack_app(&block)
+    app_class = defined?(__rack_app_class__) ? __rack_app_class__ : nil
+    constructors = []
+    constructors << __rack_app_constructor__ if defined?(__rack_app_constructor__) and __rack_app_constructor__.is_a?(Proc)
+    constructors << block unless block.nil?
+    Rack::App::Test::Utils.rack_app_by(app_class, constructors)
+  end
+
 end

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

@@ -1,15 +1,15 @@
 module Rack::App::Test::SingletonMethods
 
-  def rack_app(*args, &constructor)
-
-    begin
-      let(:rack_app) { Rack::App::Test::Utils.rack_app_by(*args, &constructor) }
-    rescue NoMethodError
-      define_method(:rack_app) do
-        rack_app_by(*args, &constructor)
-      end
-    end
+  def rack_app(rack_app_class=nil, &constructor)
+    in_this_context(:__rack_app_class__) { rack_app_class }
+    in_this_context(:__rack_app_constructor__) { constructor }
+    nil
+  end
 
+  def in_this_context(name, &block)
+    let(name, &block)
+  rescue NoMethodError
+    define_method(name, &block)
   end
 
 end

data/lib/rack/app/test/utils.rb

@@ -10,16 +10,14 @@ module Rack::App::Test::Utils
     properties
   end
 
-  def rack_app_by(*args, &constructor)
+  def rack_app_by(rack_app_class, constructors)
     subject_app = nil
 
-    rack_app_class = args.shift
-
-    if constructor.nil?
+    if constructors.empty?
       subject_app = rack_app_class
     else
       subject_app = Class.new(rack_app_class || ::Rack::App)
-      subject_app.class_eval(&constructor)
+      constructors.each { |constructor| subject_app.class_eval(&constructor) }
     end
 
     subject_app

data/lib/rack/app/utils.rb

@@ -51,7 +51,7 @@ module Rack::App::Utils
   end
 
   def join(*url_path_parts)
-    url_path_parts = [url_path_parts].flatten.compact
+    url_path_parts = [url_path_parts].flatten.compact.map(&:to_s)
     File.join(*url_path_parts).gsub(File::Separator, '/').sub(/^\/?(.*)$/, '/\1')
   end
 
@@ -82,4 +82,19 @@ module Rack::App::Utils
     ::Rack::App::Utils::DeepDup.new(object).to_dup
   end
 
+  def deep_merge(hash,oth_hash)
+    oth_hash.each_pair do |current_key, other_value|
+
+      this_value = hash[current_key]
+
+      hash[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
+                            deep_merge(this_value, other_value)
+                          else
+                            other_value
+                          end
+    end
+
+    hash
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-app
 version: !ruby/object:Gem::Version
-  version: 3.0.0.alpha
+  version: 3.0.0.beta
 platform: ruby
 authors:
 - Adam Luzsi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-26 00:00:00.000000000 Z
+date: 2016-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -103,6 +103,8 @@ files:
 - 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/serializer.rb
 - lib/rack/app/singleton_methods.rb