padrino-core 0.9.15 → 0.9.16

data/.gitignore

@@ -19,3 +19,4 @@ rdoc
 pkg
 
 ## PROJECT::SPECIFIC
+test/tmp/*

data/lib/padrino-core/application/routing.rb

@@ -15,19 +15,30 @@ module Padrino
     class ::HttpRouter #:nodoc:
       attr_accessor :runner
       class Route #:nodoc:
-        attr_accessor :custom_conditions, :before_filters, :after_filters, :use_layout, :controller
+        attr_reader :before_filters, :after_filters
+        attr_accessor :custom_conditions, :use_layout, :controller, :cache
 
-        def process_arbitrary_blocks(blocks)
-          blocks.each { |blk| arbitrary { |env| router.runner.instance_eval(&blk) != false } } if blocks
+        def add_before_filter(filter)
+          @before_filters ||= []
+          @before_filters << filter
+          arbitrary { |env| catch(:pass) { router.runner.instance_eval(&filter); true } == true }
         end
 
-        def before_filters=(before_filters)
-          process_arbitrary_blocks(before_filters)
-          @before_filters = before_filters
+        def add_after_filter(filter)
+          @after_filters ||= []
+          @after_filters << filter
+        end
+
+        def before_filters=(filters)
+          filters.each { |filter| add_before_filter(filter) } if filters
+        end
+
+        def after_filters=(filters)
+          filters.each { |filter| add_after_filter(filter) } if filters
         end
 
         def custom_conditions=(custom_conditions)
-          process_arbitrary_blocks(custom_conditions)
+          custom_conditions.each { |blk| arbitrary { |env| router.runner.instance_eval(&blk) != false } } if custom_conditions
           @custom_conditions = custom_conditions
         end
       end
@@ -49,7 +60,25 @@ module Padrino
 
     class UnrecognizedException < RuntimeError #:nodoc:
     end
-
+    
+    ##
+    # Keeps information about parent scope.
+    #
+    class Parent < String
+      attr_reader :map
+      attr_reader :optional
+      attr_reader :options
+
+      alias_method :optional?, :optional
+      
+      def initialize(value, options={})
+        super(value.to_s)
+        @map      = options.delete(:map)
+        @optional = options.delete(:optional)
+        @options  = options
+      end
+    end
+    
     ##
     # Main class that register this extension
     #
@@ -131,6 +160,8 @@ module Padrino
           @_controller, original_controller = args, @_controller
           @_parents,    original_parent     = options.delete(:parent), @_parents
           @_provides,   original_provides   = options.delete(:provides), @_provides
+          @_cache,      original_cache      = options.delete(:cache), @_cache
+          @_map,        original_map        = options.delete(:map), @_map
           @_defaults,   original_defaults   = options, @_defaults
 
           # Application defaults
@@ -146,14 +177,40 @@ module Padrino
           @layout         = original_layout
 
           # Controller defaults
-          @_controller, @_parents = original_controller, original_parent
-          @_defaults, @_provides  = original_defaults, original_provides
+          @_controller, @_parents, @_cache = original_controller, original_parent, original_cache
+          @_defaults, @_provides, @_map  = original_defaults, original_provides, original_map
         else
           include(*args) if extensions.any?
         end
       end
       alias :controllers :controller
 
+      ##
+      # Provides many parents with shallowing.  
+      #
+      # ==== Examples
+      # 
+      #   controllers :product do
+      #     parent :shop, :optional => true, :map => "/my/stand"
+      #     parent :category, :optional => true
+      #     get :show, :with => :id do
+      #       # generated urls:
+      #       #   "/product/show/#{params[:id]}"
+      #       #   "/my/stand/#{params[:shop_id]}/product/show/#{params[:id]}"
+      #       #   "/my/stand/#{params[:shop_id]}/category/#{params[:category_id]}/product/show/#{params[:id]}"
+      #       # url_for(:product, :show, :id => 10) => "/product/show/10"
+      #       # url_for(:product, :show, :shop_id => 5, :id => 10) => "/my/stand/5/product/show/10"
+      #       # url_for(:product, :show, :shop_id => 5, :category_id => 1, :id => 10) => "/my/stand/5/category/1/product/show/10"
+      #     end
+      #   end   
+      #
+      def parent(name, options={})
+        defaults = { :optional => false, :map => name.to_s }
+        options = defaults.merge(options)
+        @_parents = Array(@_parents) unless @_parents.is_a?(Array)
+        @_parents << Parent.new(name, options)
+      end
+
       ##
       # Using HTTPRouter, for features and configurations see: http://github.com/joshbuddy/http_router
       #
@@ -201,6 +258,19 @@ module Padrino
       end
       alias :url_for :url
 
+      def get(path, *args, &block)
+        conditions = @conditions.dup
+        route('GET', path, *args, &block)
+
+        @conditions = conditions
+        route('HEAD', path, *args, &block)
+      end
+
+      def put(path, *args, &bk);    route 'PUT',    path, *args, &bk end
+      def post(path, *args, &bk);   route 'POST',   path, *args, &bk end
+      def delete(path, *args, &bk); route 'DELETE', path, *args, &bk end
+      def head(path, *args, &bk);   route 'HEAD',   path, *args, &bk end
+
       private
 
         # Add prefix slash if its not present and remove trailing slashes.
@@ -214,22 +284,43 @@ module Padrino
         # ==== Examples
         #
         #   get :index                                    # => "/"
+        #   get :index, "/"                               # => "/"
         #   get :index, :map => "/"                       # => "/"
+        #   get :show, "/show-me"                         # => "/show-me"
         #   get :show,  :map => "/show-me"                # => "/show-me"
         #   get "/foo/bar"                                # => "/show"
         #   get :index, :parent => :user                  # => "/user/:user_id/index"
         #   get :show, :with => :id, :parent => :user     # => "/user/:user_id/show/:id"
         #   get :show, :with => :id                       # => "/show/:id"
+        #   get [:show, :id]                              # => "/show/:id"
         #   get :show, :with => [:id, :name]              # => "/show/:id/:name"
+        #   get [:show, :id, :name]                       # => "/show/:id/:name"
         #   get :list, :provides => :js                   # => "/list.{:format,js)"
         #   get :list, :provides => :any                  # => "/list(.:format)"
         #   get :list, :provides => [:js, :json]          # => "/list.{!format,js|json}"
         #   get :list, :provides => [:html, :js, :json]   # => "/list(.{!format,js|json})"
         #
-        def route(verb, path, options={}, &block)
+        def route(verb, path, *args, &block)
+          options = case args.size
+          when 2
+            args.last.merge(:map => args.first)
+          when 1
+            map = args.shift if args.first.is_a?(String)
+            if args.first.is_a?(Hash)
+              map ? args.first.merge(:map => map) : args.first
+            else
+              {:map => map || args.first}
+            end
+          when 0
+            {}
+          else
+            raise
+          end
+          
           # Do padrino parsing. We dup options so we can build HEAD request correctly
           route_options = options.dup
           route_options[:provides] = @_provides if @_provides
+          path, *route_options[:with] = path if path.is_a?(Array)
           path, name, options = *parse_route(path, route_options, verb)
 
           # Sinatra defaults
@@ -245,23 +336,30 @@ module Padrino
 
           # HTTPRouter route construction
           route = case path
-            when Regexp
-              router.add('/?*').match_path(path)
-            else
-              router.add(path)
+            when Regexp then router.add('/?*').match_path(path)
+            else             router.add(path)
           end
 
           route.name(name) if name
+          route.cache = options.key?(:cache) ? options.delete(:cache) : @_cache
           route.send(verb.downcase.to_sym)
           route.host(options.delete(:host)) if options.key?(:host)
           route.condition(:user_agent => options.delete(:agent)) if options.key?(:agent)
           route.default_values = options.delete(:default_values)
+          options.delete_if do |option, args| 
+            if route.send(:significant_variable_names).include?(option)
+              route.matching(option => Array(args).first)
+              true
+            end
+          end
 
           # Add Sinatra conditions
           options.each { |option, args| send(option, *args) }
           conditions, @conditions = @conditions, []
           route.custom_conditions = conditions
 
+          invoke_hook(:padrino_route_added, route, verb, path, args, options, block)
+
           # Add Application defaults
           if @_controller
             route.before_filters = @before_filters
@@ -274,7 +372,6 @@ module Padrino
           end
 
           route.to(block)
-
           route
         end
 
@@ -336,10 +433,14 @@ module Padrino
               path = process_path_for_parent_params(path, parent_params)
             end
 
+            # Add any controller level map to the front of the path
+            path = "#{@_map}/#{path}".squeeze('/') unless @_map.blank?
+
             # Small reformats
             path.gsub!(%r{/?index/?}, '')                  # Remove index path
-            path[0,0] = "/" if path !~ %r{^\(?/} && path   # Paths must start with a /
-            path.sub!(%r{/$}, '') if path != "/"           # Remove latest trailing delimiter
+            path[0,0] = "/" unless path =~ %r{^\(?/}       # Paths must start with a /
+            path.sub!(%r{/(\))?$}, '\\1') if path != "/"   # Remove latest trailing delimiter
+            path.gsub!(/\/(\(\.|$)/, '\\1')                # Remove trailing slashes
           end
 
           # Merge in option defaults
@@ -361,8 +462,13 @@ module Padrino
         # Used for calculating path in route method
         #
         def process_path_for_parent_params(path, parent_params)
-          parent_prefix = parent_params.flatten.uniq.collect { |param| "#{param}/:#{param}_id" }.join("/")
-          File.join(parent_prefix, path)
+          parent_prefix = parent_params.flatten.compact.uniq.collect do |param|
+            map  = (param.respond_to?(:map) && param.map ? param.map : param.to_s)
+            part = "#{map}/:#{param}_id/"
+            part = "(#{part})" if param.respond_to?(:optional) && param.optional?
+            part
+          end
+          [parent_prefix, path].flatten.join("")
         end
 
         ##
@@ -485,10 +591,11 @@ module Padrino
                 # Now we can eval route, but because we have "throw halt" we need to be
                 # (en)sure to reset old layout and run controller after filters.
                 begin
-                  route_eval(&match.destination)
+                  @_response_buffer = catch(:halt) { route_eval(&match.destination) }
+                  throw :halt, @_response_buffer
                 ensure
                   base.instance_variable_set(:@layout, parent_layout) if match.path.route.use_layout
-                  match.path.route.after_filters.each { |aft| throw :pass if instance_eval(&aft) == false }
+                  match.path.route.after_filters.each { |aft| throw :pass if instance_eval(&aft) == false } if match.path.route.after_filters
                 end
               end
             end
@@ -506,4 +613,4 @@ module Padrino
         end
     end # InstanceMethods
   end # Routing
-end # Padrino
+end # Padrino

data/lib/padrino-core/version.rb

@@ -5,11 +5,11 @@
 # without include full padrino core.
 #
 module Padrino
-  VERSION = '0.9.15' unless defined?(Padrino::VERSION)
+  VERSION = '0.9.16' unless defined?(Padrino::VERSION)
   ##
   # Return the current Padrino version
   #
   def self.version
     VERSION
   end
-end # Padrino
+end # Padrino

data/padrino-core.gemspec

@@ -18,14 +18,8 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_path = "lib"
   s.add_dependency("sinatra", ">= 1.0.0")
-  s.add_dependency("http_router", ">= 0.3.13")
+  s.add_dependency("http_router", ">= 0.3.16")
   s.add_dependency("thor", ">= 0.13.0")
-  # If you want try our test on AS edge.
-  # $ AS=edge rake test
-  if ENV['AS'] == "edge"
-    s.add_dependency("activesupport", ">= 3.0.0.beta4")
-    s.add_dependency("tzinfo")
-  else
-    s.add_dependency("activesupport", ">= 2.3.8")
-  end
+  s.add_dependency("activesupport", ">= 3.0.0")
+  s.add_dependency("tzinfo")
 end

data/test/test_routing.rb

@@ -77,6 +77,16 @@ class TestRouting < Test::Unit::TestCase
     assert_equal "hello IE", body
   end
 
+  should "use regex for parts of a route" do
+    app = mock_app do
+      get("/main/:id", :id => /\d+/){ "hello #{params[:id]}" }
+    end
+    get "/main/123"
+    assert_equal "hello 123", body
+    get "/main/asd"
+    assert_equal 404, status
+  end
+
   should "not generate overlapping head urls" do
     app = mock_app do
       get("/main"){ "hello" }
@@ -92,10 +102,15 @@ class TestRouting < Test::Unit::TestCase
     mock_app do
       get(:foo){ "/foo" }
       get(:foo, :with => :id){ |id| "/foo/#{id}" }
+      get([:foo, :id]){ |id| "/foo/#{id}" }
       get(:hash, :with => :id){ url(:hash, :id => 1) }
+      get([:hash, :id]){ url(:hash, :id => 1) }
       get(:array, :with => :id){ url(:array, 23) }
+      get([:array, :id]){ url(:array, 23) }
       get(:hash_with_extra, :with => :id){ url(:hash_with_extra, :id => 1, :query => 'string') }
+      get([:hash_with_extra, :id]){ url(:hash_with_extra, :id => 1, :query => 'string') }
       get(:array_with_extra, :with => :id){ url(:array_with_extra, 23, :query => 'string') }
+      get([:array_with_extra, :id]){ url(:array_with_extra, 23, :query => 'string') }
       get("/old-bar/:id"){ params[:id] }
       post(:mix, :map => "/mix-bar/:id"){ params[:id] }
       get(:mix, :map => "/mix-bar/:id"){ params[:id] }
@@ -240,7 +255,7 @@ class TestRouting < Test::Unit::TestCase
     assert_equal "bar", body
     assert_equal "/bar", @app.url(:bar)
   end
-
+  
   should 'remove index from path' do
     mock_app do
       get(:index){ "index" }
@@ -481,6 +496,7 @@ class TestRouting < Test::Unit::TestCase
         get(:index, :map => "/"){ "index" }
         get(:show, :with => :id, :map => "/show"){ "show #{params[:id]}" }
         get(:edit, :map => "/edit/:id/product"){ "edit #{params[:id]}" }
+        get(:wacky, :map => "/wacky-:id-:product_id"){ "wacky #{params[:id]}-#{params[:product_id]}" }
       end
     end
     get "/"
@@ -489,6 +505,18 @@ class TestRouting < Test::Unit::TestCase
     assert_equal "show 1", body
     get "/edit/1/product"
     assert_equal "edit 1", body
+    get "/wacky-1-2"
+    assert_equal "wacky 1-2", body
+  end
+
+  should 'apply maps when given path is kind of hash' do
+    mock_app do 
+      controllers :admin do 
+        get(:foobar, "/foo/bar"){ "foobar" }
+      end
+    end
+    get "/foo/bar"
+    assert_equal "foobar", body
   end
 
   should "apply parent to route" do
@@ -534,6 +562,62 @@ class TestRouting < Test::Unit::TestCase
     assert_equal "show 3 1 2", body
     assert_equal user_product_project_url, @app.url(:project, :show, :user_id => 1, :product_id => 2, :id => 3)
   end
+  
+  should "apply parent with shallowing to controller" do 
+    mock_app do 
+      controller :project do
+        parent :user
+        parent :shop, :optional => true
+        get(:index) { "index #{params[:user_id]} #{params[:shop_id]}" }
+        get(:edit, :with => :id) { "edit #{params[:id]} #{params[:user_id]} #{params[:shop_id]}" }
+        get(:show, :with => :id, :parent => :product) { "show #{params[:id]} #{params[:user_id]} #{params[:product_id]} #{params[:shop_id]}" }
+      end
+    end
+    
+    user_project_url = "/user/1/project"
+    get user_project_url
+    assert_equal "index 1 ", body
+    assert_equal user_project_url, @app.url(:project, :index, :user_id => 1)
+
+    user_project_edit_url = "/user/1/project/edit/2"
+    get user_project_edit_url
+    assert_equal "edit 2 1 ", body
+    assert_equal user_project_edit_url, @app.url(:project, :edit, :user_id => 1, :id => 2)
+
+    user_product_project_url = "/user/1/product/2/project/show/3"
+    get user_product_project_url
+    assert_equal "show 3 1 2 ", body
+    assert_equal user_product_project_url, @app.url(:project, :show, :user_id => 1, :product_id => 2, :id => 3)
+
+    user_project_url = "/user/1/shop/1/project"
+    get user_project_url
+    assert_equal "index 1 1", body
+    assert_equal user_project_url, @app.url(:project, :index, :user_id => 1, :shop_id => 1)
+
+    user_project_edit_url = "/user/1/shop/1/project/edit/2"
+    get user_project_edit_url
+    assert_equal "edit 2 1 1", body
+    assert_equal user_project_edit_url, @app.url(:project, :edit, :user_id => 1, :id => 2, :shop_id => 1)
+
+    user_product_project_url = "/user/1/shop/1/product/2/project/show/3"
+    get user_product_project_url
+    assert_equal "show 3 1 2 1", body
+    assert_equal user_product_project_url, @app.url(:project, :show, :user_id => 1, :product_id => 2, :id => 3, :shop_id => 1)
+  end
+  
+  should "respect map in parents with shallowing" do 
+    mock_app do 
+      controller :project do
+        parent :shop, :map => "/foo/bar"
+        get(:index) { "index #{params[:shop_id]}" }
+      end
+    end
+    
+    shop_project_url = "/foo/bar/1/project"
+    get shop_project_url
+    assert_equal "index 1", body
+    assert_equal shop_project_url, @app.url(:project, :index, :shop_id => 1)
+  end
 
   should "use default values" do
     mock_app do
@@ -703,6 +787,52 @@ class TestRouting < Test::Unit::TestCase
     assert_equal "hey", body
   end
 
+  should "allow concise routing" do
+    mock_app do
+      get :index, ":id" do
+        params[:id]
+      end
+
+      get :map, "route/:id" do
+        params[:id]
+      end
+    end
+
+    get "/123"
+    assert_equal "123", body
+
+    get "/route/123"
+    assert_equal "123", body
+  end
+
+  should "allow passing & halting in before filters" do
+    mock_app do
+      controller do
+        before { env['QUERY_STRING'] == 'secret' or pass }
+        get :index do
+          "secret index"
+        end
+      end
+
+      controller do
+        before { env['QUERY_STRING'] == 'halt' and halt 401, 'go away!' }
+        get :index do
+          "index"
+        end
+      end
+    end
+
+    get "/?secret"
+    assert_equal "secret index", body
+
+    get "/?halt"
+    assert_equal "go away!", body
+    assert_equal 401, status
+
+    get "/"
+    assert_equal "index", body
+  end
+
   should 'scope filters in the given controller' do
     mock_app do
       before { @global = 'global' }
@@ -821,6 +951,26 @@ class TestRouting < Test::Unit::TestCase
     assert_equal 404, status
   end
 
+  should "allow controller level mapping" do
+    mock_app do
+      controller :map => "controller-:id" do
+        get(:url3) { "#{params[:id]}" }
+        get(:url4, :map => 'test-:id2') { "#{params[:id]}, #{params[:id2]}" }
+      end
+    end
+
+    url = @app.url(:url3, :id => 1)
+    assert_equal "/controller-1/url3", url
+    get url
+    assert_equal "1", body
+
+    url = @app.url(:url4, 1, 2)
+    assert_equal "/controller-1/test-2", url
+    get url
+    assert_equal "1, 2", body
+  end
+
+
   should "work with params and parent options" do
     mock_app do
       controller :test2, :parent => :parent1, :parent1_id => 1 do
@@ -871,13 +1021,24 @@ class TestRouting < Test::Unit::TestCase
     end
     get "/foo"
     assert_equal "this is foo", body
-    # TODO fix this in http_router, should pass
     get "/foo/"
     assert_equal "this is foo", body
     get '/foo/5/10'
     assert_equal "/foo/5/10", body
   end
 
+  should "index routes should be optional when nested" do
+    mock_app do
+      controller '/users', :provides => [:json] do
+        get '/' do
+          "foo"
+        end
+      end
+    end
+    get "/users.json"
+    assert_equal "foo", body
+  end
+
   should "parse params with class level provides" do
     mock_app do
       controllers :posts, :provides => [:html, :js] do

data/test/tmp/cache/%2Ffoo

@@ -0,0 +1,2 @@
+-1
+test page again

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: padrino-core
 version: !ruby/object:Gem::Version 
-  hash: 37
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 9
-  - 15
-  version: 0.9.15
+  - 16
+  version: 0.9.16
 platform: ruby
 authors: 
 - Padrino Team
@@ -18,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-28 00:00:00 +02:00
+date: 2010-09-24 00:00:00 +02:00
 default_executable: padrino
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -45,12 +45,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 9
+        hash: 51
         segments: 
         - 0
         - 3
-        - 13
-        version: 0.3.13
+        - 16
+        version: 0.3.16
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -77,14 +77,28 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 19
+        hash: 7
         segments: 
-        - 2
         - 3
-        - 8
-        version: 2.3.8
+        - 0
+        - 0
+        version: 3.0.0
   type: :runtime
   version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: tzinfo
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
 description: The Padrino core gem required for use of this framework
 email: padrinorb@gmail.com
 executables: 
@@ -154,6 +168,7 @@ files:
 - test/test_router.rb
 - test/test_routing.rb
 - test/test_server.rb
+- test/tmp/cache/%2Ffoo
 has_rdoc: true
 homepage: http://www.padrinorb.com
 licenses: []