deas 0.17.1 → 0.18.0

data/lib/deas/logging.rb

@@ -57,7 +57,8 @@ module Deas
 
     RESPONSE_STATUS_NAMES = {
       200 => 'OK',
-      400 => 'BAD REQUEST' ,
+      302 => 'FOUND',
+      400 => 'BAD REQUEST',
       401 => 'UNAUTHORIZED',
       403 => 'FORBIDDEN',
       404 => 'NOT FOUND',
@@ -75,6 +76,7 @@ module Deas
       end
       env['deas.logging'] = Proc.new{ |msg| log(msg) }
       status, headers, body = super(env)
+      log "  Redir:   #{headers['Location']}" if headers.key?('Location')
       log "===== Completed in #{env['deas.time_taken']}ms (#{response_display(status)}) ====="
       [ status, headers, body ]
     end
@@ -93,14 +95,18 @@ module Deas
       env['deas.logging'] = Proc.new{ |msg| } # no-op
       status, headers, body = super(env)
       request = Rack::Request.new(env)
-      log SummaryLine.new({
+      line_attrs = {
         'method'  => request.request_method,
         'path'    => request.path,
         'handler' => env['deas.handler_class_name'],
         'params'  => env['sinatra.params'],
         'time'    => env['deas.time_taken'],
         'status'  => status
-      })
+      }
+      if headers.key?('Location')
+        line_attrs['redir'] = headers['Location']
+      end
+      log SummaryLine.new(line_attrs)
       [ status, headers, body ]
     end
 
@@ -108,10 +114,12 @@ module Deas
 
   module SummaryLine
     def self.keys
-      %w{time status method path handler params}
+      %w{time status method path handler params redir}
     end
     def self.new(line_attrs)
-      self.keys.map{ |k| "#{k}=#{line_attrs[k].inspect}" }.join(' ')
+      self.keys.select{ |k| line_attrs.key?(k) }.
+                map{ |k| "#{k}=#{line_attrs[k].inspect}"  }.
+                join(' ')
     end
   end
 

data/lib/deas/redirect_proxy.rb

@@ -1,4 +1,5 @@
 require 'deas/view_handler'
+require 'deas/url'
 
 module Deas
   class RedirectProxy
@@ -16,12 +17,25 @@ module Deas
 
         def self.name; 'Deas::RedirectHandler'; end
 
+        attr_reader :redirect_path
+
+        def init!
+          @redirect_path = self.instance_eval(&self.class.redirect_path)
+        end
+
         def run!
-          redirect self.instance_eval(&self.class.redirect_path)
+          redirect @redirect_path
         end
 
       end
-      @handler_class.redirect_path = path ? proc{ path } : block
+
+      @handler_class.redirect_path = if path.nil?
+        block
+      elsif path.kind_of?(Deas::Url)
+        proc{ path.path_for(params) }
+      else
+        proc{ path }
+      end
       @handler_class_name = @handler_class.name
     end
 

data/lib/deas/server.rb

@@ -1,13 +1,14 @@
-require 'ns-options'
-require 'ns-options/boolean'
 require 'pathname'
 require 'set'
+require 'ns-options'
+require 'ns-options/boolean'
 require 'deas/exceptions'
 require 'deas/template'
 require 'deas/logging'
 require 'deas/redirect_proxy'
 require 'deas/route_proxy'
 require 'deas/route'
+require 'deas/url'
 require 'deas/show_exceptions'
 require 'deas/sinatra_app'
 
@@ -17,7 +18,8 @@ module Deas::Server
   class Configuration
     include NsOptions::Proxy
 
-    # Sinatra based options
+    # Sinatra-based options
+
     option :env,  String,   :default => 'development'
 
     option :root,          Pathname, :required => true
@@ -30,19 +32,16 @@ module Deas::Server
     option :show_exceptions,  NsOptions::Boolean, :default => false
     option :static_files,     NsOptions::Boolean, :default => true
     option :reload_templates, NsOptions::Boolean, :default => false
+    option :default_charset,  String,             :default => 'utf-8'
 
     # server handling options
-    option :error_procs,     Array,  :default => []
-    option :init_procs,      Array,  :default => []
-    option :logger,                  :default => proc{ Deas::NullLogger.new }
-    option :middlewares,     Array,  :default => []
-    option :settings,        Hash,   :default => {}
-    option :verbose_logging,         :default => true
-    option :routes,          Array,  :default => []
+
+    option :logger,                              :default => proc{ Deas::NullLogger.new }
+    option :verbose_logging, NsOptions::Boolean, :default => true
     option :view_handler_ns, String
-    option :default_charset, String, :default => 'utf-8'
 
-    attr_reader :template_helpers
+    attr_accessor :settings, :error_procs, :init_procs, :template_helpers
+    attr_accessor :middlewares, :routes, :urls
 
     def initialize(values=nil)
       # these are defaulted here because we want to use the Configuration
@@ -53,7 +52,9 @@ module Deas::Server
         :public_folder => proc{ self.root.join('public') },
         :views_folder  => proc{ self.root.join('views') }
       }))
-      @template_helpers = []
+      @settings, @urls = {}, {}
+      @error_procs, @init_procs, @template_helpers = [], [], []
+      @middlewares, @routes = [], []
       @valid = nil
     end
 
@@ -101,6 +102,10 @@ module Deas::Server
       Deas::Route.new(http_method, path, proxy).tap{ |r| self.routes.push(r) }
     end
 
+    def add_url(name, path)
+      self.urls[name] = Deas::Url.new(name, path)
+    end
+
   end
 
   def self.included(receiver)
@@ -202,39 +207,59 @@ module Deas::Server
       self.configuration.default_charset *args
     end
 
-    def get(path, handler_class_name)
-      self.route(:get, path, handler_class_name)
+    def get(path, handler_class_name, url_name = nil)
+      self.route(:get, path, handler_class_name, url_name)
     end
 
-    def post(path, handler_class_name)
-      self.route(:post, path, handler_class_name)
+    def post(path, handler_class_name, url_name = nil)
+      self.route(:post, path, handler_class_name, url_name)
     end
 
-    def put(path, handler_class_name)
-      self.route(:put, path, handler_class_name)
+    def put(path, handler_class_name, url_name = nil)
+      self.route(:put, path, handler_class_name, url_name)
     end
 
-    def patch(path, handler_class_name)
-      self.route(:patch, path, handler_class_name)
+    def patch(path, handler_class_name, url_name = nil)
+      self.route(:patch, path, handler_class_name, url_name)
     end
 
-    def delete(path, handler_class_name)
-      self.route(:delete, path, handler_class_name)
+    def delete(path, handler_class_name, url_name = nil)
+      self.route(:delete, path, handler_class_name, url_name)
     end
 
     def redirect(http_method, path, to_path = nil, &block)
-      proxy = Deas::RedirectProxy.new(to_path, &block)
+      url = self.configuration.urls[to_path]
+      if to_path.kind_of?(::Symbol) && url.nil?
+        raise ArgumentError, "no url named `#{to_path.inspect}`"
+      end
+      proxy = Deas::RedirectProxy.new(url || to_path, &block)
       self.configuration.add_route(http_method, path, proxy)
     end
 
-    def route(http_method, path, handler_class_name)
+    def route(http_method, path, handler_class_name, url_name = nil)
       if self.view_handler_ns && !(handler_class_name =~ /^::/)
         handler_class_name = "#{self.view_handler_ns}::#{handler_class_name}"
       end
       proxy = Deas::RouteProxy.new(handler_class_name)
+
+      if url_name && !url_name.to_s.empty?
+        if !path.kind_of?(::String)
+          raise ArgumentError, "invalid path `#{path.inspect}` - "\
+                               "can only provide a url name with String paths"
+        end
+        self.configuration.add_url(url_name.to_sym, path)
+      end
       self.configuration.add_route(http_method, path, proxy)
     end
 
+    def url(name, *args)
+      url = self.configuration.urls[name.to_sym]
+      raise ArgumentError, "no route named `#{name.to_sym.inspect}`" unless url
+
+      url.path_for(*args)
+    end
+
   end
 
 end
+

data/lib/deas/url.rb

@@ -0,0 +1,33 @@
+module Deas
+  class Url
+
+    attr_reader :name, :path
+
+    def initialize(name, path)
+      @name, @path = name, path
+    end
+
+    def path_for(*args)
+      named, ordered = [
+        args.last.kind_of?(::Hash) ? args.pop : {},
+        args
+      ]
+      apply_ordered_params(apply_named_params(@path, named), ordered)
+    end
+
+    private
+
+    def apply_named_params(path, params)
+      # ignore captures in applying params
+      captures   = params.delete(:captures) || params.delete('captures') || []
+      splat      = params.delete(:splat)    || params.delete('splat')    || []
+      splat_path = splat.inject(path){ |p, v| p.sub(/\*+/, v.to_s) }
+      params.inject(splat_path){ |p, (k, v)| p.gsub(":#{k}", v.to_s) }
+    end
+
+    def apply_ordered_params(path, params)
+      params.inject(path){ |p, v| p.sub(/\*+|\:\w+/i, v.to_s) }
+    end
+
+  end
+end

data/lib/deas/version.rb

@@ -1,3 +1,3 @@
 module Deas
-  VERSION = "0.17.1"
+  VERSION = "0.18.0"
 end

data/test/unit/logging_tests.rb

@@ -50,21 +50,37 @@ module Deas::Logging
     subject{ Deas::SummaryLine }
 
     should "output its attributes in a specific order" do
-      assert_equal %w{time status method path handler params}, subject.keys
+      assert_equal %w{time status method path handler params redir}, subject.keys
     end
 
     should "output its attributes in a single line" do
       line_attrs = {
-        'time' => 't',
-        'status' => 's',
-        'method' => 'm',
-        'path' => 'pth',
+        'time'    => 't',
+        'status'  => 's',
+        'method'  => 'm',
+        'path'    => 'pth',
         'handler' => 'h',
-        'params' => 'p',
+        'params'  => 'p',
+        'redir'   => 'r'
       }
       exp_line = "time=\"t\" "\
                  "status=\"s\" "\
                  "method=\"m\" "\
+                 "path=\"pth\" "\
+                 "handler=\"h\" "\
+                 "params=\"p\" "\
+                 "redir=\"r\""
+      assert_equal exp_line, subject.new(line_attrs)
+    end
+
+    should "only output keys if data exists for them" do
+      line_attrs = {
+        'status'  => 's',
+        'path'    => 'pth',
+        'handler' => 'h',
+        'params'  => 'p'
+      }
+      exp_line = "status=\"s\" "\
                  "path=\"pth\" "\
                  "handler=\"h\" "\
                  "params=\"p\""

data/test/unit/redirect_proxy_tests.rb

@@ -20,13 +20,15 @@ class Deas::RedirectProxy
   end
 
   class HandlerClassTests < BaseTests
-    desc "handler class"
+    include Deas::TestHelpers
+
+    desc "redir handler class"
     setup do
       @handler_class = @proxy.handler_class
     end
     subject{ @handler_class }
 
-    should have_accessors :redirect_path
+    should have_accessor :redirect_path
     should have_imeth :name
 
     should "be a view handler" do
@@ -39,41 +41,63 @@ class Deas::RedirectProxy
       assert_equal 'Deas::RedirectHandler', subject.name
     end
 
-    should "know its redirect path" do
-      assert_instance_of Proc, subject.redirect_path
-      assert_equal '/somewhere', subject.redirect_path.call
-    end
+    should "store its redirect path as a proc" do
+      assert_kind_of Proc, subject.redirect_path
 
-    should "allow specifying the redir path as a block" do
-      path_proc = proc{ '/somewhere' }
+      url = Deas::Url.new(:some_thing, '/:some/:thing')
+      handler_class = Deas::RedirectProxy.new(url).handler_class
+      assert_kind_of Proc, handler_class.redirect_path
 
+      path_proc = proc{ '/somewhere' }
       handler_class = Deas::RedirectProxy.new(&path_proc).handler_class
-      assert_equal path_proc, handler_class.redirect_path
-      assert_equal '/somewhere', subject.redirect_path.call
+      assert_kind_of Proc, handler_class.redirect_path
     end
 
   end
 
-  class RunTests < HandlerClassTests
-    include Deas::TestHelpers
+  class HandlerTests < HandlerClassTests
+    desc "redir handler instance"
+    setup do
+      @handler = test_handler(@handler_class)
+    end
+    subject{ @handler }
 
-    desc "when run"
+    should have_reader :redirect_path
 
-    should "redirect to the path that it was build with" do
-      render_args = test_runner(subject).run
-      assert_equal true,         render_args.redirect?
-      assert_equal '/somewhere', render_args.path
+    should "know its redir path if from a path string" do
+      assert_equal '/somewhere', subject.redirect_path
     end
 
-    should "redirect to the path returned from instance evaling the proc" do
-      path_proc = proc{ params['redirect_to'] }
-      handler_class = Deas::RedirectProxy.new(&path_proc).handler_class
+    should "know its redir path if from Url" do
+      url = Deas::Url.new(:some_thing, '/:some/:thing')
+      handler_class = Deas::RedirectProxy.new(url).handler_class
+      handler = test_handler(handler_class, {
+        :params => { 'some' => 'a', 'thing' => 'goose' }
+      })
+
+      assert_equal '/a/goose', handler.redirect_path
+    end
+
+    should "know its redir path if from a block" do
+      handler_class = Deas::RedirectProxy.new(&proc{'/from-block-arg'}).handler_class
+      handler = test_handler(handler_class)
+
+      assert_equal '/from-block-arg', handler.redirect_path
+    end
+
+  end
+
+  class RunTests < HandlerClassTests
+    desc "when run"
+    setup do
+      @runner = test_runner(@handler_class)
+      @handler = @runner.handler
+      @render_args = @runner.run
+    end
 
-      render_args = test_runner(handler_class, {
-        :params => { 'redirect_to' => '/go_here' }
-      }).run
-      assert_equal true,       render_args.redirect?
-      assert_equal '/go_here', render_args.path
+    should "redirect to the handler's redirect path" do
+      assert @render_args.redirect?
+      assert_equal @handler.redirect_path, @render_args.path
     end
 
   end

data/test/unit/server_configuration_tests.rb

@@ -16,17 +16,19 @@ class Deas::Server::Configuration
     end
     subject{ @configuration }
 
-    # sinatra related options
+    # sinatra-based options
+
     should have_imeths :env, :root, :public_folder, :views_folder
     should have_imeths :dump_errors, :method_override, :sessions, :show_exceptions
-    should have_imeths :static_files, :reload_templates
+    should have_imeths :static_files, :reload_templates, :default_charset
 
     # server handling options
-    should have_imeths :error_procs, :init_procs, :logger, :middlewares, :settings
-    should have_imeths :verbose_logging, :routes, :view_handler_ns, :default_charset
 
-    should have_reader :template_helpers
-    should have_imeths :valid?, :validate!
+    should have_imeths :logger, :verbose_logging, :view_handler_ns
+
+    should have_accessors :settings, :error_procs, :init_procs, :template_helpers
+    should have_accessors :middlewares, :routes, :urls
+    should have_imeths :valid?, :validate!, :template_scope, :add_route
 
     should "default the env to 'development'" do
       assert_equal 'development', subject.env
@@ -47,15 +49,19 @@ class Deas::Server::Configuration
     end
 
     should "default the handling options" do
+      assert_instance_of Deas::NullLogger, subject.logger
+      assert_equal true, subject.verbose_logging
+      assert_nil subject.view_handler_ns
+    end
+
+    should "default its stored configuration" do
+      assert_empty subject.settings
       assert_empty subject.error_procs
       assert_empty subject.init_procs
-      assert_instance_of Deas::NullLogger, subject.logger
+      assert_empty subject.template_helpers
       assert_empty subject.middlewares
-      assert_empty subject.settings
-      assert_equal true, subject.verbose_logging
       assert_empty subject.routes
-      assert_nil   subject.view_handler_ns
-      assert_empty subject.template_helpers
+      assert_empty subject.urls
     end
 
     should "build a template scope including its template helpers" do
@@ -102,8 +108,8 @@ class Deas::Server::Configuration
         c.show_exceptions  = true
         c.static           = true
         c.reload_templates = true
-        c.routes           = [ @route ]
         c.middlewares      = [ ['MyMiddleware'] ]
+        c.routes           = [ @route ]
       end
       @configuration.init_procs << proc{ @initialized = true }
       @configuration.init_procs << proc{ @other_initialized = true }

data/test/unit/server_tests.rb

@@ -15,16 +15,16 @@ module Deas::Server
 
     should have_imeths :new, :configuration
 
-    # DSL for sinatra settings
+    # DSL for sinatra-based settings
     should have_imeths :env, :root, :public_folder, :views_folder
     should have_imeths :dump_errors, :method_override, :sessions, :show_exceptions
-    should have_imeths :static_files, :reload_templates
+    should have_imeths :static_files, :reload_templates, :default_charset
 
-    # DSL for server handling
+    # DSL for server handling settings
     should have_imeths :init, :error, :template_helpers, :template_helper?
     should have_imeths :use, :set, :view_handler_ns, :verbose_logging, :logger
-    should have_imeths :default_charset
-    should have_imeths :get, :post, :put, :patch, :delete, :redirect, :route
+    should have_imeths :get, :post, :put, :patch, :delete
+    should have_imeths :redirect, :route, :url
 
     should "allow setting it's configuration options" do
       config = subject.configuration
@@ -176,6 +176,64 @@ module Deas::Server
       assert_equal 'GetInfo',   route.handler_proxy.handler_class_name
     end
 
+    should "not define urls for routes created with no url name" do
+      assert_empty subject.configuration.urls
+
+      @server_class.route(:get, '/info', 'GetInfo')
+      assert_empty subject.configuration.urls
+
+      @server_class.route(:get, '/info', 'GetInfo', nil)
+      assert_empty subject.configuration.urls
+
+      @server_class.route(:get, '/info', 'GetInfo', '')
+      assert_empty subject.configuration.urls
+
+      @server_class.route(:get, '/info', 'GetInfo', 'get_info')
+      assert_not_empty subject.configuration.urls
+    end
+
+  end
+
+  class NamedUrlTests < BaseTests
+    desc "when defining a route with a url name"
+    setup do
+      @server_class.route(:get, '/info/:for', 'GetInfo', 'get_info')
+    end
+
+    should "define a url for the route on the server" do
+      url = subject.configuration.urls[:get_info]
+
+      assert_not_nil url
+      assert_kind_of Deas::Url, url
+      assert_equal :get_info, url.name
+      assert_equal '/info/:for', url.path
+    end
+
+    should "complain if given a non-string path" do
+      assert_raises ArgumentError do
+        subject.route(:get, /^\/info/, 'GetInfo', 'get_info')
+      end
+    end
+
+    should "build a path for a url given params" do
+      exp_path = "/info/now"
+
+      assert_equal exp_path, subject.url(:get_info, :for => 'now')
+      assert_equal exp_path, subject.url(:get_info, 'now')
+    end
+
+    should "complain if building a named url that hasn't been defined" do
+      assert_raises ArgumentError do
+        subject.url(:get_all_info, 'now')
+      end
+    end
+
+    should "complain if redirecting to a named url that hasn't been defined" do
+      assert_raises ArgumentError do
+        subject.redirect(:get, '/somewhere', :not_defined_url)
+      end
+    end
+
   end
 
 end

data/test/unit/sinatra_app_tests.rb

@@ -58,7 +58,7 @@ module Deas::SinatraApp
 
     should "define Sinatra routes for every route in the configuration" do
       get_routes = subject.routes[@route.method.to_s.upcase] || []
-      sinatra_route = get_routes.detect{|route| route[0].match(@route.path) }
+      sinatra_route = get_routes.detect{ |route| route[0].match(@route.path) }
 
       assert_not_nil sinatra_route
     end

data/test/unit/url_tests.rb

@@ -0,0 +1,90 @@
+require 'assert'
+require 'deas/url'
+
+require 'test/support/view_handlers'
+
+class Deas::Url
+
+  class BaseTests < Assert::Context
+    desc "Deas::Url"
+    setup do
+      @url = Deas::Url.new(:get_info, '/info')
+    end
+    subject{ @url }
+
+    should have_readers :name, :path
+    should have_imeth :path_for
+
+    should "know its name and path info" do
+      assert_equal :get_info, subject.name
+      assert_equal '/info', subject.path
+    end
+
+  end
+
+  class PathForTests < BaseTests
+    desc "when generating paths"
+    setup do
+      @url = Deas::Url.new(:some_thing, '/:some/:thing/*/*')
+    end
+
+    should "generate given named params only" do
+      exp_path = "/a/goose/*/*"
+      assert_equal exp_path, subject.path_for({
+        'some' => 'a',
+        :thing => 'goose'
+      })
+
+      exp_path = "/a/goose/cooked-well/*"
+      assert_equal exp_path, subject.path_for({
+        'some' => 'a',
+        :thing => 'goose',
+        :splat => ['cooked-well']
+      })
+
+      exp_path = "/a/goose/cooked/well"
+      assert_equal exp_path, subject.path_for({
+        'some'  => 'a',
+        :thing  => 'goose',
+        'splat' => ['cooked', 'well']
+      })
+    end
+
+    should "generate given ordered params only" do
+      exp_path = "/a/:thing/*/*"
+      assert_equal exp_path, subject.path_for('a')
+
+      exp_path = "/a/goose/*/*"
+      assert_equal exp_path, subject.path_for('a', 'goose')
+
+      exp_path = "/a/goose/cooked-well/*"
+      assert_equal exp_path, subject.path_for('a', 'goose', 'cooked-well')
+
+      exp_path = "/a/goose/cooked/well"
+      assert_equal exp_path, subject.path_for('a', 'goose', 'cooked', 'well')
+    end
+
+    should "generate given mixed ordered and named params" do
+      exp_path = "/:some/:thing/*/*"
+      assert_equal exp_path, subject.path_for
+
+      exp_path = "/a/goose/*/*"
+      assert_equal exp_path, subject.path_for('a', 'thing' => 'goose')
+
+      exp_path = "/goose/a/well/*"
+      assert_equal exp_path, subject.path_for('a', 'well', 'some' => 'goose')
+    end
+
+    should "pass on this" do
+
+      exp_path = "/a/goose/cooked/well"
+      assert_equal exp_path, subject.path_for('ignore', 'these', 'params', {
+        'some'  => 'a',
+        :thing  => 'goose',
+        'splat' => ['cooked', 'well']
+      })
+    end
+
+  end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: deas
 version: !ruby/object:Gem::Version 
-  hash: 89
+  hash: 87
   prerelease: 
   segments: 
   - 0
-  - 17
-  - 1
-  version: 0.17.1
+  - 18
+  - 0
+  version: 0.18.0
 platform: ruby
 authors: 
 - Kelly Redding
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-06-19 00:00:00 Z
+date: 2013-07-10 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: ns-options
@@ -161,6 +161,7 @@ files:
 - lib/deas/template.rb
 - lib/deas/test_helpers.rb
 - lib/deas/test_runner.rb
+- lib/deas/url.rb
 - lib/deas/version.rb
 - lib/deas/view_handler.rb
 - log/.gitkeep
@@ -197,6 +198,7 @@ files:
 - test/unit/sinatra_app_tests.rb
 - test/unit/sinatra_runner_tests.rb
 - test/unit/template_tests.rb
+- test/unit/url_tests.rb
 - test/unit/view_handler_tests.rb
 - tmp/.gitkeep
 homepage: http://github.com/redding/deas
@@ -266,4 +268,5 @@ test_files:
 - test/unit/sinatra_app_tests.rb
 - test/unit/sinatra_runner_tests.rb
 - test/unit/template_tests.rb
+- test/unit/url_tests.rb
 - test/unit/view_handler_tests.rb