rack-app 5.4.0 → 5.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6dd2f46b2f007bef6e687579c333ebad1d77ac65
-  data.tar.gz: 0a216bf4a522cd5b6ed17385a09137101812e1e4
+  metadata.gz: b4b3d25d410555551a8d81c6be4c797cb28d9a2b
+  data.tar.gz: 6b4c65de92a11cfcf01d7a613674797e855a0ffa
 SHA512:
-  metadata.gz: 21e7fa7810f21fd7f0336728633aa7cd18a18525d0bfd458103037ffdac57e0abb1cfc3d50f9e85801efb79b23aed43ee120cb164370f0e74a43f0f1d4b4cc3f
-  data.tar.gz: acc7507fa92edeefae60d910ee0be289eb649899dcf088bbff149875640b3b07f26e5679ed5ec7bc969f24394f1087f6f8e1fc6fbf02ce4cdf1b511249864fb4
+  metadata.gz: d84f255799c2c240f6245732a2ae00701c25584bb9eb37797206bbc88a2b69f3584d5ca441638699d7e5c33e090f24f2d3b84ebc564a170e85f420fd917a8386
+  data.tar.gz: 1a0db3ae2452a57f87c11f02613f8491b3659131d2af2d61ac41f1ec7ab0d0eb0599ffdb510fac27188c91f5b220f214dab0754386a72690d5591b338eac1363

data/VERSION

@@ -1 +1 @@
-5.4.0
+5.5.1

data/lib/rack/app/constants.rb

@@ -1,5 +1,11 @@
 module Rack::App::Constants
 
+  def self.rack_constant(constant_name, fallback_value)
+    ::Rack.const_get(constant_name)
+  rescue NameError
+    fallback_value.freeze
+  end
+
   module HTTP
 
     module METHOD
@@ -18,13 +24,19 @@ module Rack::App::Constants
 
     METHODS = (METHOD.constants - [:ANY]).map(&:to_s).freeze
 
+    module Headers
+      CONTENT_TYPE = Rack::App::Constants.rack_constant(:CONTENT_TYPE, "Content-Type")
+    end
+
   end
 
   module ENV
-    PATH_INFO =      (defined?(::Rack::PATH_INFO)      ? ::Rack::PATH_INFO      : "PATH_INFO".freeze)
-    REQUEST_METHOD = (defined?(::Rack::REQUEST_METHOD) ? ::Rack::REQUEST_METHOD : "REQUEST_METHOD".freeze)
-    REQUEST_PATH =   (defined?(::Rack::REQUEST_PATH)   ? ::Rack::REQUEST_PATH   : "REQUEST_PATH".freeze)
 
+    PATH_INFO = Rack::App::Constants.rack_constant(:PATH_INFO, "PATH_INFO")
+    REQUEST_PATH = Rack::App::Constants.rack_constant(:REQUEST_PATH, "REQUEST_PATH")
+    REQUEST_METHOD = Rack::App::Constants.rack_constant(:REQUEST_METHOD, "REQUEST_METHOD")
+
+    EXTNAME = 'rack-app.extname'.freeze
     REQUEST_HANDLER = 'rack-app.handler'
     SERIALIZER = 'rack-app.serializer'
     PARSED_PARAMS = 'rack-app.parsed_params'

data/lib/rack/app/endpoint.rb

@@ -26,6 +26,10 @@ 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/builder.rb

@@ -19,7 +19,7 @@ class Rack::App::Endpoint::Builder
     builder_blocks.each do |builder_block|
       builder_block.call(builder)
     end
-    builder.use(Rack::App::Middlewares::Configuration, @config.to_hash)
+    builder.use(Rack::App::Middlewares::Configuration, @config)
     apply_hook_middlewares(builder)
   end
 

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

@@ -1,7 +1,6 @@
 class Rack::App::Endpoint::Config
 
   def to_hash
-    serializer
     error_handler
     middleware_builders_blocks
     request_path
@@ -18,7 +17,11 @@ class Rack::App::Endpoint::Config
   end
 
   def serializer
-    @raw[:serializer] ||= Rack::App::Serializer.new
+    serializer_builder.to_serializer
+  end
+
+  def serializer_builder
+    @raw[:serializer_builder] ||= app_class.__send__(:formats)
   end
 
   def error_handler

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

@@ -12,7 +12,7 @@ class Rack::App::Endpoint::Executor
 
   def execute(env)
     request_handler = env[Rack::App::Constants::ENV::REQUEST_HANDLER]
-    set_response_body(request_handler.response, get_response_body(request_handler))
+    set_response_body(request_handler, get_response_body(request_handler))
     return request_handler.response
   end
 
@@ -24,8 +24,13 @@ class Rack::App::Endpoint::Executor
     end
   end
 
-  def set_response_body(response, response_body)
-    response.write(String(@endpoint_properties.serializer.serialize(response_body)))
+  EXTNAME = ::Rack::App::Constants::ENV::EXTNAME
+  CONTENT_TYPE = ::Rack::App::Constants::HTTP::Headers::CONTENT_TYPE
+
+  def set_response_body(handler, response_body)
+    extname = handler.request.env[EXTNAME]
+    handler.response.headers.merge!(@endpoint_properties.serializer.response_headers_for(extname))
+    handler.response.write(@endpoint_properties.serializer.serialize(extname, response_body))
   end
 
   def evaluate_value(request_handler)
@@ -34,5 +39,4 @@ class Rack::App::Endpoint::Executor
     end
   end
 
-
 end

data/lib/rack/app/middlewares.rb

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

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

@@ -1,29 +1,34 @@
+require "rack/builder"
 require "rack/request"
 require "rack/response"
 class Rack::App::Middlewares::Configuration
 
-  require "rack/app/middlewares/configuration/path_info_formatter"
+  require "rack/app/middlewares/configuration/handler_setter"
+  require "rack/app/middlewares/configuration/serializer_setter"
+
   require "rack/app/middlewares/configuration/path_params_matcher"
 
-  def initialize(app, options={})
-    @handler_class = options[:app_class] || raise
-    @serializer = options[:serializer] || raise
-    @app = app
+  def initialize(app, config)
+    @stack = build_stack(app) do |builder|
+      builder.use Rack::App::Middlewares::Configuration::SerializerSetter,
+                  config.serializer
+
+      builder.use Rack::App::Middlewares::Configuration::HandlerSetter,
+                  config.app_class
+
+    end
   end
 
   def call(env)
-    env[Rack::App::Constants::ENV::SERIALIZER]= @serializer
-    env[Rack::App::Constants::ENV::REQUEST_HANDLER]= handler(env)
-    @app.call(env)
+    @stack.call(env)
   end
 
   protected
 
-  def handler(env)
-    new_handler = @handler_class.new
-    new_handler.request = ::Rack::Request.new(env)
-    new_handler.response = ::Rack::Response.new
-    new_handler
+  def build_stack(app)
+    builder = Rack::Builder.new
+    yield(builder)
+    builder.run(app)
+    return builder.to_app
   end
-
 end

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

@@ -0,0 +1,22 @@
+class Rack::App::Middlewares::Configuration::HandlerSetter
+
+  def initialize(app, handler_class)
+    @app = app
+    @handler_class = handler_class || raise
+  end
+
+  def call(env)
+    env[Rack::App::Constants::ENV::REQUEST_HANDLER]= handler(env)
+    @app.call(env)
+  end
+
+  protected
+
+  def handler(env)
+    new_handler = @handler_class.new
+    new_handler.request = ::Rack::Request.new(env)
+    new_handler.response = ::Rack::Response.new
+    new_handler
+  end
+
+end

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

@@ -0,0 +1,21 @@
+class Rack::App::Middlewares::Configuration::SerializerSetter
+
+  def initialize(app, serializer)
+    @app = app
+    @serializer = serializer || raise
+  end
+
+  def call(env)
+    # env[::Rack::App::Constants::ENV::EXTNAME] ||= extname(env)
+    env[::Rack::App::Constants::ENV::SERIALIZER]= @serializer
+    @app.call(env)
+  end
+
+  protected
+
+  def extname(env)
+    path_info = env[::Rack::App::Constants::ENV::PATH_INFO]
+    File.extname(path_info.split("/").last.to_s)
+  end
+
+end

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

@@ -0,0 +1,15 @@
+class Rack::App::Middlewares::PathInfoCutter
+
+  def initialize(app, cut_string_from_path)
+    @cut_string_from_path = cut_string_from_path
+    @app = app
+  end
+
+  def call(env)
+    #env[::Rack::App::Constants::ENV::ORIGINAL_PATH_INFO]= env[::Rack::App::Constants::ENV::PATH_INFO]
+    env[::Rack::App::Constants::ENV::PATH_INFO]= env[::Rack::App::Constants::ENV::PATH_INFO].dup
+    env[::Rack::App::Constants::ENV::PATH_INFO].sub!(@cut_string_from_path, '')
+    @app.call(env)
+  end
+
+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::ENV::PARSED_PARAMS]
-      @request_env[::Rack::App::Constants::ENV::PARSED_PARAMS]
+    if @env[::Rack::App::Constants::ENV::PARSED_PARAMS]
+      @env[::Rack::App::Constants::ENV::PARSED_PARAMS]
     else
       query_params.merge(request_path_params)
     end
@@ -11,24 +11,21 @@ class Rack::App::Params
 
   protected
 
-  def initialize(request_env)
-    @request_env = request_env
+  def initialize(env)
+    @env = env
   end
 
   def query_params
     raw_cgi_params.reduce({}) do |params_collection, (k, v)|
+      stripped_key = k.sub(/\[\]$/, '')
 
-      if single_paramter_value?(v)
-        params_collection[k]= v[0]
-
+      if single_paramter_value?(v) && !k.end_with?("[]")
+        params_collection[stripped_key]= v[0]
       else
-        k = k.sub(/\[\]$/, '')
-        params_collection[k]= v
-
+        params_collection[stripped_key]= v
       end
 
       params_collection
-
     end
   end
 
@@ -37,7 +34,7 @@ class Rack::App::Params
   end
 
   def raw_cgi_params
-    CGI.parse(@request_env[::Rack::QUERY_STRING].to_s)
+    CGI.parse(@env[::Rack::QUERY_STRING].to_s)
   end
 
   def request_path_params
@@ -47,18 +44,26 @@ class Rack::App::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)|
-      params_col[path_params_matcher[index]]= path_part if path_params_matcher[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
-    @request_env[::Rack::App::Constants::ENV::PATH_INFO].split('/')
+    @env[::Rack::App::Constants::ENV::PATH_INFO].split('/')
   end
 
   def path_params_matcher
-    @request_env[::Rack::App::Constants::ENV::PATH_PARAMS_MATCHER] || {}
+    @env[::Rack::App::Constants::ENV::PATH_PARAMS_MATCHER] || {}
   end
 
 end

data/lib/rack/app/request_configurator.rb

@@ -3,16 +3,26 @@ module Rack::App::RequestConfigurator
   extend self
 
   def configure(env)
-    path_info(env)
-    env
+    set_path_info(env)
+    set_extname(env)
   end
 
   protected
 
-  def path_info(env)
-    path_info = env[::Rack::App::Constants::ENV::PATH_INFO]
-    env[::Rack::App::Constants::ENV::ORIGINAL_PATH_INFO]= path_info
-    env[::Rack::App::Constants::ENV::PATH_INFO]= Rack::App::Utils.normalize_path(path_info)
+  EXTNAME = ::Rack::App::Constants::ENV::EXTNAME
+  PATH_INFO = ::Rack::App::Constants::ENV::PATH_INFO
+  ORIGINAL_PATH_INFO = ::Rack::App::Constants::ENV::ORIGINAL_PATH_INFO
+
+  def set_path_info(env)
+    path_info = env[PATH_INFO]
+    env[ORIGINAL_PATH_INFO]= path_info.dup
+    env[PATH_INFO]= Rack::App::Utils.normalize_path(path_info)
+  end
+
+  def set_extname(env)
+    path_info = env[PATH_INFO]
+    basename = path_info.split("/").last.to_s
+    env[EXTNAME]= File.extname(basename)
   end
 
-end
+end

data/lib/rack/app/router.rb

@@ -6,6 +6,7 @@ class Rack::App::Router
   require 'rack/app/router/not_found'
 
   def call(env)
+    Rack::App::RequestConfigurator.configure(env)
     @static.call(env) or @dynamic.call(env) or @not_found.call(env)
   end
 

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

@@ -1,17 +1,10 @@
 class Rack::App::Router::Base
 
   def call(env)
-
-    request_method= env[::Rack::App::Constants::ENV::REQUEST_METHOD]
-    path_info= env[Rack::App::Constants::ENV::PATH_INFO]
-
-    context = fetch_context(request_method, path_info)
-    return unless context.is_a?(Hash) and not context[:app].nil?
-
-    context[:app].call(env)
+    app = get_app(env)
+    app && app.call(env)
   end
 
-
   def endpoints
     @endpoints ||= []
   end
@@ -29,6 +22,10 @@ class Rack::App::Router::Base
 
   protected
 
+  def get_app(env)
+    raise(NotImplementedError)
+  end
+
   def compile_endpoint!(endpoint)
     raise(NotImplementedError)
   end
@@ -53,4 +50,26 @@ class Rack::App::Router::Base
     end
   end
 
+  def find_by_path_infos(env, &block)
+    block.call(raw_path_info(env)) || block.call(formatted_path_info(env))
+  end
+
+  def get_request_method(env)
+    env[::Rack::App::Constants::ENV::REQUEST_METHOD]
+  end
+
+  def raw_path_info(env)
+    env[::Rack::App::Constants::ENV::PATH_INFO]
+  end
+
+  def formatted_path_info(env)
+    path_info = raw_path_info(env).dup
+    path_info.slice!(/#{Regexp.escape(extname(env))}$/)
+    path_info
+  end
+
+  def extname(env)
+    env[::Rack::App::Constants::ENV::EXTNAME]
+  end
+
 end

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

@@ -70,7 +70,7 @@ class Rack::App::Router::Dynamic < Rack::App::Router::Base
                            elsif path_part_is_a_mounted_rack_based_application?(path_part)
                              break_build = true
                              builder.use(
-                              Rack::App::Middlewares::Configuration::PathInfoFormatter,
+                              Rack::App::Middlewares::PathInfoCutter,
                               calculate_mount_path(request_path_parts)
                              )
                              MOUNTED_APPLICATION
@@ -116,14 +116,25 @@ class Rack::App::Router::Dynamic < Rack::App::Router::Base
     ::Rack::App::Constants::HTTP::METHODS
   end
 
+  def get_app(env)
+    find_by_path_infos(env) do |path_info|
+      c = fetch_context(get_request_method(env), path_info)
+
+      if c.is_a?(Hash)
+        c[:app]
+      else
+        nil
+      end
+    end
+  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|
+    
+    path_info.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

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

@@ -1,23 +1,19 @@
 require "rack/response"
 class Rack::App::Router::NotFound < Rack::App::Router::Base
 
-  def fetch_context(request_method, path_info)
-    {:app => lambda{|env| not_found_response }}
-  end
-
-  def fetch_endpoint(request_method, path_info)
-    ::Rack::App::Endpoint::NOT_FOUND
-  end
-
   protected
 
-  def not_found_response
+  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

@@ -2,9 +2,11 @@ class Rack::App::Router::Static < Rack::App::Router::Base
 
   protected
 
-  def fetch_context(request_method, request_path)
-    app = mapped_endpoint_routes[[request_method, request_path]]
-    app && {:app => app}
+  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
@@ -17,6 +19,7 @@ class Rack::App::Router::Static < Rack::App::Router::Base
 
   def compile_endpoint!(endpoint)
     routing_key = [endpoint.request_method, endpoint.request_path]
+
     mapped_endpoint_routes[routing_key]= as_app(endpoint)
   end
 

data/lib/rack/app/serializer.rb

@@ -1,13 +1,56 @@
 class Rack::App::Serializer
 
-  attr_reader :logic
+  require "rack/app/serializer/formats_builder"
 
-  def initialize(&block)
-    @logic = block || lambda { |o| o.to_s }
+  def initialize(options={})
+
+    @default_formatter = options[:default_formatter] || lambda { |o| o.to_s }
+    @default_content_type = options[:default_content_type]
+
+    formatters = options[:formatters] || {}
+    content_types = options[:content_types] || {}
+
+    @content_types = Hash.new(@default_content_type)
+    @content_types.merge!(content_types)
+
+    @formatters = Hash.new(@default_formatter)
+    @formatters.merge!(formatters)
+
+  end
+
+  def serialize(extname, object)
+    String(@formatters[extname].call(object))
+  end
+
+  CONTENT_TYPE = ::Rack::App::Constants::HTTP::Headers::CONTENT_TYPE
+
+  def response_headers_for(extname)
+    headers = {}
+    add_content_type_for(headers, extname)
+    headers
+  end
+
+  def to_options
+    {
+      :formatters => @formatters,
+      :content_types => @content_types,
+      :default_formatter => @default_formatter,
+      :default_content_type => @default_content_type,
+    }
   end
 
-  def serialize(object)
-    String(@logic.call(object))
+  def extnames
+    (@formatters.keys + @content_types.keys).uniq
   end
 
+  protected
+
+  def add_content_type_for(headers, extname)
+    content_type = @content_types[extname]
+    if content_type
+      headers[CONTENT_TYPE]= content_type.dup
+    end
+  end
+
+
 end

data/lib/rack/app/serializer/formats_builder.rb

@@ -0,0 +1,39 @@
+class Rack::App::Serializer::FormatsBuilder
+
+  def initialize
+    @formatters = {}
+    @content_types = {}
+    @default_formatter = lambda { |o| o.to_s }
+    @default_content_type = nil
+  end
+
+  def on(extname, response_content_type, &formatter)
+    format = String(extname).downcase
+    extension = (format[0,1] == '.' ? format : ".#{format}")
+    @formatters[extension]= formatter
+    @content_types[extension]= response_content_type
+    self
+  end
+
+  def default(content_type=nil, &block)
+    @default_content_type = content_type if content_type
+    @default_formatter = block if block
+    self
+  end
+
+  def to_serializer
+    Rack::App::Serializer.new(
+      :formatters => @formatters,
+      :content_types => @content_types,
+      :default_formatter => @default_formatter,
+      :default_content_type => @default_content_type
+    )
+  end
+
+  def merge!(formats_builder)
+    @formatters.merge!(formats_builder.instance_variable_get(:@formatters))
+    @default_formatter = formats_builder.instance_variable_get(:@default_formatter)
+    self
+  end
+
+end

data/lib/rack/app/singleton_methods.rb

@@ -9,6 +9,7 @@ module Rack::App::SingletonMethods
   require 'rack/app/singleton_methods/route_handling'
   require 'rack/app/singleton_methods/settings'
   require 'rack/app/singleton_methods/extensions'
+  require 'rack/app/singleton_methods/formats'
   require 'rack/app/singleton_methods/hooks'
 
   include Rack::App::SingletonMethods::HttpMethods
@@ -20,6 +21,7 @@ module Rack::App::SingletonMethods
   include Rack::App::SingletonMethods::RouteHandling
   include Rack::App::SingletonMethods::Settings
   include Rack::App::SingletonMethods::Extensions
+  include Rack::App::SingletonMethods::Formats
   include Rack::App::SingletonMethods::Hooks
 
 end

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

@@ -0,0 +1,17 @@
+module Rack::App::SingletonMethods::Formats
+
+  def formats(&descriptor)
+    @formats_builder ||= Rack::App::Serializer::FormatsBuilder.new
+    unless descriptor.nil?
+      @formats_builder.instance_exec(&descriptor)
+      router.reset 
+    end
+    @formats_builder
+  end
+
+  def serializer(default_content_type=nil, &how_to_serialize)
+    formats{ default(default_content_type,&how_to_serialize) } unless how_to_serialize.nil?
+    return formats.to_serializer
+  end
+
+end

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

@@ -10,7 +10,8 @@ module Rack::App::SingletonMethods::Inheritance
 
   def inherited(child)
 
-    child.serializer(&serializer.logic)
+    child.formats.merge!(formats)
+
     [:middlewares, :before, :after].each do |type|
       child.__send__(type).push(*__send__(type))
     end

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

@@ -3,7 +3,6 @@ module Rack::App::SingletonMethods::RackInterface
   public
 
   def call(env)
-    Rack::App::RequestConfigurator.configure(env)
     return router.call(env)
   end
 

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

@@ -26,7 +26,6 @@ module Rack::App::SingletonMethods::RouteHandling
       Rack::App::Endpoint.new({
         :app_class => self,
         :error_handler => error,
-        :serializer => serializer,
         :user_defined_logic => block,
         :request_method => request_method,
         :route => route_registration_properties.dup,

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

@@ -8,12 +8,6 @@ module Rack::App::SingletonMethods::Settings
 
   protected
 
-  def serializer(&definition_how_to_serialize)
-    @serializer ||= Rack::App::Serializer.new
-    @serializer = Rack::App::Serializer.new(&definition_how_to_serialize) unless definition_how_to_serialize.nil?
-    return @serializer
-  end
-
   def headers(new_headers=nil)
     middleware do |b|
       b.use(Rack::App::Middlewares::HeaderSetter,new_headers)

data/lib/rack/app/streamer.rb

@@ -13,7 +13,8 @@ class Rack::App::Streamer
   require "rack/app/streamer/scheduler"
 
   def initialize(env, options={}, &back)
-    @serializer = env[Rack::App::Constants::ENV::SERIALIZER]
+    @serializer = env[::Rack::App::Constants::ENV::SERIALIZER]
+    @extname = env[::Rack::App::Constants::ENV::EXTNAME]
     @scheduler = options[:scheduler] || Rack::App::Streamer::Scheduler.by_env(env)
     @keep_open = options[:keep_open] || false
     @back = back.to_proc
@@ -39,7 +40,7 @@ class Rack::App::Streamer
   end
 
   def <<(data)
-    @scheduler.schedule { @front.call(@serializer.serialize(data)) }
+    @scheduler.schedule { @front.call(@serializer.serialize(@extname, data)) }
     self
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-app
 version: !ruby/object:Gem::Version
-  version: 5.4.0
+  version: 5.5.1
 platform: ruby
 authors:
 - Adam Luzsi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-21 00:00:00.000000000 Z
+date: 2016-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -120,8 +120,9 @@ files:
 - lib/rack/app/instance_methods/streaming.rb
 - lib/rack/app/middlewares.rb
 - lib/rack/app/middlewares/configuration.rb
-- lib/rack/app/middlewares/configuration/path_info_formatter.rb
+- lib/rack/app/middlewares/configuration/handler_setter.rb
 - lib/rack/app/middlewares/configuration/path_params_matcher.rb
+- lib/rack/app/middlewares/configuration/serializer_setter.rb
 - lib/rack/app/middlewares/header_setter.rb
 - lib/rack/app/middlewares/hooks.rb
 - lib/rack/app/middlewares/hooks/after.rb
@@ -132,6 +133,7 @@ files:
 - lib/rack/app/middlewares/params/parser.rb
 - lib/rack/app/middlewares/params/setter.rb
 - lib/rack/app/middlewares/params/validator.rb
+- lib/rack/app/middlewares/path_info_cutter.rb
 - lib/rack/app/params.rb
 - lib/rack/app/request_configurator.rb
 - lib/rack/app/router.rb
@@ -141,8 +143,10 @@ files:
 - lib/rack/app/router/not_found.rb
 - lib/rack/app/router/static.rb
 - lib/rack/app/serializer.rb
+- lib/rack/app/serializer/formats_builder.rb
 - lib/rack/app/singleton_methods.rb
 - lib/rack/app/singleton_methods/extensions.rb
+- lib/rack/app/singleton_methods/formats.rb
 - lib/rack/app/singleton_methods/hooks.rb
 - lib/rack/app/singleton_methods/http_methods.rb
 - lib/rack/app/singleton_methods/inheritance.rb

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

@@ -1,14 +0,0 @@
-class Rack::App::Middlewares::Configuration::PathInfoFormatter
-
-  def initialize(app, cut_string_from_path)
-    @cut_string_from_path = cut_string_from_path
-    @app = app
-  end
-
-  def call(env)
-    env[::Rack::App::Constants::ENV::ORIGINAL_PATH_INFO]= env[::Rack::App::Constants::ENV::PATH_INFO].dup
-    env[::Rack::App::Constants::ENV::PATH_INFO].sub!(@cut_string_from_path, '')
-    @app.call(env)
-  end
-
-end