deas 0.41.0 → 0.42.0

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
 SHA1: 
-  metadata.gz: 5e46a609344a9bab5fd5dd0aa922a7109258c2fb
-  data.tar.gz: 6b809e7cc1cc9c9fbfdf17115f88f00e06adbe0a
+  metadata.gz: 1105d3943d8f80cbcfd722a4fd5796b015fb7e0c
+  data.tar.gz: 4847313602ffd9942d2b287f36052c0946e03c06
 SHA512: 
-  metadata.gz: 6a4dd5daee23f0ebd8ae06588a15330ffa0fb57ca59fcf8027c7db0b3c3d7f0aba97251ceb6b098c954cb47a56c8c0aaa72b19f612c4ebb6108dac31b4dc6585
-  data.tar.gz: 53ab6f0f9d22a00248a4c3e195d3e553856d3e4cdd3e44f47d04c8d4c3343b3732761640b7e870f1d9d2d01004b61631e0999d3df02defbdbcf3908ef17e24ec
+  metadata.gz: 431fac2fe7deafdf9523882813e5caf34b57035b5077cf8152270503e6a0c914fa501015a47c5ead7d5c221d788e216389449a087c16167915ed82d769f9deab
+  data.tar.gz: 45cc5441925322a35fd7ad112ecf5b297113782ff14afb9d621b50735c6ee492ea163ec915e8b8cdef3d0b5da1d9653f0513f35a18aa8564855a6a9cf133b7a7

data/README.md

@@ -22,7 +22,7 @@ class HellowWorldHandler
   include Deas::ViewHandler
 
   def run!
-    "<h1>Hello World</h1>"
+    body "<h1>Hello World</h1>"
   end
 
 end

data/lib/deas/handler_proxy.rb

@@ -16,21 +16,28 @@ module Deas
     end
 
     def run(server_data, sinatra_call)
-      # these are not part of Deas' intended behavior and route matching
-      # they are side-effects of using Sinatra.  remove them so they won't
+      # 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(:splat)
-      sinatra_call.params.delete('splat')
       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
+
       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
+        :params          => sinatra_call.params,
+        :splat           => splat_value
       })
 
       runner.request.env.tap do |env|
@@ -45,6 +52,7 @@ module Deas
         # 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?
       end
 
       runner.run

data/lib/deas/router.rb

@@ -45,7 +45,11 @@ module Deas
     def url(name, path, options = nil)
       if !path.kind_of?(::String)
         raise ArgumentError, "invalid path `#{path.inspect}` - "\
-                             "can only provide a url name with String paths"
+                             "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 || {})
     end

data/lib/deas/runner.rb

@@ -15,7 +15,7 @@ module Deas
 
     attr_reader :handler_class, :handler
     attr_reader :logger, :router, :template_source
-    attr_reader :request, :session, :params
+    attr_reader :request, :session, :params, :splat
 
     def initialize(handler_class, args = nil)
       @status, @headers, @body = nil, Rack::Utils::HeaderHash.new, nil
@@ -27,6 +27,7 @@ module Deas
       @request         = args[:request]
       @session         = args[:session]
       @params          = args[:params] || {}
+      @splat           = args[:splat]
 
       @handler_class = handler_class
       @handler = @handler_class.new(self)

data/lib/deas/test_runner.rb

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

data/lib/deas/url.rb

@@ -23,7 +23,7 @@ module Deas
 
       h = params.dup # don't alter the given params
       c = h.delete(:captures) || h.delete('captures') || []
-      s = h.delete(:splat)    || h.delete('splat')    || []
+      s = h.delete(:splat)    || h.delete('splat')    || nil
       a = h.delete(:'#')      || h.delete('#')        || nil
 
       # ignore captures when setting params
@@ -33,10 +33,8 @@ module Deas
 
     private
 
-    def set_splat(path, params)
-      params.inject(path) do |path_string, value|
-        path_string.sub(/\*+/, value.to_s)
-      end
+    def set_splat(path, value)
+      path.sub(/\*+/, value.to_s)
     end
 
     def set_named(path, params)

data/lib/deas/version.rb

@@ -1,3 +1,3 @@
 module Deas
-  VERSION = "0.41.0"
+  VERSION = "0.42.0"
 end

data/lib/deas/view_handler.rb

@@ -67,6 +67,7 @@ module Deas
       def request; @deas_runner.request; end
       def session; @deas_runner.session; end
       def params;  @deas_runner.params;  end
+      def splat;   @deas_runner.splat;   end
 
       # response
       def status(*args);       @deas_runner.status(*args);       end

data/test/unit/handler_proxy_tests.rb

@@ -38,11 +38,13 @@ class Deas::HandlerProxy
 
       Assert.stub(@proxy, :handler_class){ EmptyViewHandler }
 
-      @server_data       = Factory.server_data
-      @fake_sinatra_call = Factory.sinatra_call
+      @server_data        = Factory.server_data
+      @fake_sinatra_call  = Factory.sinatra_call
+      @splat_sym_param    = Factory.string
+      @splat_string_param = Factory.string
       @fake_sinatra_call.params = {
-        :splat     => Factory.string,
-        'splat'    => Factory.string,
+        :splat     => [@splat_sym_param],
+        'splat'    => [@splat_string_param],
         :captures  => [Factory.string],
         'captures' => [Factory.string]
       }
@@ -65,13 +67,24 @@ class Deas::HandlerProxy
         :template_source => @server_data.template_source,
         :request         => @fake_sinatra_call.request,
         :session         => @fake_sinatra_call.session,
-        :params          => @fake_sinatra_call.params
+        :params          => @fake_sinatra_call.params,
+        :splat           => @splat_sym_param
       }
       assert_equal exp_args, @runner_spy.args
 
       assert_true @runner_spy.run_called
     end
 
+    should "prefer splat sym params over splat string params" do
+      assert_equal @splat_sym_param, @runner_spy.args[:splat]
+
+      @fake_sinatra_call.params['splat'] = [@splat_string_param]
+      proxy = Deas::HandlerProxy.new('EmptyViewHandler')
+      Assert.stub(proxy, :handler_class){ EmptyViewHandler }
+      proxy.run(@server_data, @fake_sinatra_call)
+      assert_equal @splat_string_param, @runner_spy.args[:splat]
+    end
+
     should "add data to the request env to make it available to Rack" do
       exp = subject.handler_class
       assert_equal exp, @fake_sinatra_call.request.env['deas.handler_class']
@@ -86,7 +99,8 @@ class Deas::HandlerProxy
     should "log the handler class name and the params" do
       exp_msgs = [
         "  Handler: #{subject.handler_class.name}",
-        "  Params:  #{@runner_spy.params.inspect}"
+        "  Params:  #{@runner_spy.params.inspect}",
+        "  Splat:   #{@runner_spy.splat.inspect}"
       ]
       assert_equal exp_msgs, @fake_sinatra_call.request.logging_msgs
     end
@@ -98,7 +112,7 @@ class Deas::HandlerProxy
     attr_reader :run_called
     attr_reader :handler_class, :handler, :args
     attr_reader :logger, :router, :template_source
-    attr_reader :request, :session, :params
+    attr_reader :request, :session, :params, :splat
 
     def initialize
       @run_called = false
@@ -115,6 +129,7 @@ class Deas::HandlerProxy
       @request         = args[:request]
       @session         = args[:session]
       @params          = args[:params]
+      @splat           = args[:splat]
     end
 
     def run

data/test/unit/router_tests.rb

@@ -402,6 +402,27 @@ class Deas::Router
       end
     end
 
+    should "complain if defining a url with invalid splats" do
+      assert_raises ArgumentError do
+        subject.url(:get_info, "/something/*/other/*")
+      end
+      assert_raises ArgumentError do
+        subject.url(:get_info, "/something/*/other")
+      end
+      assert_raises ArgumentError do
+        subject.url(:get_info, "/something/*/")
+      end
+      assert_raises ArgumentError do
+        subject.url(:get_info, "/*/something")
+      end
+      assert_nothing_raised do
+        subject.url(:get_info, "/something/*")
+      end
+      assert_nothing_raised do
+        subject.url(:get_info, "/*")
+      end
+    end
+
     should "build a path for a url given params" do
       exp_path = subject.prepend_base_url("/info/now")
       assert_equal exp_path, subject.url_for(:get_info, :for => 'now')

data/test/unit/runner_tests.rb

@@ -45,7 +45,7 @@ class Deas::Runner
 
     should have_readers :handler_class, :handler
     should have_readers :logger, :router, :template_source
-    should have_readers :request, :session, :params
+    should have_readers :request, :session, :params, :splat
     should have_imeths :run, :to_rack
     should have_imeths :status, :headers, :body, :content_type
     should have_imeths :halt, :redirect, :send_file
@@ -75,7 +75,8 @@ class Deas::Runner
         :template_source => 'a-source',
         :request         => 'a-request',
         :session         => 'a-session',
-        :params          => {}
+        :params          => {},
+        :splat           => 'a-splat'
       }
 
       runner = @runner_class.new(@handler_class, args)
@@ -86,6 +87,7 @@ class Deas::Runner
       assert_equal args[:request],         runner.request
       assert_equal args[:session],         runner.session
       assert_equal args[:params],          runner.params
+      assert_equal args[:splat],           runner.splat
     end
 
     should "not implement its run method" do

data/test/unit/test_runner_tests.rb

@@ -35,6 +35,7 @@ class Deas::TestRunner
         :request         => @request,
         :session         => Factory.string,
         :params          => @params,
+        :splat           => Factory.path,
         :custom_value    => Factory.integer
       }
 
@@ -63,6 +64,7 @@ class Deas::TestRunner
       assert_equal @args[:request],         subject.request
       assert_equal @args[:session],         subject.session
       assert_equal @args[:params],          subject.params
+      assert_equal @args[:splat],           subject.splat
     end
 
     should "call to normalize its params" do

data/test/unit/url_tests.rb

@@ -59,31 +59,31 @@ class Deas::Url
   class PathForTests < InitTests
     desc "when generating paths"
     setup do
-      @url = Deas::Url.new(:some_thing, '/:some/:thing/*/*')
-      @url_with_escape = Deas::Url.new(:some_thing, '/:some/:thing/*/*', {
+      @url = Deas::Url.new(:some_thing, '/:some/:thing/*')
+      @url_with_escape = Deas::Url.new(:some_thing, '/:some/:thing/*', {
         :escape_query_value => proc{ |v| Rack::Utils.escape(v) }
       })
     end
 
     should "generate given named params only" do
-      exp_path = "/a/goose/*/*"
+      exp_path = '/a/goose/'
       assert_equal exp_path, subject.path_for({
         'some' => 'a',
         :thing => 'goose'
       })
 
-      exp_path = "/a/goose/cooked-well/*"
+      exp_path = '/a/goose/cooked'
       assert_equal exp_path, subject.path_for({
         'some' => 'a',
         :thing => 'goose',
-        :splat => ['cooked-well']
+        :splat => 'cooked'
       })
 
-      exp_path = "/a/goose/cooked/well"
+      exp_path = '/a/goose/cooked'
       assert_equal exp_path, subject.path_for({
         'some'  => 'a',
         :thing  => 'goose',
-        'splat' => ['cooked', 'well']
+        'splat' => 'cooked'
       })
     end
 
@@ -105,95 +105,86 @@ class Deas::Url
     end
 
     should "not complain if given empty splat param values" do
-      exp_path = "/a/goose/"
+      exp_path = '/a/goose/'
       assert_equal exp_path, subject.path_for({
         'some'  => 'a',
         :thing  => 'goose',
-        'splat' => [nil, '']
+        'splat' => [nil, ''].sample
       })
     end
 
     should "append other (additional) params as query params" do
-      exp_path = "/a/goose/cooked/well?aye=a&bee=b"
+      exp_path = '/a/goose/cooked?aye=a&bee=b'
       assert_equal exp_path, subject.path_for({
         'some'  => 'a',
         :thing  => 'goose',
-        'splat' => ['cooked', 'well'],
+        'splat' => 'cooked',
         'bee'   => 'b',
         :aye    => 'a'
       })
     end
 
     should "escape query values when built with an escape query value proc" do
-      exp_path = "/a/goose/cooked/well?aye=a?a&a"
+      exp_path = '/a/goose/cooked?aye=a?a&a'
       assert_equal exp_path, subject.path_for({
         'some'  => 'a',
         :thing  => 'goose',
-        'splat' => ['cooked', 'well'],
+        'splat' => 'cooked',
         :aye    => 'a?a&a'
       })
 
-      exp_path = "/a/goose/cooked/well?aye=a%3Fa%26a"
+      exp_path = "/a/goose/cooked?aye=a%3Fa%26a"
       assert_equal exp_path, @url_with_escape.path_for({
         'some'  => 'a',
         :thing  => 'goose',
-        'splat' => ['cooked', 'well'],
+        'splat' => 'cooked',
         :aye    => 'a?a&a'
       })
     end
 
     should "ignore any 'captures'" do
-      exp_path = "/a/goose/cooked/well"
+      exp_path = '/a/goose/cooked'
       assert_equal exp_path, subject.path_for({
-        'some'  => 'a',
-        :thing  => 'goose',
-        'splat' => ['cooked', 'well'],
+        'some'     => 'a',
+        :thing     => 'goose',
+        'splat'    => 'cooked',
         'captures' => 'some-captures'
       })
     end
 
     should "append anchors" do
-      exp_path = "/a/goose/cooked/well#an-anchor"
+      exp_path = '/a/goose/cooked#an-anchor'
       assert_equal exp_path, subject.path_for({
         'some'  => 'a',
         :thing  => 'goose',
-        'splat' => ['cooked', 'well'],
+        'splat' => 'cooked',
         '#'     => 'an-anchor'
       })
     end
 
     should "ignore empty anchors" do
-      exp_path = "/a/goose/cooked/well"
-      assert_equal exp_path, subject.path_for({
-        'some'  => 'a',
-        :thing  => 'goose',
-        'splat' => ['cooked', 'well'],
-        '#'     => nil
-      })
-
-      exp_path = "/a/goose/cooked/well"
+      exp_path = '/a/goose/cooked'
       assert_equal exp_path, subject.path_for({
         'some'  => 'a',
         :thing  => 'goose',
-        'splat' => ['cooked', 'well'],
-        '#'     => ''
+        'splat' => 'cooked',
+        '#'     => [nil, ''].sample
       })
     end
 
     should "'squash' duplicate forward-slashes" do
-      exp_path = "/a/goose/cooked/well/"
+      exp_path = '/a/goose/cooked'
       assert_equal exp_path, subject.path_for({
         'some'  => '/a',
         :thing  => '/goose',
-        'splat' => ['///cooked', 'well//']
+        'splat' => '///cooked'
       })
     end
 
     should "not alter the given params" do
       params = {
         'some'    => 'thing',
-        :captures => ['captures'],
-        :splat    => ['splat'],
+        :splat    => 'splat',
         '#'       => 'anchor'
       }
       exp_params = params.dup

data/test/unit/view_handler_tests.rb

@@ -242,6 +242,11 @@ module Deas::ViewHandler
       assert_equal @runner.params, subject.instance_eval{ params }
     end
 
+    should "call to the runner for its splat" do
+      stub_runner_with_something_for(:splat)
+      assert_equal @runner.splat, subject.instance_eval{ splat }
+    end
+
     should "call to the runner for its status helper" do
       capture_runner_meth_args_for(:status)
       exp_args = @args

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: deas
 version: !ruby/object:Gem::Version 
-  version: 0.41.0
+  version: 0.42.0
 platform: ruby
 authors: 
 - Kelly Redding
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2016-06-15 00:00:00 Z
+date: 2016-09-01 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: assert