deas 0.42.0 → 0.43.0

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
-SHA1: 
-  metadata.gz: 1105d3943d8f80cbcfd722a4fd5796b015fb7e0c
-  data.tar.gz: 4847313602ffd9942d2b287f36052c0946e03c06
 SHA512: 
-  metadata.gz: 431fac2fe7deafdf9523882813e5caf34b57035b5077cf8152270503e6a0c914fa501015a47c5ead7d5c221d788e216389449a087c16167915ed82d769f9deab
-  data.tar.gz: 45cc5441925322a35fd7ad112ecf5b297113782ff14afb9d621b50735c6ee492ea163ec915e8b8cdef3d0b5da1d9653f0513f35a18aa8564855a6a9cf133b7a7
+  data.tar.gz: 3520f4645edbc6b6b89e470cc2025f436e6031989c7c7ebf60f9b2c50ec4ec9e68b938fd0149603c8addd798ccd9fc895a0a68e58b89b12c51e2aad0e6f84f1d
+  metadata.gz: ba28b9b16f9011f958849afdb5a774a1f559d5c258447b6f0e3ba551328ebbad70d36d84f462af46cce1fcd9f9fec2ebc5fc57d3da01d86aa9f7d778bc181a7f
+SHA1: 
+  data.tar.gz: 91a77987b3fb3b6d87a728643150a787b620c04a
+  metadata.gz: 69eab40552eaaf3cb49bf1d9dd1bc3f4cadb8533

data/deas.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency("assert-rack-test", ["~> 1.0.4"])
 
   gem.add_dependency("much-plugin", ["~> 0.2.0"])
-  gem.add_dependency("rack",        ["~> 1.1"])
+  gem.add_dependency("rack",        ["~> 1.6.4"])
   gem.add_dependency("sinatra",     ["~> 1.2"])
 
 end

data/lib/deas/error_handler.rb

@@ -35,25 +35,30 @@ module Deas
     class Context
 
       attr_reader :server_data
-      attr_reader :request, :response, :handler_class, :handler, :params
+      attr_reader :request, :response, :handler_class, :handler
+      attr_reader :params, :splat, :route_path
 
       def initialize(args)
-        @server_data   = args[:server_data]
-        @request       = args[:request]
-        @response      = args[:response]
-        @handler_class = args[:handler_class]
-        @handler       = args[:handler]
-        @params        = args[:params]
+        @server_data   = args.fetch(:server_data)
+        @request       = args.fetch(:request)
+        @response      = args.fetch(:response)
+        @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)
         if other.kind_of?(self.class)
-          self.server_data   == other.server_data &&
+          self.server_data   == other.server_data   &&
           self.handler_class == other.handler_class &&
-          self.request       == other.request &&
-          self.response      == other.response &&
-          self.handler       == other.handler &&
-          self.params        == other.params
+          self.request       == other.request       &&
+          self.response      == other.response      &&
+          self.handler       == other.handler       &&
+          self.params        == other.params        &&
+          self.splat         == other.splat         &&
+          self.route_path    == other.route_path
         else
           super
         end

data/lib/deas/handler_proxy.rb

@@ -15,29 +15,26 @@ module Deas
       raise NotImplementedError
     end
 
-    def run(server_data, sinatra_call)
-      # captures are not part of Deas' intended behavior and route matching
-      # they are a side-effects of using Sinatra.  remove them so they won't
-      # be relied upon in Deas apps.
-      sinatra_call.params.delete(:captures)
-      sinatra_call.params.delete('captures')
-
-      # splat will be provided to the handlers via a special `splat` helper.
-      # only single splat values are allowed (see router `url` method).  this
-      # takes the last splat value from Sinatra and provides it standalone to
-      # the runner.
-      splat_sym_param    = sinatra_call.params.delete(:splat)
-      splat_string_param = sinatra_call.params.delete('splat')
-      splat_value        = (splat_sym_param || splat_string_param || []).last
+    def run(server_data, request_data)
+      # captures are not part of Deas' intended behavior and route matching -
+      # they are a side-effect of using Sinatra.  remove them so they won't
+      # be relied upon in Deas apps.  Remove all of this when Sinatra is removed.
+      request_data.params.delete(:captures)
+      request_data.params.delete('captures')
+
+      # splats that Sinatra provides aren't used by Deas - they are a
+      # side-effect of using Sinatra.  remove them so they won't be relied upon
+      # in Deas apps.  Remove all of this when Sinatra is removed.
+      request_data.params.delete(:splat)
+      request_data.params.delete('splat')
 
       runner = DeasRunner.new(self.handler_class, {
         :logger          => server_data.logger,
         :router          => server_data.router,
         :template_source => server_data.template_source,
-        :request         => sinatra_call.request,
-        :session         => sinatra_call.session,
-        :params          => sinatra_call.params,
-        :splat           => splat_value
+        :request         => request_data.request,
+        :params          => request_data.params,
+        :route_path      => request_data.route_path
       })
 
       runner.request.env.tap do |env|
@@ -48,11 +45,14 @@ module Deas
         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 "  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,8 +4,8 @@ require 'sinatra/base'
 module Deas
 
   module Logging
-    def self.middleware(verbose)
-      verbose ? VerboseLogging : SummaryLogging
+    def self.middleware_args(verbose)
+      verbose ? [VerboseLogging] : [SummaryLogging]
     end
   end
 
@@ -102,6 +102,7 @@ module Deas
         'method'  => request.request_method,
         'path'    => request.path,
         'params'  => env['deas.params'],
+        'splat'   => env['deas.splat'],
         'time'    => env['deas.time_taken'],
         'status'  => status
       }
@@ -119,7 +120,7 @@ module Deas
 
   module SummaryLine
     def self.keys
-      %w{time status method path handler params redir}
+      %w{time status method path handler params splat redir}
     end
     def self.new(line_attrs)
       self.keys.select{ |k| line_attrs.key?(k) }.

data/lib/deas/request_data.rb

@@ -0,0 +1,33 @@
+module Deas
+
+  class RequestData
+
+    # The rack app uses this to "compile" the request-related data. The goal
+    # here is to wrap up these (and any future) request objects into a struct
+    # object to make them available to the runner/handler.  This is also to
+    # 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
+
+    def initialize(args)
+      @request    = args[:request]
+      @response   = args[:response]
+      @params     = args[:params]
+      @route_path = args[:route_path]
+    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
+      else
+        super
+      end
+    end
+
+  end
+
+end

data/lib/deas/route.rb

@@ -16,15 +16,13 @@ module Deas
       end
     end
 
-    def run(server_data, sinatra_call)
-      type = server_data.router.request_type_name(sinatra_call.request)
-      proxy = begin
-        @handler_proxies[type]
+    def run(server_data, request_data)
+      request_type_name = server_data.router.request_type_name(request_data.request)
+      begin
+        @handler_proxies[request_type_name].run(server_data, request_data)
       rescue HandlerProxyNotFound
-        sinatra_call.halt(404)
+        [404, Rack::Utils::HeaderHash.new, []]
       end
-      # TODO: eventually stop sending sinatra call (part of phasing out Sinatra)
-      proxy.run(server_data, sinatra_call)
     end
 
   end

data/lib/deas/router.rb

@@ -43,15 +43,15 @@ module Deas
     end
 
     def url(name, path, options = nil)
+      if !name.kind_of?(::Symbol)
+        raise ArgumentError, "invalid name `#{name.inspect}` - "\
+                             "named urls must be defined with Symbol names"
+      end
       if !path.kind_of?(::String)
         raise ArgumentError, "invalid path `#{path.inspect}` - "\
                              "named urls must be defined with String paths"
       end
-      if path =~ /\*(?!$)/ # splat not at end of path
-        raise ArgumentError, "invalid path `#{path.inspect}` - "\
-                             "named urls can only have a single splat at the end of the path"
-      end
-      add_url(name.to_sym, path, options || {})
+      add_url(name, path, options || {})
     end
 
     def url_for(name, *args)
@@ -179,11 +179,21 @@ module Deas
     end
 
     def add_route(http_method, path, proxies)
+      # splat not at end of path OR
+      # at end of path without preceding forward slash
+      if path =~ /\*(?!$)|[^\/]\*/
+        raise InvalidSplatError, "invalid path `#{path.inspect}` - "\
+                                 "routes can only have a single splat and " \
+                                 "it must be the last path segment " \
+                                 "(ie '/something/*')"
+      end
       proxies = HandlerProxies.new(proxies, self.default_request_type_name)
       require 'deas/route'
       Deas::Route.new(http_method, path, proxies).tap{ |r| self.routes.push(r) }
     end
 
+    InvalidSplatError = Class.new(ArgumentError)
+
     class HandlerProxies
 
       attr_reader :default_type

data/lib/deas/runner.rb

@@ -15,24 +15,27 @@ module Deas
 
     attr_reader :handler_class, :handler
     attr_reader :logger, :router, :template_source
-    attr_reader :request, :session, :params, :splat
+    attr_reader :request, :params, :route_path
 
     def initialize(handler_class, args = nil)
       @status, @headers, @body = nil, Rack::Utils::HeaderHash.new, nil
 
       args ||= {}
-      @logger          = args[:logger] || Deas::NullLogger.new
-      @router          = args[:router] || Deas::Router.new
+      @logger          = args[:logger]          || Deas::NullLogger.new
+      @router          = args[:router]          || Deas::Router.new
       @template_source = args[:template_source] || Deas::NullTemplateSource.new
       @request         = args[:request]
-      @session         = args[:session]
-      @params          = args[:params] || {}
-      @splat           = args[:splat]
+      @params          = args[:params]          || {}
+      @route_path      = args[:route_path].to_s
 
       @handler_class = handler_class
       @handler = @handler_class.new(self)
     end
 
+    def splat
+      @splat ||= parse_splat_value
+    end
+
     def run
       raise NotImplementedError
     end
@@ -138,6 +141,46 @@ module Deas
       File.join("#{request.env['rack.url_scheme']}://#{request.env['HTTP_HOST']}", url)
     end
 
+    def parse_splat_value
+      return nil if request.nil? || (path_info = request.env['PATH_INFO']).nil?
+
+      regex = splat_value_parse_regex
+      match = regex.match(path_info)
+      if match.nil?
+        raise SplatParseError, "could not parse the splat value: " \
+                               "the PATH_INFO, `#{path_info.inspect}`, " \
+                               "doesn't match " \
+                               "the route, `#{self.route_path.inspect}`, " \
+                               "using the route regex, `#{regex.inspect}`"
+      end
+      match.captures.first
+    end
+
+    SplatParseError = Class.new(RuntimeError)
+
+    def splat_value_parse_regex
+      # `sub` should suffice as only a single trailing splat is allowed. Replace
+      # any splat with a capture placholder so we can extract the splat value.
+      /^#{route_path_with_regex_placeholders.sub('*', '(.+?)')}$/
+    end
+
+    def route_path_with_regex_placeholders
+      # Replace param values with regex placeholders b/c we don't care what
+      # the values are just that "a param value goes here".  Use gsub in the odd
+      # case a placeholder is used more than once in a route.  This is to help
+      # ensure matching and capturing splats even on nonsense paths.
+      sorted_param_names.inject(self.route_path) do |path, name|
+        path.gsub(":#{name}", '.+?')
+      end
+    end
+
+    def sorted_param_names
+      # Sort longer key names first so they will be processed first.  This
+      # ensures that shorter param names that compose longer param names won't
+      # be subbed in the longer param name's place.
+      self.params.keys.sort{ |a, b| b.size <=> a.size }
+    end
+
     class NormalizedParams
 
       attr_reader :value

data/lib/deas/server.rb

@@ -31,7 +31,12 @@ module Deas
       # TODO: needed while Deas is powered by Sinatra
       # eventually do an initialize method more like Sanford does
       def new
-        Deas::SinatraApp.new(self.config)
+        begin
+          Deas::SinatraApp.new(self.config)
+        rescue Router::InvalidSplatError => e
+          # reset the exception backtrace to hide Deas internals
+          raise e.class, e.message, caller
+        end
       end
 
       def config
@@ -48,44 +53,19 @@ module Deas
         self.config.root
       end
 
-      def views_path(value = nil)
-        self.config.views_path = value if !value.nil?
-        self.config.views_path
-      end
-
-      def views_root
-        self.config.views_root
-      end
-
-      def public_path(value = nil)
-        self.config.public_path = value if !value.nil?
-        self.config.public_path
-      end
-
-      def public_root
-        self.config.public_root
-      end
-
-      def default_encoding(value = nil)
-        self.config.default_encoding = value if !value.nil?
-        self.config.default_encoding
-      end
-
-      def set(name, value)
-        self.config.settings[name.to_sym] = value
-      end
-
-      def settings
-        self.config.settings
+      def method_override(value = nil)
+        self.config.method_override = value if !value.nil?
+        self.config.method_override
       end
 
-      def template_helpers(*helper_modules)
-        helper_modules.each{ |m| self.config.template_helpers << m }
-        self.config.template_helpers
+      def show_exceptions(value = nil)
+        self.config.show_exceptions = value if !value.nil?
+        self.config.show_exceptions
       end
 
-      def template_helper?(helper_module)
-        self.config.template_helpers.include?(helper_module)
+      def verbose_logging(value = nil)
+        self.config.verbose_logging = value if !value.nil?
+        self.config.verbose_logging
       end
 
       def use(*args)
@@ -132,94 +112,33 @@ module Deas
 
       def url_for(*args, &block); self.router.url_for(*args, &block); end
 
-      # flags
-
-      def dump_errors(value = nil)
-        self.config.dump_errors = value if !value.nil?
-        self.config.dump_errors
-      end
-
-      def method_override(value = nil)
-        self.config.method_override = value if !value.nil?
-        self.config.method_override
-      end
-
-      def reload_templates(value = nil)
-        self.config.reload_templates = value if !value.nil?
-        self.config.reload_templates
-      end
-
-      def sessions(value = nil)
-        self.config.sessions = value if !value.nil?
-        self.config.sessions
-      end
-
-      def show_exceptions(value = nil)
-        self.config.show_exceptions = value if !value.nil?
-        self.config.show_exceptions
-      end
-
-      def static_files(value = nil)
-        self.config.static_files = value if !value.nil?
-        self.config.static_files
-      end
-
-      def verbose_logging(value = nil)
-        self.config.verbose_logging = value if !value.nil?
-        self.config.verbose_logging
-      end
-
     end
 
     class Config
 
-      DEFAULT_ENV         = 'development'.freeze
-      DEFAULT_VIEWS_PATH  = 'views'.freeze
-      DEFAULT_PUBLIC_PATH = 'public'.freeze
-      DEFAULT_ENCODING    = 'utf-8'.freeze
-
-      attr_accessor :env, :root, :views_path, :public_path, :default_encoding
-      attr_accessor :settings, :template_helpers, :middlewares
-      attr_accessor :init_procs, :error_procs, :template_source, :logger, :router
+      DEFAULT_ENV = 'development'.freeze
 
-      attr_accessor :dump_errors, :method_override, :reload_templates
-      attr_accessor :sessions, :show_exceptions, :static_files
-      attr_accessor :verbose_logging
+      attr_accessor :env, :root
+      attr_accessor :method_override, :show_exceptions, :verbose_logging
+      attr_accessor :middlewares, :init_procs, :error_procs
+      attr_accessor :template_source, :logger, :router
 
       def initialize
-        @env              = DEFAULT_ENV
-        @root             = ENV['PWD']
-        @views_path       = DEFAULT_VIEWS_PATH
-        @public_path      = DEFAULT_PUBLIC_PATH
-        @default_encoding = DEFAULT_ENCODING
-        @settings         = {}
-        @template_helpers = []
-        @middlewares      = []
-        @init_procs       = []
-        @error_procs      = []
-        @template_source  = nil
-        @logger           = Deas::NullLogger.new
-        @router           = Deas::Router.new
-
-        @dump_errors      = false
-        @method_override  = true
-        @reload_templates = false
-        @sessions         = false
-        @show_exceptions  = false
-        @static_files     = true
-        @verbose_logging  = true
+        @env             = DEFAULT_ENV
+        @root            = ENV['PWD']
+        @method_override = true
+        @show_exceptions = false
+        @verbose_logging = true
+        @middlewares     = []
+        @init_procs      = []
+        @error_procs     = []
+        @template_source = nil
+        @logger          = Deas::NullLogger.new
+        @router          = Deas::Router.new
 
         @valid = nil
       end
 
-      def views_root
-        File.expand_path(@views_path.to_s, @root.to_s)
-      end
-
-      def public_root
-        File.expand_path(@public_path.to_s, @root.to_s)
-      end
-
       def template_source
         @template_source ||= Deas::NullTemplateSource.new(self.root)
       end
@@ -242,19 +161,26 @@ module Deas
       def validate!
         return @valid if !@valid.nil?  # only need to run this once per config
 
-        # ensure all user and plugin configs/settings are applied
+        # ensure all user and plugin configs are applied
         self.init_procs.each(&:call)
         raise Deas::ServerRootError if self.root.nil?
 
         # validate the router
         self.router.validate!
 
+        # TODO: build final middleware stack when building the rack app, not here
+        # (once Sinatra is removed)
+
+        # prepend the method override middleware first.  This ensures that the
+        # 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.
         self.middlewares << [Deas::ShowExceptions] if self.show_exceptions
-        logging_mw_args = [*Deas::Logging.middleware(self.verbose_logging)]
-        self.middlewares << logging_mw_args
+        self.middlewares << Deas::Logging.middleware_args(self.verbose_logging)
+        self.middlewares.freeze
 
         @valid = true # if it made it this far, its valid!
       end