pendragon 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4e7cbea66f8dd29316768cfb0fe023d1406a8b64
-  data.tar.gz: 0e01b51a0a24b2ee596bf4f01d228a9885b49269
+  metadata.gz: 89f0b037692dd728f51329a2cc4df730582d0480
+  data.tar.gz: 20859c54d93fa69ff145d11d052600b60245ffd9
 SHA512:
-  metadata.gz: 2010774c84e8aa9c33c4190c69e068b9e1d318dada14316dcaa4a3550a7363544626a2d77a791269ec0ec86426bd9c7542f5013f96340c020afdba74027d8cbe
-  data.tar.gz: 62dd9579a534ded3447bc6de68503cfcd6e70e56db1df11802c3bcb1abc26ac5274e332b083b33b0c96033e434427cac2e9f38bd70ff114de4a2228811da14ee
+  metadata.gz: e7226f8f044f7310cd4de904661c2cfeda0ac66169d691363f905718498db5cae9f44bf4d857f585a1c4547d9b1de8356763ef6e5414245724f4e4a2031063a7
+  data.tar.gz: 80b0c5acd5492211707c5e7c3fd5f0bb3b3fba6adadd5863e641dca640ca544752e5ff7fdfa97ad87a5de58a292f68c7dc3c048bdc3090a8e61dae5e1d524678

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pendragon (0.5.1)
+    pendragon (0.6.0)
       mustermann (= 0.2.0)
       rack (>= 1.3.0)
 

data/lib/pendragon/padrino/ext/class_methods.rb

@@ -36,26 +36,21 @@ module Pendragon
       end
 
       def url(*args)
-        params = args.extract_options! # parameters is hash at end
-        names, params_array = args.partition{|a| a.is_a?(Symbol)}
-        name = names[0, 2].join(" ").to_sym # route name is concatenated with underscores
-        if params.is_a?(Hash)
-          params[:format] = params[:format].to_s unless params[:format].nil?
-          params = value_to_param(params)
-        end
-        url =
-          if params_array.empty?
-            compiled_router.path(name, params)
-          else
-            compiled_router.path(name, *(params_array << params))
-          end
-        rebase_url(url)
-      rescue Pendragon::InvalidRouteException
-        route_error = "route mapping for url(#{name.inspect}) could not be found!"
-        raise ::Padrino::Routing::UnrecognizedException.new(route_error)
+        params = args.extract_options!
+        fragment = params.delete(:fragment) || params.delete(:anchor)
+        path = make_path_with_params(args, value_to_param(params.symbolize_keys))
+        rebase_url(fragment ? path << '#' << fragment : path)
       end
       alias :url_for :url
 
+      def make_path_with_params(args, params)
+        names, params_array = args.partition{ |arg| arg.is_a?(Symbol) }
+        name = names[0, 2].join(" ").to_sym
+        compiled_router.path(name, *(params_array << params))
+      rescue Pendragon::InvalidRouteException
+        raise ::Padrino::Routing::UnrecognizedException, "Route mapping for url(#{name.inspect}) could not be found"
+      end
+
       def recognize_path(path)
         responses = @router.recognize_path(path)
         [responses[0], responses[1]]
@@ -64,8 +59,8 @@ module Pendragon
       def rebase_url(url)
         if url.start_with?('/')
           new_url = ''
-          new_url << conform_uri(uri_root) if defined?(uri_root)
           new_url << conform_uri(ENV['RACK_BASE_URI']) if ENV['RACK_BASE_URI']
+          new_url << conform_uri(uri_root) if defined?(uri_root)
           new_url << url
         else
           url.blank? ? '/' : url
@@ -92,9 +87,11 @@ module Pendragon
 
         route_options = options.dup
         route_options[:provides] = @_provides if @_provides
+        route_options[:accepts] = @_accepts if @_accepts
+        route_options[:params] = @_params unless @_params.nil? || route_options.include?(:params)
 
-        if allow_disabled_csrf
-          unless route_options[:csrf_protection] == false
+        if protect_from_csrf && (report_csrf_failure || allow_disabled_csrf)
+          unless route_options.has_key?(:csrf_protection)
             route_options[:csrf_protection] = true
           end
         end
@@ -158,6 +155,13 @@ module Pendragon
       def parse_route(path, options, verb)
         route_options = {}
 
+        if options[:params] == true
+          options.delete(:params)
+        elsif options.include?(:params)
+          options[:params] ||= []
+          options[:params] += options[:with] if options[:with]
+        end
+
         # We need check if path is a symbol, if that it's a named route.
         map = options.delete(:map)
 

data/lib/pendragon/router.rb

@@ -127,7 +127,7 @@ module Pendragon
     # @return [Array]
     def recognize_path(path_info)
       route, params = recognize(Rack::MockRequest.env_for(path_info)).first
-      [route.name, params.inject({}){|hash, (key, value)| hash[key.to_sym] = value; hash }]
+      [route.name, params.inject({}){|hash, (key, value)| hash[key] = value; hash }]
     end
 
     # Returns an expanded path matched with the conditions as arguments

data/lib/pendragon/version.rb

@@ -1,4 +1,4 @@
 
 module Pendragon
-  VERSION = '0.6.0'
+  VERSION = '0.6.1'
 end

data/test/padrino_test.rb

@@ -1,5 +1,6 @@
 require File.expand_path('../../lib/pendragon/padrino', __FILE__)
 $:.unshift(File.dirname(__FILE__))
+require 'active_support/core_ext/hash/conversions'
 require 'helper'
 
 class FooError < RuntimeError; end
@@ -8,6 +9,7 @@ describe "Pendragon::Padrino" do
   setup do
     Padrino::Application.send(:register, Pendragon::Padrino)
     Padrino::Rendering::DEFAULT_RENDERING_OPTIONS[:strict_format] = false
+    ENV['RACK_BASE_URI'] = nil
   end
 
   should "serve static files with simple cache control" do
@@ -824,6 +826,18 @@ describe "Pendragon::Padrino" do
     ENV['RACK_BASE_URI'] = nil
   end
 
+  it 'should use uri_root and RACK_BASE_URI' do
+    mock_app do
+      controller :foo do
+        get(:bar){ "bar" }
+      end
+    end
+    ENV['RACK_BASE_URI'] = '/base'
+    @app.uri_root = 'testing'
+    assert_equal '/base/testing/foo/bar', @app.url(:foo, :bar)
+    ENV['RACK_BASE_URI'] = nil
+  end
+
   should 'reset routes' do
     mock_app do
       get("/"){ "foo" }
@@ -1882,14 +1896,14 @@ describe "Pendragon::Padrino" do
       get(:simple, :map => "/simple/:id") { }
       get(:with_format, :with => :id, :provides => :js) { }
     end
-    assert_equal [:"foo bar", { :id => "fantastic" }], @app.recognize_path(@app.url(:foo, :bar, :id => :fantastic))
-    assert_equal [:"foo bar", { :id => "18" }], @app.recognize_path(@app.url(:foo, :bar, :id => 18))
-    assert_equal [:simple, { :id => "bar" }], @app.recognize_path(@app.url(:simple, :id => "bar"))
-    assert_equal [:simple, { :id => "true" }], @app.recognize_path(@app.url(:simple, :id => true))
-    assert_equal [:simple, { :id => "9" }], @app.recognize_path(@app.url(:simple, :id => 9))
-    assert_equal [:with_format, { :id => "bar", :format => "js" }], @app.recognize_path(@app.url(:with_format, :id => "bar", :format => :js))
-    assert_equal [:with_format, { :id => "true", :format => "js" }], @app.recognize_path(@app.url(:with_format, :id => true, :format => "js"))
-    assert_equal [:with_format, { :id => "9", :format => "js" }], @app.recognize_path(@app.url(:with_format, :id => 9, :format => :js))
+    assert_equal [:"foo bar", { :id => "fantastic" }.with_indifferent_access], @app.recognize_path(@app.url(:foo, :bar, :id => :fantastic))
+    assert_equal [:"foo bar", { :id => "18" }.with_indifferent_access], @app.recognize_path(@app.url(:foo, :bar, :id => 18))
+    assert_equal [:simple, { :id => "bar" }.with_indifferent_access], @app.recognize_path(@app.url(:simple, :id => "bar"))
+    assert_equal [:simple, { :id => "true" }.with_indifferent_access], @app.recognize_path(@app.url(:simple, :id => true))
+    assert_equal [:simple, { :id => "9" }.with_indifferent_access], @app.recognize_path(@app.url(:simple, :id => 9))
+    assert_equal [:with_format, { :id => "bar", :format => "js" }.with_indifferent_access], @app.recognize_path(@app.url(:with_format, :id => "bar", :format => :js))
+    assert_equal [:with_format, { :id => "true", :format => "js" }.with_indifferent_access], @app.recognize_path(@app.url(:with_format, :id => true, :format => "js"))
+    assert_equal [:with_format, { :id => "9", :format => "js" }.with_indifferent_access], @app.recognize_path(@app.url(:with_format, :id => 9, :format => :js))
   end
 
   should 'have current_path' do
@@ -1939,4 +1953,160 @@ describe "Pendragon::Padrino" do
     get '/users//'
     assert_equal 404, status
   end
+  describe "Padrino::ParamsProtection" do
+    before do
+      @teri = { 'name' => 'Teri Bauer', 'position' => 'baby' }
+      @kim = { 'name' => 'Kim Bauer', 'position' => 'daughter', 'child' => @teri }
+      @jack = { 'name' => 'Jack Bauer', 'position' => 'terrorist', 'child' => @kim }
+      @family = { 'name' => 'Bauer', 'persons' => { 1 => @teri, 2 => @kim, 3 => @jack } }
+    end
+
+    it 'should drop all parameters except allowed ones' do
+      result = nil
+      mock_app do
+        post :basic, :params => [ :name ] do
+          result = params
+          ''
+        end
+      end
+      post '/basic?' + @jack.to_query
+      assert_equal({ 'name' => @jack['name'] }, result)
+    end
+
+    it 'should preserve original params' do
+      result = nil
+      mock_app do
+        post :basic, :params => [ :name ] do
+          result = original_params
+          ''
+        end
+      end
+      post '/basic?' + @jack.to_query
+      assert_equal(@jack, result)
+    end
+
+    it 'should work with recursive data' do
+      result = nil
+      mock_app do
+        post :basic, :params => [ :name, :child => [ :name, :child => [ :name ] ] ] do
+          result = [params, original_params]
+          ''
+        end
+      end
+      post '/basic?' + @jack.to_query
+      assert_equal(
+        [
+          { 'name' => @jack['name'], 'child' => { 'name' => @kim['name'], 'child' => { 'name' => @teri['name'] } } },
+          @jack
+        ],
+        result
+      )
+    end
+
+    it 'should be able to process the data' do
+      result = nil
+      mock_app do
+        post :basic, :params => [ :name, :position => proc{ |v| 'anti-'+v } ] do
+          result = params
+          ''
+        end
+      end
+      post '/basic?' + @jack.to_query
+      assert_equal({ 'name' => @jack['name'], 'position' => 'anti-terrorist' }, result)
+    end
+
+    it 'should pass :with parameters' do
+      result = nil
+      mock_app do
+        post :basic, :with => [:id, :tag], :params => [ :name ] do
+          result = params
+          ''
+        end
+      end
+      post '/basic/24/42?' + @jack.to_query
+      assert_equal({ 'name' => @jack['name'], 'id' => '24', 'tag' => '42' }, result)
+    end
+
+    it 'should understand true or false values' do
+      result = nil
+      mock_app do
+        get :hide, :with => [ :id ], :params => false do
+          result = params
+          ''
+        end
+        get :show, :with => [ :id ], :params => true do
+          result = params
+          ''
+        end
+      end
+      get '/hide/1?' + @jack.to_query
+      assert_equal({"id"=>"1"}, result)
+      get '/show/1?' + @jack.to_query
+      assert_equal({"id"=>"1"}.merge(@jack), result)
+    end
+
+    it 'should be configurable with controller options' do
+      result = nil
+      mock_app do
+        controller :persons, :params => [ :name ] do
+          post :create, :params => [ :name, :position ] do
+            result = params
+            ''
+          end
+          post :update, :with => [ :id ] do
+            result = params
+            ''
+          end
+          post :delete, :params => true do
+            result = params
+            ''
+          end
+          post :destroy, :with => [ :id ], :params => false do
+            result = params
+            ''
+          end
+        end
+        controller :noparam, :params => false do
+          get :index do
+            result = params
+            ''
+          end
+        end
+      end
+      post '/persons/create?' + @jack.to_query
+      assert_equal({ 'name' => @jack['name'], 'position' => 'terrorist' }, result)
+      post '/persons/update/1?name=Chloe+O\'Brian&position=hacker'
+      assert_equal({ 'id' => '1', 'name' => 'Chloe O\'Brian' }, result)
+      post '/persons/delete?' + @jack.to_query
+      assert_equal(@jack, result)
+      post '/persons/destroy/1?' + @jack.to_query
+      assert_equal({"id"=>"1"}, result)
+      get '/noparam?a=1;b=2'
+      assert_equal({}, result)
+    end
+
+    it 'should successfully filter hashes' do
+      result = nil
+      mock_app do
+        post :family, :params => [ :persons => [ :name ] ] do
+          result = params
+          ''
+        end
+      end
+      post '/family?' + @family.to_query
+      assert_equal({"persons" => {"3" => {"name" => @jack["name"]}, "2" => {"name" => @kim["name"]}, "1" => {"name" => @teri["name"]}}}, result)
+    end
+
+    it 'should pass arrays' do
+      result = nil
+      mock_app do
+        post :family, :params => [ :names => [] ] do
+          result = params
+          ''
+        end
+      end
+      post '/family?names[]=Jack&names[]=Kim&names[]=Teri'
+      assert_equal({"names" => %w[Jack Kim Teri]}, result)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pendragon
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - namusyaka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-22 00:00:00.000000000 Z
+date: 2014-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack