deas 0.43.3 → 0.43.4

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
 SHA512: 
-  data.tar.gz: b170992c80b97715972d5a7bd749a617cdfe821c0cb8fe36e106a2a626ea38adfbe544c719dc211910b3711151b58e9cab7db5e0a6709519f6ad297634030497
-  metadata.gz: fdffbb2ae1dad2bae870411a2eac9b8ef8d57c3a52b3751667aa8d1fd3cabe704b516388fcc2913ddb48962aa22ad88d196a6a051567ed42bef041b444a2ea01
+  metadata.gz: 0408c659dda15d5dabe1982e6a062e9d9021d38cdb5068aeb96cd46298341a740b4c73875c59f7d39a538b93152f92b57fbf87dd2d2476d5091905286301976a
+  data.tar.gz: e6af545cc1ed6365fd6825e6ceb5d2490311ca67a86bdb261e42590d72593e20891fde53ebe7b718ccc4bf1ba5b7997aa60a61dbe92f1c4d810838d7390587f9
 SHA1: 
-  data.tar.gz: c8540720fc644e4b104147aae617d88805a5d772
-  metadata.gz: aeaae586a530fc712c24f179c44729382c6ffe24
+  metadata.gz: cccc4cbf0e9a8ee8e5cdfbd597bbb3d348d2bbac
+  data.tar.gz: d29bf90d2085ccaca87d0059e78b2a8a658ad287

data/Gemfile

@@ -2,4 +2,5 @@ source "https://rubygems.org"
 
 gemspec
 
-gem 'pry', "~> 0.9.0"
+gem 'pry',  "~> 0.9.0"
+gem 'rack', " = 1.6.8"

data/deas.gemspec

@@ -18,8 +18,8 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency("assert",           ["~> 2.16.1"])
-  gem.add_development_dependency("assert-rack-test", ["~> 1.0.4"])
+  gem.add_development_dependency("assert",           ["~> 2.16.3"])
+  gem.add_development_dependency("assert-rack-test", ["~> 1.0.5"])
 
   gem.add_dependency("much-plugin", ["~> 0.2.0"])
   gem.add_dependency("rack",        ["~> 1.1"])

data/lib/deas/error_handler.rb

@@ -26,7 +26,7 @@ module Deas
           error_proc.call(@exception, @context)
         rescue StandardError => proc_exception
           @exception = proc_exception
-          response = nil # reset response
+          response   = nil # reset response
         end
         response || result
       end
@@ -35,18 +35,18 @@ module Deas
     class Context
 
       attr_reader :server_data
-      attr_reader :request, :response, :handler_class, :handler
-      attr_reader :params, :splat, :route_path
+      attr_reader :request, :response
+      attr_reader :route_path, :handler_class, :handler, :params, :splat
 
       def initialize(args)
         @server_data   = args.fetch(:server_data)
         @request       = args.fetch(:request)
         @response      = args.fetch(:response)
+        @route_path    = args.fetch(:route_path)
         @handler_class = args.fetch(:handler_class)
         @handler       = args.fetch(:handler)
         @params        = args.fetch(:params)
         @splat         = args.fetch(:splat)
-        @route_path    = args.fetch(:route_path)
       end
 
       def ==(other)
@@ -55,10 +55,10 @@ module Deas
           self.handler_class == other.handler_class &&
           self.request       == other.request       &&
           self.response      == other.response      &&
+          self.route_path    == other.route_path    &&
           self.handler       == other.handler       &&
           self.params        == other.params        &&
-          self.splat         == other.splat         &&
-          self.route_path    == other.route_path
+          self.splat         == other.splat
         else
           super
         end

data/lib/deas/handler_proxy.rb

@@ -33,8 +33,8 @@ module Deas
         :router          => server_data.router,
         :template_source => server_data.template_source,
         :request         => request_data.request,
-        :params          => request_data.params,
-        :route_path      => request_data.route_path
+        :route_path      => request_data.route_path,
+        :params          => request_data.params
       })
 
       runner.request.env.tap do |env|
@@ -42,17 +42,17 @@ module Deas
         # this is specifically needed by the Logging middleware
         # this is also needed by the Sinatra error handlers so they can provide
         # error context.  This may change when we eventually remove Sinatra.
+        env['deas.route_path']    = runner.route_path
         env['deas.handler_class'] = self.handler_class
         env['deas.handler']       = runner.handler
         env['deas.params']        = runner.params
         env['deas.splat']         = runner.splat
-        env['deas.route_path']    = runner.route_path
 
         # this handles the verbose logging (it is a no-op if summary logging)
+        env['deas.logging'].call "  Route:   #{runner.route_path.inspect}"
         env['deas.logging'].call "  Handler: #{self.handler_class.name}"
         env['deas.logging'].call "  Params:  #{runner.params.inspect}"
         env['deas.logging'].call "  Splat:   #{runner.splat.inspect}" if !runner.splat.nil?
-        env['deas.logging'].call "  Route:   #{runner.route_path.inspect}"
       end
 
       runner.run

data/lib/deas/logging.rb

@@ -4,16 +4,16 @@ require 'sinatra/base'
 module Deas
 
   module Logging
-    def self.middleware_args(verbose)
-      verbose ? [VerboseLogging] : [SummaryLogging]
+    def self.middleware_type(verbose)
+      verbose ? VerboseLogging : SummaryLogging
     end
   end
 
   class BaseLogging
 
-    def initialize(app)
+    def initialize(app, logger)
       @app    = app
-      @logger = @app.settings.deas_server_data.logger
+      @logger = logger
     end
 
     # The Rack call interface. The receiver acts as a prototype and runs

data/lib/deas/request_data.rb

@@ -8,21 +8,21 @@ module Deas
     # decouple the rack app from the handlers (we can use any rack app as long
     # as they provide this data).
 
-    attr_reader :request, :response, :params, :route_path
+    attr_reader :request, :response, :route_path, :params
 
     def initialize(args)
       @request    = args[:request]
       @response   = args[:response]
-      @params     = args[:params]
       @route_path = args[:route_path]
+      @params     = args[:params]
     end
 
     def ==(other_request_data)
       if other_request_data.kind_of?(RequestData)
         self.request    == other_request_data.request    &&
         self.response   == other_request_data.response   &&
-        self.params     == other_request_data.params     &&
-        self.route_path == other_request_data.route_path
+        self.route_path == other_request_data.route_path &&
+        self.params     == other_request_data.params
       else
         super
       end

data/lib/deas/router.rb

@@ -7,9 +7,17 @@ module Deas
   class Router
 
     DEFAULT_REQUEST_TYPE_NAME = 'default'.freeze
+    ALLOW_TRAILING_SLASHES    = 'allow'.freeze
+    REMOVE_TRAILING_SLASHES   = 'remove'.freeze
+    SLASH                     = '/'.freeze
+
+    VALID_TRAILING_SLASHES_VALUES = [
+      ALLOW_TRAILING_SLASHES,
+      REMOVE_TRAILING_SLASHES
+    ].freeze
 
     attr_reader :request_types, :urls, :routes, :definitions
-    attr_reader :escape_query_value_proc
+    attr_reader :trailing_slashes, :escape_query_value_proc
 
     def initialize(&block)
       @request_types = []
@@ -24,6 +32,26 @@ module Deas
       @view_handler_ns
     end
 
+    def allow_trailing_slashes
+      @trailing_slashes = ALLOW_TRAILING_SLASHES
+    end
+
+    def allow_trailing_slashes_set?
+      @trailing_slashes == ALLOW_TRAILING_SLASHES
+    end
+
+    def remove_trailing_slashes
+      @trailing_slashes = REMOVE_TRAILING_SLASHES
+    end
+
+    def remove_trailing_slashes_set?
+      @trailing_slashes == REMOVE_TRAILING_SLASHES
+    end
+
+    def trailing_slashes_set?
+      VALID_TRAILING_SLASHES_VALUES.include?(@trailing_slashes)
+    end
+
     def escape_query_value(&block)
       raise(ArgumentError, "no block given") unless block
       @escape_query_value_proc = block
@@ -109,9 +137,26 @@ module Deas
       true
     end
 
+    def validate_trailing_slashes!
+      if self.trailing_slashes == REMOVE_TRAILING_SLASHES
+        paths = []
+        all_missing = self.routes.inject(true) do |result, route|
+          paths << route.path if route.path[-1..-1] == SLASH
+          result && route.path[-1..-1] != SLASH
+        end
+        if !all_missing
+          msg = "all route paths must *not* end with a \"/\", but these do:\n"\
+                "#{paths.join("\n")}"
+          raise TrailingSlashesError, msg
+        end
+      end
+      true
+    end
+
     def validate!
       self.apply_definitions!
       self.routes.each(&:validate!)
+      self.validate_trailing_slashes!
       true
     end
 
@@ -192,7 +237,8 @@ module Deas
       Deas::Route.new(http_method, path, proxies).tap{ |r| self.routes.push(r) }
     end
 
-    InvalidSplatError = Class.new(ArgumentError)
+    InvalidSplatError    = Class.new(ArgumentError)
+    TrailingSlashesError = Class.new(RuntimeError)
 
     class HandlerProxies
 

data/lib/deas/runner.rb

@@ -14,22 +14,22 @@ module Deas
     DEFAULT_BODY      = [].freeze
 
     attr_reader :handler_class, :handler
+    attr_reader :request, :route_path, :params
     attr_reader :logger, :router, :template_source
-    attr_reader :request, :params, :route_path
 
     def initialize(handler_class, args = nil)
       @status, @headers, @body = nil, Rack::Utils::HeaderHash.new, nil
 
+      @handler_class = handler_class
+      @handler = @handler_class.new(self)
+
       args ||= {}
+      @request         = args[:request]
+      @route_path      = args[:route_path].to_s
+      @params          = args[:params]          || {}
       @logger          = args[:logger]          || Deas::NullLogger.new
       @router          = args[:router]          || Deas::Router.new
       @template_source = args[:template_source] || Deas::NullTemplateSource.new
-      @request         = args[:request]
-      @params          = args[:params]          || {}
-      @route_path      = args[:route_path].to_s
-
-      @handler_class = handler_class
-      @handler = @handler_class.new(self)
     end
 
     def splat
@@ -56,8 +56,10 @@ module Deas
 
     def body(value = nil)
       if !value.nil?
+        # http://www.rubydoc.info/github/rack/rack/master/file/SPEC#The_Body
+        # "The Body must respond to each and must only yield String values"
         # String#each is a thing in 1.8.7, so account for it here
-        @body = !value.respond_to?(:each) || value.kind_of?(String) ? [*value] : value
+        @body = !value.respond_to?(:each) || value.kind_of?(String) ? [*value.to_s] : value
       end
       @body
     end
@@ -66,6 +68,14 @@ module Deas
       self.headers['Content-Type'] = get_content_type(extname, params)
     end
 
+    def set_cookie(name, value, opts = nil)
+      Rack::Utils.set_cookie_header!(
+        self.headers,
+        name,
+        (opts || {}).merge(:value => value)
+      )
+    end
+
     def halt(*args)
       self.status(args.shift)  if args.first.instance_of?(::Fixnum)
       self.headers(args.shift) if args.first.kind_of?(::Hash)

data/lib/deas/server.rb

@@ -6,6 +6,7 @@ require 'deas/router'
 require 'deas/show_exceptions'
 require 'deas/sinatra_app'
 require 'deas/template_source'
+require 'deas/trailing_slashes'
 
 module Deas
 
@@ -194,11 +195,27 @@ module Deas
         # it is run before any other middleware
         self.middlewares.unshift([Rack::MethodOverride]) if self.method_override
 
-        # append the show exceptions and logging middlewares last.  This ensures
-        # that the logging and exception showing happens just before the app gets
-        # the request and just after the app sends a response.
+        # append the show exceptions and logging middlewares next-to-last. This
+        # ensures the logging and exception showing happens just before the
+        # optional trailing slashes handling.  It should be just before the app
+        # gets the request and just after the app sends a response (except for
+        # trailing slashes - this should happen inside of the show exceptions
+        # and logging behavior).
         self.middlewares << [Deas::ShowExceptions] if self.show_exceptions
-        self.middlewares << Deas::Logging.middleware_args(self.verbose_logging)
+        self.middlewares << [
+          Deas::Logging.middleware_type(self.verbose_logging),
+          self.logger
+        ]
+
+        # optionally add the trailing slashes middleware last b/c it should
+        # happen inside of show exceptions and logging.  we want the behavior
+        # to feel like app behavior to the rest of the middleware stack so it
+        # needs to be just before the app gest the request and just after the
+        # app sends a response.
+        if self.router.trailing_slashes_set?
+          self.middlewares << [Deas::TrailingSlashes, self.router]
+        end
+
         self.middlewares.freeze
 
         @valid = true # if it made it this far, its valid!

data/lib/deas/sinatra_app.rb

@@ -43,13 +43,6 @@ module Deas
         set :environment, server_config.env
         set :root,        server_config.root
 
-        # TODO: sucks to have to do this but b/c of Rack there is no better way
-        # to make the server data available to middleware.  We should remove this
-        # once we remove Sinatra.  Whatever rack app implemenation will needs to
-        # provide the server data or maybe the server data *will be* the rack app.
-        # Not sure right now, just jotting down notes.
-        set :deas_server_data, server_data
-
         # static settings - Deas doesn't care about these anymore so just
         # use some intelligent defaults
         set :views,            server_config.root
@@ -84,8 +77,8 @@ module Deas
                 RequestData.new({
                   :request    => request,
                   :response   => response,
-                  :params     => params,
-                  :route_path => route.path
+                  :route_path => route.path,
+                  :params     => params
                 })
               )
             rescue *STANDARD_ERROR_CLASSES => err
@@ -95,11 +88,11 @@ module Deas
                 :server_data   => server_data,
                 :request       => request,
                 :response      => response,
+                :route_path    => request.env['deas.route_path'],
                 :handler_class => request.env['deas.handler_class'],
                 :handler       => request.env['deas.handler'],
                 :params        => request.env['deas.params'],
-                :splat         => request.env['deas.splat'],
-                :route_path    => request.env['deas.route_path']
+                :splat         => request.env['deas.splat']
               })
             end
           end
@@ -109,7 +102,7 @@ module Deas
           # `self` is the sinatra call in this context
           if env['sinatra.error']
             env['deas.error'] = if env['sinatra.error'].instance_of?(::Sinatra::NotFound)
-              Deas::NotFound.new(env['PATH_INFO']).tap do |e|
+              Deas::NotFound.new("#{env['REQUEST_METHOD']} #{env['PATH_INFO']}").tap do |e|
                 e.set_backtrace(env['sinatra.error'].backtrace)
               end
             else
@@ -119,11 +112,11 @@ module Deas
               :server_data   => server_data,
               :request       => request,
               :response      => response,
+              :route_path    => request.env['deas.route_path'],
               :handler_class => request.env['deas.handler_class'],
               :handler       => request.env['deas.handler'],
               :params        => request.env['deas.params'],
-              :splat         => request.env['deas.splat'],
-              :route_path    => request.env['deas.route_path']
+              :splat         => request.env['deas.splat']
             })
           end
         end

data/lib/deas/test_runner.rb

@@ -27,8 +27,8 @@ module Deas
         :router          => a.delete(:router),
         :template_source => a.delete(:template_source),
         :request         => a.delete(:request),
-        :params          => NormalizedParams.new(a.delete(:params) || {}).value,
-        :route_path      => a.delete(:route_path)
+        :route_path      => a.delete(:route_path),
+        :params          => NormalizedParams.new(a.delete(:params) || {}).value
       })
       @splat = a.delete(:splat)
       a.each{|key, value| self.handler.send("#{key}=", value) }

data/lib/deas/trailing_slashes.rb

@@ -0,0 +1,85 @@
+require 'rack/utils'
+
+require 'deas/exceptions'
+require 'deas/router'
+
+module Deas
+
+  class TrailingSlashes
+
+    module RequireNoHandler; end
+    module AllowHandler;     end
+
+    HANDLERS = {
+      Deas::Router::REMOVE_TRAILING_SLASHES => RequireNoHandler,
+      Deas::Router::ALLOW_TRAILING_SLASHES  => AllowHandler
+    }
+
+    def initialize(app, router)
+      @app    = app
+      @router = router
+
+      if !@router.trailing_slashes_set?
+        val  = @router.trailing_slashes
+        desc = val.nil? ? 'no' : "an invalid (`#{val.inspect}`)"
+        raise ArgumentError, "TrailingSlashes middleware is in use but there is "\
+                             "#{desc} trailing slashes router directive set."
+      end
+    end
+
+    # The Rack call interface. The receiver acts as a prototype and runs
+    # each request in a clone object unless the +rack.run_once+ variable is
+    # set in the environment. Ripped from:
+    # http://github.com/rtomayko/rack-cache/blob/master/lib/rack/cache/context.rb
+    def call(env)
+      if env['rack.run_once']
+        call! env
+      else
+        clone.call! env
+      end
+    end
+
+    # The real Rack call interface.
+    def call!(env)
+      HANDLERS[@router.trailing_slashes].run(env){ @app.call(env) }
+    end
+
+    module RequireNoHandler
+
+      def self.run(env)
+        if env['PATH_INFO'][-1..-1] == Deas::Router::SLASH
+          [302, { 'Location' => env['PATH_INFO'][0..-2] }, ['']]
+        else
+          yield
+        end
+      end
+
+    end
+
+    module AllowHandler
+
+      def self.run(env)
+        status, headers, body = yield
+        if env['deas.error'].kind_of?(Deas::NotFound)
+          # reset 'deas.error' state
+          env['deas.error'] = nil
+
+          # switching the trailing slash of the path info
+          env['PATH_INFO'] = if env['PATH_INFO'][-1..-1] == Deas::Router::SLASH
+            env['PATH_INFO'][0..-2]
+          else
+            env['PATH_INFO']+Deas::Router::SLASH
+          end
+
+          # retry
+          yield
+        else
+          [status, headers, body]
+        end
+      end
+
+    end
+
+  end
+
+end