padrino-core 0.8.5 → 0.9.0

data/README.rdoc

@@ -55,7 +55,7 @@ Please help me brainstorm and fork the project if you have any ideas to contribu
 
 To install the padrino framework, simply grab the latest version from gemcutter:
 
-  $ sudo gem install padrino --source http://gemcutter.org
+  $ sudo gem install padrino
   
 This will install the necessary padrino gems to get you started.
 Now you are ready to use this gem to enhance your sinatra projects or to create new Padrino applications.
@@ -301,21 +301,6 @@ within your application:
 This will instruct Padrino to autoload these files (and reload them when changes are detected). By default, the load path 
 contains certain paths known to contain important files such as controllers, mailers, models, urls, and helpers. 
 
-=== Initializers
-
-Padrino also has support for 'initializers' which are important setup steps or configuration within an application
-that should occur during the bootup process. To construct initializers, simply add a file to the <tt>config/initializers<tt>
-directory following this convention:
-
-  # config/initializers/example.rb
-  module ExampleInitializer
-    def self.registered(app)
-      # Manipulate 'app' here to register components or adjust configuration
-      app.set :environment, :production # just an example configuration change
-      app.use Hassle # or even enable middleware
-    end
-  end
-  
 Initializers are automatically required and 'registered' during the application startup process. Note that
 the name of the module must be the name of the file appended with 'Initializer' (i.e sample.rb => SampleInitializer)
 

data/Rakefile

@@ -17,8 +17,8 @@ begin
     gem.add_runtime_dependency     "i18n",          ">= 0.3.2"
     gem.add_runtime_dependency     "usher",         ">= 0.6.2"
     gem.add_runtime_dependency     "thor",          ">= 0.13.0"
-    gem.add_runtime_dependency     "bundler",       "= 0.9.5"
-    gem.add_runtime_dependency     "activesupport", ">= 2.3.5"
+    gem.add_runtime_dependency     "bundler",       "= 0.9.7"
+    gem.add_runtime_dependency     "activesupport", "= 2.3.5"
     gem.add_development_dependency "shoulda",       ">= 2.10.3"
     gem.add_development_dependency "mocha",         ">= 0.9.7"
     gem.add_development_dependency "rack-test",     ">= 0.5.0"

data/VERSION

@@ -1 +1 @@
-0.8.5
+0.9.0

data/lib/padrino-core.rb

@@ -1,6 +1,6 @@
-require 'usher'
 require 'sinatra/base'
 
+Dir[File.dirname(__FILE__) + '/padrino-core/application/*.rb'].each {|file| require file }
 Dir[File.dirname(__FILE__) + '/padrino-core/*.rb'].each {|file| require file }
 
 # Defines our PADRINO_ENV

data/lib/padrino-core/application.rb

@@ -1,20 +1,24 @@
 module Padrino
   class ApplicationSetupError < RuntimeError #:nodoc:
   end
+
   ##
   # Subclasses of this become independent Padrino applications (stemming from Sinatra::Application)
   # These subclassed applications can be easily mounted into other Padrino applications as well.
-  # 
+  #
   class Application < Sinatra::Application
+    register Padrino::Routing   # Support for advanced routing, controllers, url_for
+    register Padrino::Rendering # Support for enhanced rendering with template detection
 
     class << self
+
       def inherited(subclass) #:nodoc:
         CALLERS_TO_IGNORE.concat(PADRINO_IGNORE_CALLERS)
         subclass.default_configuration!
         Padrino.set_load_paths File.join(subclass.root, "/models")
         Padrino.require_dependencies File.join(subclass.root, "/models.rb")
         Padrino.require_dependencies File.join(subclass.root, "/models/**/*.rb")
-        super(subclass) # Loading the subclass
+        super(subclass) # Loading the subclass inherited method
         subclass.default_filters!
         subclass.default_routes!
         subclass.default_errors!
@@ -25,95 +29,21 @@ module Padrino
       # This is used because putting the configuration into inherited doesn't
       # take into account overwritten app settings inside subclassed definitions
       # Only performs the setup first time application is initialized.
-      # 
+      #
       def new(*args, &bk)
         setup_application!
         super(*args, &bk)
       end
 
       ##
-      # Method for organize in a better way our routes like:
-      # 
-      #   controller :admin do
-      #     get :index do; ...; end
-      #     get :show, :with => :id  do; ...; end
-      #   end
-      # 
-      # Now you can call your actions with:
-      # 
-      #   url(:admin_index) # => "/admin"
-      #   url(:admin_show, :id => 1) # "/admin/show/1"
-      # 
-      # You can instead using named routes follow the sinatra way like:
-      # 
-      #   controller "/admin" do
-      #     get "/index" do; ...; end
-      #     get "/show/:id" do; ...; end
-      #   end
-      # 
-      # And you can call directly these urls:
-      # 
-      #   # => "/admin"
-      #   # => "/admin/show/1"
-      # 
-      def controller(*extensions, &block)
-        if block_given?
-          @_controller, original = extensions, @_controller
-          instance_eval(&block)
-          @_controller = original
-        else
-          include(*extensions)  if extensions.any?
-        end
-      end
-      alias :controllers :controller
-
-      ##
-      # Usher router, for fatures and configurations see: http://github.com/joshbuddy/usher
-      # 
-      # ==== Examples
-      # 
-      #   router.add_route('/greedy/{!:greed,.*}')
-      #   router.recognize_path('/simple')
-      # 
-      def router
-        @router ||= Usher.new(:request_methods => [:request_method, :host, :port, :scheme], 
-                              :ignore_trailing_delimiters => true,
-                              :generator => Usher::Util::Generators::URL.new)
-        block_given? ? yield(@router) : @router
-      end
-      alias :urls :router
-
-      ##
-      # Instance method for url generation like:
-      # 
-      # ==== Examples
-      # 
-      #   url(:show, :id => 1)
-      #   url(:show, :name => :test)
-      #   url("/show/:id/:name", :id => 1, :name => foo)
-      # 
-      def url(name, *params)
-        params.map! do |param|
-          if param.is_a?(Hash)
-            param[:format] = param[:format].to_s if param.has_key?(:format)
-            param.each { |k,v| param[k] = v.to_param if v.respond_to?(:to_param) }
-          end
-        end
-        url = router.generator.generate(name, *params)
-        uri_root != "/" ? uri_root + url : url
-      end
-      alias :url_for :url
-
-      ##
-      # With this method we can use layout like rails do or if a block given like sinatra
-      # By default we look in your/app/views/layouts/application.(haml|erb|etc)
-      # 
-      # If you define:
-      # 
-      #   layout :custom
-      # 
-      # Padrino look for your/app/views/layouts/custom.(haml|erb|etc)
-      # 
+      # Use layout like rails does or if a block given then like sinatra.
+      # If used without a block, sets the current layout for the route.
+      #
+      # By default, searches in your +app/views/layouts/application.(haml|erb|xxx)+
+      #
+      # If you define +layout :custom+ then searches for your layouts in
+      # +app/views/layouts/custom.(haml|erb|xxx)+
+      #
       def layout(name=:layout, &block)
         return super(name, &block) if block_given?
         @_layout = name
@@ -121,13 +51,14 @@ module Padrino
 
       ##
       # Reloads the application files from all defined load paths
-      # 
-      # This method is used from our Padrino Reloader.
-      # 
+      #
+      # This method is used from our Padrino Reloader during development mode
+      # in order to reload the source files.
+      #
       # ==== Examples
-      # 
+      #
       #   MyApp.reload!
-      # 
+      #
       def reload!
         reset_routes! # remove all existing user-defined application routes
         Padrino.load_dependency(self.app_file)  # reload the app file
@@ -136,11 +67,11 @@ module Padrino
 
       ##
       # Resets application routes to only routes not defined by the user
-      # 
+      #
       # ==== Examples
-      # 
+      #
       #   MyApp.reset_routes!
-      # 
+      #
       def reset_routes!
         router.reset!
         default_routes!
@@ -149,11 +80,11 @@ module Padrino
       ##
       # Setup the application by registering initializers, load paths and logger
       # Invoked automatically when an application is first instantiated
-      # 
+      #
       def setup_application!
         return if @_configured
-        self.register_framework_extensions
         self.calculate_paths
+        self.register_framework_extensions
         self.register_initializers
         self.require_load_paths
         self.disable :logging # We need do that as default because Sinatra use commonlogger.
@@ -163,9 +94,10 @@ module Padrino
       end
 
       protected
+
         ##
         # Defines default settings for Padrino application
-        # 
+        #
         def default_configuration!
           # Overwriting Sinatra defaults
           set :app_file, caller_files.first || $0 # Assume app file is first caller
@@ -183,7 +115,6 @@ module Padrino
           set :authentication, false
           # Padrino locale
           set :locale_path, Proc.new { Dir[File.join(self.root, "/locale/**/*.{rb,yml}")] }
-          set :auto_locale, false
           # Plugin specific
           set :padrino_mailer, defined?(Padrino::Mailer)
           set :padrino_helpers, defined?(Padrino::Helpers)
@@ -191,7 +122,7 @@ module Padrino
 
         ##
         # We need to add almost __sinatra__ images.
-        # 
+        #
         def default_routes!
           # images resources
           get "/__sinatra__/:image.png" do
@@ -202,7 +133,7 @@ module Padrino
 
         ##
         # This filter it's used for know the format of the request, and automatically set the content type.
-        # 
+        #
         def default_filters!
           before do
             request.path_info =~ /\.([^\.\/]+)$/
@@ -213,7 +144,7 @@ module Padrino
 
         ##
         # This log errors for production environments
-        # 
+        #
         def default_errors!
           configure :production do
             error ::Exception do
@@ -229,7 +160,7 @@ module Padrino
         ##
         # Calculates any required paths after app_file and root have been properly configured
         # Executes as part of the setup_application! method
-        # 
+        #
         def calculate_paths
           raise ApplicationSetupError.new("Please define 'app_file' option for #{self.name} app!") unless self.app_file
           set :views, find_view_path if find_view_path
@@ -237,19 +168,17 @@ module Padrino
         end
 
         ##
-        # Requires the middleware and initializer modules to configure components
-        # 
+        # Requires the Padrino middleware
+        #
         def register_initializers
           use Padrino::Logger::Rack
           use Padrino::Reloader::Rack  if reload?
           use Rack::Flash              if flash?
-          @initializer_path ||= Padrino.root + '/config/initializers/*.rb'
-          Dir[@initializer_path].each { |file| register_initializer(file) }
         end
 
         ##
         # Registers all desired padrino extension helpers
-        # 
+        #
         def register_framework_extensions
           register Padrino::Mailer        if padrino_mailer?
           register Padrino::Helpers       if padrino_helpers?
@@ -258,288 +187,25 @@ module Padrino
 
         ##
         # Returns the load_paths for the application (relative to the application root)
-        # 
+        #
         def load_paths
           @load_paths ||= ["urls.rb", "config/urls.rb", "mailers/*.rb", "controllers/**/*.rb", "controllers.rb", "helpers/*.rb"]
         end
 
         ##
         # Requires all files within the application load paths
-        # 
+        #
         def require_load_paths
           load_paths.each { |path| Padrino.require_dependencies(File.join(self.root, path)) }
         end
 
         ##
         # Returns the path to the views directory from root by returning the first that is found
-        # 
+        #
         def find_view_path
           @view_paths = ["views"].collect { |path| File.join(self.root, path) }
           @view_paths.find { |path| Dir[File.join(path, '/**/*')].any? }
         end
-
-        ##
-        # Registers an initializer with the application
-        # register_initializer('/path/to/initializer')
-        # 
-        def register_initializer(file_path)
-          Padrino.require_dependencies(file_path)
-          file_class = File.basename(file_path, '.rb').camelize
-          register "#{file_class}Initializer".constantize
-        rescue NameError => e
-          logger.error "The module '#{file_class}Initializer' (#{file_path}) didn't loaded properly!"
-          logger.error "   Initializer error was '#{e.message}'"
-        end
-
-      private
-        ##
-        # Rewrite default because now routes can be:
-        # 
-        # ==== Examples
-        # 
-        #   get :index                                    # => "/"
-        #   get :index, :map => "/"                       # => "/"
-        #   get :show,  :map => "/show-me"                # => "/show-me"
-        #   get "/foo/bar"                                # => "/show"
-        #   get :show, :with => :id                       # => "/show/:id"
-        #   get :show, :with => [:id, :name]              # => "/show/:id/:name"
-        #   get :list, :respond_to => :js                 # => "/list.{:format,js)"
-        #   get :list, :respond_to => :any                # => "/list(.:format)"
-        #   get :list, :respond_to => [:js, :json]        # => "/list.{!format,js|json}"
-        #   gen :list, :respond_to => [:html, :js, :json] # => "/list(.{!format,js|json})"
-        # 
-        def route(verb, path, options={}, &block)
-
-          # We dup options so we can build HEAD request correctly
-          options = options.dup
-
-          # We need check if path is a symbol, if that it's a named route
-          map = options.delete(:map)
-
-          if path.kind_of?(Symbol)
-            name = path                       # The route name
-            path = map || "/#{path}"          # The route path
-          end
-
-          if path.kind_of?(String)
-            # Little reformats
-            path.sub!(/\/index$/, "")                             # If the route end with /index we remove them
-            path = (uri_root == "/" ? "/" : "(/)") if path.blank? # Add a trailing delimiter if empty
-
-            # Now we need to parse our with params
-            if params = options.delete(:with)
-              path += "/" unless path =~ /\/$/
-              path += Array(params).collect(&:inspect).join("/")
-            end
-
-            # Now we need to parse our respond_to
-            if format = options.delete(:respond_to)
-              path += case format
-                when :any  then "(.:format)"
-                when Array then
-                  formats   = format.dup # Prevent changes to HEAD verb
-                  container = formats.delete(:html) ? "(%s)" : "%s"
-                  match     = ".{:format," + formats.collect { |f| "#{f}$" }.join("|") + "}"
-                  container % match
-                else ".{:format,#{format}}"
-              end
-            end
-
-            # Build our controller
-            controller = Array(@_controller).collect(&:to_s)
-
-            unless controller.empty?
-              # Now we need to add our controller path only if not mapped directly
-              if map.blank?
-                controller_path = controller.join("/")
-                path = controller_path + path
-              end
-              # Here we build the correct name route
-              if name
-                controller_name = controller.join("_")
-                name = "#{controller_name}_#{name}".to_sym unless controller_name.blank?
-              end
-            end
-
-            # We need to have a path that start with / in some circumstances and that don't end with /
-            if path != "(/)" && path != "/"
-              path = "/" + path if path !~ /^\//
-              path.sub!(/\/$/, '')
-            end
-          end
-
-          # Standard Sinatra requirements
-          options[:conditions] ||= {}
-          options[:conditions][:request_method] = verb
-          options[:conditions][:host] = options.delete(:host) if options.key?(:host)
-
-          # Because of self.options.host
-          host_name(options.delete(:host)) if options.key?(:host)
-
-          # Sinatra defaults
-          define_method "#{verb} #{path}", &block
-          unbound_method = instance_method("#{verb} #{path}")
-          block =
-            if block.arity != 0
-              proc { unbound_method.bind(self).call(*@block_params) }
-            else
-              proc { unbound_method.bind(self).call }
-            end
-
-          invoke_hook(:route_added, verb, path, block)
-
-          route = router.add_route(path, options).to(block)
-          route.name(name) if name
-          route
-        end
-    end # self
-
-    ##
-    # Return the request format, this is useful when we need to respond to a given content_type like:
-    # 
-    # ==== Examples
-    # 
-    #   get :index, :respond_to => :any do
-    #     case content_type
-    #       when :js    then ...
-    #       when :json  then ...
-    #       when :html  then ...
-    #     end
-    #   end
-    # 
-    def content_type(type=nil, params={})
-      type.nil? ? @_content_type : super(type, params)
-    end
-
-    ##
-    # Instance method for url generation like:
-    # 
-    # ==== Examples
-    # 
-    #   url(:show, :id => 1)
-    #   url(:show, :name => :test)
-    #   url("/show/:id/:name", :id => 1, :name => foo)
-    # 
-    def url(name, *params)
-      self.class.url(name, *params)
-    end
-    alias :url_for :url
-
-    ##
-    # This is mostly just a helper so request.path_info isn't changed when
-    # serving files from the public directory
-    # 
-    def static_file?(path_info)
-      return if (public_dir = options.public).nil?
-      public_dir = File.expand_path(public_dir)
-
-      path = File.expand_path(public_dir + unescape(path_info))
-      return if path[0, public_dir.length] != public_dir
-      return unless File.file?(path)
-      return path
-    end
-
-    private
-
-      ##
-      # Method for deliver static files, Sinatra 0.10.x or 1.0.x have this method
-      # but for now we use this (because we need a compatibility with 0.9.x) and also
-      # because we just have +static_file?+ method.
-      # 
-      def static!
-        if path = static_file?(request.path_info)
-          send_file(path, :disposition => nil)
-        end
-      end
-
-      ##
-      # Compatibility with usher
-      # 
-      def route!(base=self.class, pass_block=nil)
-        # TODO: remove this when sinatra 1.0 will be released
-        if Sinatra::VERSION =~ /^0\.9/
-          # enable nested params in Rack < 1.0; allow indifferent access
-          @params = if Rack::Utils.respond_to?(:parse_nested_query)
-            indifferent_params(@request.params)
-          else
-            nested_params(@request.params)
-          end
-          # deliver static files
-          static! if options.static? && (request.get? || request.head?)
-          # perform before filters
-          self.class.filters.each { |block| instance_eval(&block) }
-        end
-
-        # Usher
-        if self.class.router and match = self.class.router.recognize(@request, @request.path_info)
-          @block_params = match.params.map{|p| p.last}
-          @params = @params ? @params.merge(match.params_as_hash) : match.params_as_hash
-          pass_block = catch(:pass) do
-            route_eval(&match.destination)
-          end
-        elsif base.superclass.respond_to?(:routes)
-          route! base.superclass
-        else
-          route_missing
-        end
-      end
-      
-      ##
-      # When we set :auto_locale, true then if we use param locale like:
-      # 
-      # ==== Examples
-      # 
-      #   get "/:locale/some/foo" do; ...; end
-      # 
-      # we automatically set the I18n locale to params[:locale]
-      # 
-      def route_eval(&block)
-        if options.auto_locale
-          if params[:locale]
-            I18n.locale = params[:locale].to_sym rescue options.locale
-          end
-        end
-        super(&block)
-      end
-
-      ##
-      # Hijacking the sinatra render for do three thing:
-      # 
-      # * Use layout like rails do
-      # * Use render 'path/to/my/template' (without symbols)
-      # * Use render 'path/to/my/template' (with auto enegine lookup)
-      # 
-      def render(engine, data=nil, options={}, locals={}, &block)
-        # TODO: remove these @template_cache.respond_to?(:clear) when sinatra 1.0 will be released
-        @template_cache.clear if Padrino.env != :production && @template_cache && @template_cache.respond_to?(:clear)
-        # If engine is an hash we convert to json
-        return engine.to_json if engine.is_a?(Hash)
-        # If an engine is a string probably is a path so we try to resolve them
-        if data.nil?
-          data   = engine.to_sym
-          engine = resolve_template_engine(engine)
-        end
-        # Use layout as rails do
-        if (options[:layout].nil? || options[:layout] == true) && !self.class.templates.has_key?(:layout)
-          layout = self.class.instance_variable_defined?(:@_layout) ? self.class.instance_variable_get(:@_layout) : :application
-          if layout
-            # We look first for views/layout_name.ext then then for views/layouts/layout_name.ext
-            options[:layout] = Dir["#{self.options.views}/#{layout}.*"].present? ? layout.to_sym : File.join('layouts', layout.to_s).to_sym
-            logger.debug "Rendering layout #{options[:layout]}"
-          end
-        end
-        super(engine, data, options, locals, &block)
-      end
-
-      ##
-      # Returns the template engine (i.e haml) to use for a given template_path
-      # resolve_template_engine('users/new') => :haml
-      # 
-      def resolve_template_engine(template_path)
-        resolved_template_path = File.join(self.options.views, template_path.to_s + ".*")
-        template_file = Dir[resolved_template_path].first
-        raise "Template path '#{template_path}' could not be located in views!" unless template_file
-        template_engine = File.extname(template_file)[1..-1].to_sym
-      end
+    end # Class Methods
   end # Application
-end # Padrino
+end # Padrino

data/lib/padrino-core/{mounter.rb → application/mounter.rb}

@@ -45,8 +45,7 @@ module Padrino
         app_obj.set :app_name, app_data.name
         app_obj.set :app_file, app_data.app_file unless ::File.exist?(app_obj.app_file)
         app_obj.set :root,     app_data.app_root unless app_data.app_root.blank?
-        # We need to initialize here the app.
-        app_obj.setup_application!
+        app_obj.setup_application! # We need to initialize here the app.
         run app_obj
       end
     end

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

@@ -0,0 +1,48 @@
+module Padrino
+  module Rendering
+    def self.registered(app)
+      app.send(:include, Padrino::Rendering)
+    end
+
+    private
+      ##
+      # Hijacking the sinatra render for do three thing:
+      #
+      # * Use layout like rails do
+      # * Use render 'path/to/my/template' (without symbols)
+      # * Use render 'path/to/my/template' (with auto enegine lookup)
+      #
+      def render(engine, data=nil, options={}, locals={}, &block)
+        # TODO: remove these @template_cache.respond_to?(:clear) when sinatra 1.0 will be released
+        @template_cache.clear if Padrino.env != :production && @template_cache && @template_cache.respond_to?(:clear)
+        # If engine is an hash we convert to json
+        return engine.to_json if engine.is_a?(Hash)
+        # If an engine is a string probably is a path so we try to resolve them
+        if data.nil?
+          data   = engine.to_sym
+          engine = resolve_template_engine(engine)
+        end
+        # Use layout as rails do
+        if (options[:layout].nil? || options[:layout] == true) && !self.class.templates.has_key?(:layout)
+          layout = self.class.instance_variable_defined?(:@_layout) ? self.class.instance_variable_get(:@_layout) : :application
+          if layout
+            # We look first for views/layout_name.ext then then for views/layouts/layout_name.ext
+            options[:layout] = Dir["#{self.options.views}/#{layout}.*"].present? ? layout.to_sym : File.join('layouts', layout.to_s).to_sym
+            logger.debug "Rendering layout #{options[:layout]}"
+          end
+        end
+        super(engine, data, options, locals, &block)
+      end
+
+      ##
+      # Returns the template engine (i.e haml) to use for a given template_path
+      # resolve_template_engine('users/new') => :haml
+      #
+      def resolve_template_engine(template_path)
+        resolved_template_path = File.join(self.options.views, template_path.to_s + ".*")
+        template_file = Dir[resolved_template_path].first
+        raise "Template path '#{template_path}' could not be located in views!" unless template_file
+        template_engine = File.extname(template_file)[1..-1].to_sym
+      end
+  end
+end

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

@@ -0,0 +1,313 @@
+require 'usher' unless defined?(Usher)
+require 'padrino-core/support_lite' unless String.method_defined?(:blank!)
+
+module Padrino
+  module Routing
+    def self.registered(app)
+      app.send(:include, Padrino::Routing)
+    end
+
+    def self.included(base)
+      base.extend Padrino::Routing::ClassMethods
+    end
+
+    ##
+    # Compatibility with usher
+    #
+    def route!(base=self.class, pass_block=nil)
+      # TODO: remove this when sinatra 1.0 will be released
+      if Sinatra::VERSION =~ /^0\.9/
+        # enable nested params in Rack < 1.0; allow indifferent access
+        can_parse_nested = Rack::Utils.respond_to?(:parse_nested_query)
+        @params = can_parse_nested ? indifferent_params(@request.params) : nested_params(@request.params)
+        # deliver static files
+        static! if options.static? && (request.get? || request.head?)
+        # perform before filters
+        self.class.filters.each { |block| instance_eval(&block) }
+      end # for sinatra = 0.9
+
+      # Usher
+      if self.class.router and match = self.class.router.recognize(@request, @request.path_info)
+        @block_params = match.params.map { |p| p.last }
+        @params = @params ? @params.merge(match.params_as_hash) : match.params_as_hash
+        pass_block = catch(:pass) do
+          route_eval(&match.destination)
+        end
+      elsif base.superclass.respond_to?(:routes)
+        route! base.superclass
+      else
+        route_missing
+      end
+    end
+
+    ##
+    # Instance method for url generation like:
+    #
+    # ==== Examples
+    #
+    #   url(:show, :id => 1)
+    #   url(:show, :name => :test)
+    #   url("/show/:id/:name", :id => 1, :name => foo)
+    #
+    def url(*names)
+      self.class.url(*names)
+    end
+    alias :url_for :url
+
+    ##
+    # This is mostly just a helper so request.path_info isn't changed when
+    # serving files from the public directory
+    #
+    def static_file?(path_info)
+      return if (public_dir = options.public).nil?
+      public_dir = File.expand_path(public_dir)
+
+      path = File.expand_path(public_dir + unescape(path_info))
+      return if path[0, public_dir.length] != public_dir
+      return unless File.file?(path)
+      return path
+    end
+
+    ##
+    # Return the request format, this is useful when we need to respond to a given content_type like:
+    #
+    # ==== Examples
+    #
+    #   get :index, :respond_to => :any do
+    #     case content_type
+    #       when :js    then ...
+    #       when :json  then ...
+    #       when :html  then ...
+    #     end
+    #   end
+    #
+    def content_type(type=nil, params={})
+      type.nil? ? @_content_type : super(type, params)
+    end
+
+    ##
+    # Method for deliver static files, Sinatra 0.10.x or 1.0.x have this method
+    # but for now we use this (because we need a compatibility with 0.9.x) and also
+    # because we just have +static_file?+ method.
+    #
+    def static!
+      if path = static_file?(request.path_info)
+        send_file(path, :disposition => nil)
+      end
+    end
+
+    module ClassMethods
+      ##
+      # Method for organize in a better way our routes like:
+      #
+      #   controller :admin do
+      #     get :index do; ...; end
+      #     get :show, :with => :id  do; ...; end
+      #   end
+      #
+      # Now you can call your actions with:
+      #
+      #   url(:admin_index) # => "/admin"
+      #   url(:admin_show, :id => 1) # "/admin/show/1"
+      #
+      # You can instead using named routes follow the sinatra way like:
+      #
+      #   controller "/admin" do
+      #     get "/index" do; ...; end
+      #     get "/show/:id" do; ...; end
+      #   end
+      #
+      # And you can call directly these urls:
+      #
+      #   # => "/admin"
+      #   # => "/admin/show/1"
+      #
+      def controller(*extensions, &block)
+        if block_given?
+          options = extensions.extract_options!
+          @_controller, original_controller = extensions, @_controller
+          @_parents, original_parent = options[:parent], @_parents
+          instance_eval(&block)
+          @_controller, @_parents = original_controller, original_parent
+        else
+          include(*extensions) if extensions.any?
+        end
+      end
+      alias :controllers :controller
+
+      ##
+      # Usher router, for fatures and configurations see: http://github.com/joshbuddy/usher
+      #
+      # ==== Examples
+      #
+      #   router.add_route('/greedy/{!:greed,.*}')
+      #   router.recognize_path('/simple')
+      #
+      def router
+        @router ||= Usher.new(:request_methods => [:request_method, :host, :port, :scheme],
+                              :ignore_trailing_delimiters => true,
+                              :generator => Usher::Util::Generators::URL.new)
+        block_given? ? yield(@router) : @router
+      end
+      alias :urls :router
+
+      ##
+      # Instance method for url generation like:
+      #
+      # ==== Examples
+      #
+      #   url(:show, :id => 1)
+      #   url(:show, :name => :test)
+      #   url("/show/:id/:name", :id => 1, :name => foo)
+      #
+      def url(*names)
+        params =  names.extract_options! # parameters is hash at end
+        name = names.join("_").to_sym    # route name is concatenated with underscores
+        if params.is_a?(Hash)
+          params[:format] = params[:format].to_s if params.has_key?(:format)
+          params.each { |k,v| params[k] = v.to_param if v.respond_to?(:to_param) }
+        end
+        url = router.generator.generate(name, params)
+        url = uri_root + url if defined?(uri_root) && uri_root != "/"
+        url
+      end
+      alias :url_for :url
+
+      private
+
+        ##
+        # Rewrite default because now routes can be:
+        #
+        # ==== Examples
+        #
+        #   get :index                                    # => "/"
+        #   get :index, :map => "/"                       # => "/"
+        #   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, :with => [:id, :name]              # => "/show/:id/:name"
+        #   get :list, :respond_to => :js                 # => "/list.{:format,js)"
+        #   get :list, :respond_to => :any                # => "/list(.:format)"
+        #   get :list, :respond_to => [:js, :json]        # => "/list.{!format,js|json}"
+        #   get :list, :respond_to => [:html, :js, :json] # => "/list(.{!format,js|json})"
+        #
+        def route(verb, path, options={}, &block)
+          # We dup options so we can build HEAD request correctly
+          options = options.dup
+          # We need check if path is a symbol, if that it's a named route
+          map = options.delete(:map)
+
+          if path.kind_of?(Symbol) # path i.e :index or :show
+            name = path                       # The route name
+            path = map || path.to_s           # The route path
+          end
+
+          if path.kind_of?(String) # path i.e "/index" or "/show"
+            # Now we need to parse our 'with' params
+            if with_params = options.delete(:with)
+              path = process_path_for_with_params(path, with_params)
+            end
+
+            # Now we need to parse our respond_to
+            if format_params = options.delete(:respond_to)
+              path = process_path_for_respond_to(path, format_params)
+            end
+
+            # Build our controller
+            controller = Array(@_controller).collect(&:to_s)
+
+            unless controller.empty?
+              # Now we need to add our controller path only if not mapped directly
+              if map.blank?
+                controller_path = controller.join("/")
+                path = File.join(controller_path, path)
+              end
+              # Here we build the correct name route
+              if name
+                controller_name = controller.join("_")
+                name = "#{controller_name}_#{name}".to_sym unless controller_name.blank?
+              end
+            end
+
+            # Now we need to parse our 'parent' params and parent scope
+            if parent_params = options.delete(:parent) || @_parents
+              parent_params = Array(@_parents) + Array(parent_params)
+              path = process_path_for_parent_params(path, parent_params)
+            end
+
+            # Little reformats
+            path.sub!(%r{\bindex$}, "")                           # If the route end with /index we remove them
+            path = (uri_root == "/" ? "/" : "(/)") if path.blank? # Add a trailing delimiter if path is empty
+
+            # We need to have a path that start with / in some circumstances and that don't end with /
+            if path != "(/)" && path != "/"
+              path = "/" + path unless path =~ %r{^/}
+              path.sub!(%r{/$}, '')
+            end
+
+            # We need to fix some differences between usher and sintra router
+            path.sub!(%r{/\?$}, '(/)') #  '/foo/?' => '/foo(/)'
+          end
+
+          # Standard Sinatra requirements
+          options[:conditions] ||= {}
+          options[:conditions][:request_method] = verb
+          options[:conditions][:host] = options.delete(:host) if options.key?(:host)
+
+          # Because of self.options.host
+          host_name(options.delete(:host)) if options.key?(:host)
+
+          # Sinatra defaults
+          define_method "#{verb} #{path}", &block
+          unbound_method = instance_method("#{verb} #{path}")
+          block =
+          if block.arity != 0
+            proc { unbound_method.bind(self).call(*@block_params) }
+          else
+            proc { unbound_method.bind(self).call }
+          end
+
+          invoke_hook(:route_added, verb, path, block)
+          route = router.add_route(path, options).to(block)
+          route.name(name) if name
+          route
+        end
+
+        ##
+        # Processes the existing path and appends the 'with' parameters onto the route
+        # Used for calculating path in route method
+        #
+        def process_path_for_with_params(path, with_params)
+          File.join(path, Array(with_params).collect(&:inspect).join("/"))
+        end
+
+        ##
+        # Processes the existing path and prepends the 'parent' parameters onto the route
+        # Used for calculating path in route method
+        #
+        def process_path_for_parent_params(path, parent_params)
+          parent_prefix = parent_params.uniq.collect { |param| "#{param}/:#{param}_id" }.join("/")
+          File.join(parent_prefix, path)
+        end
+
+        ##
+        # Processes the existing path and appends the 'format' suffix onto the route
+        # Used for calculating path in route method
+        #
+        def process_path_for_respond_to(path, format_params)
+          format_suffix = case format_params
+            when :any  then "(.:format)"
+            when Array then
+              formats   = format_params.dup # Prevent changes to HEAD verb
+              container = formats.delete(:html) ? "(%s)" : "%s"
+              match     = ".{:format," + formats.collect { |f| "#{f}$" }.join("|") + "}"
+              container % match
+            else ".{:format,#{format_params}}"
+          end
+          path << format_suffix
+        end
+    end
+  end
+end

data/lib/padrino-core/caller.rb

@@ -24,6 +24,8 @@ module Padrino
   # 
   PADRINO_IGNORE_CALLERS.concat(RUBY_IGNORE_CALLERS) if defined?(RUBY_IGNORE_CALLERS)
 
+  private
+
   ##
   # Returns the filename for the file that is the direct caller (first caller)
   # 

data/lib/padrino-core/reloader.rb

@@ -10,7 +10,7 @@ module Padrino
     #
     # It is performing a check/reload cycle at the start of every request, but
     # also respects a cool down time, during which nothing will be done.
-    # 
+    #
     class Rack
       def initialize(app, cooldown = 1)
         @app = app
@@ -33,6 +33,14 @@ module Padrino
       end
     end
 
+    ##
+    # You can exclude some folders from reload its contents.
+    # Defaults excluded directories of Padrino.root are: test, spec, features, tmp, config, lib and public
+    # 
+    def self.exclude
+      @_exclude ||= %w(test spec tmp features config lib public).map { |path| Padrino.root(path) }
+    end
+
     ##
     # What makes it especially suited for use in a any environment is that
     # any file will only be checked once and there will only be made one system
@@ -79,8 +87,8 @@ module Padrino
         # Search Ruby files in your +Padrino.root+ and monitor them for changes.
         # 
         def rotation
-          files = Dir[Padrino.root("/**/*.rb")]
-          paths = [Padrino.root] # For now we set only our root.
+          paths = Dir[Padrino.root("*")].reject { |path| Padrino::Reloader.exclude.include?(path) || !File.directory?(path) }
+          files = paths.map { |path| Dir["#{path}/**/*.rb"] }.flatten
 
           files.map{ |file|
             found, stat = figure_path(file, paths)

data/lib/padrino-core/support_lite.rb

@@ -1,19 +1,17 @@
 ##
-# This file load some usefull extensions from Active Support.
+# This file loads certain extensions required by Padrino from ActiveSupport.
 # 
-# Why ActiveSupport and not ours or extlib?
+# Why use ActiveSupport and not our own library or extlib? 
+#
+# 1) Writing custom method extensions needed (i.e string inflections) is not a good use of time.
+# 2) Loading custom method extensions or separate gem would conflict when AR or MM has been loaded.
+# 3) Datamapper is planning to move to ActiveSupport and away from extlib.
 # 
-# We don't love so much rewite code and we don't use extlib because:
-# 
-#   1) ActiveRecord need ActiveSupport
-#   2) MongoMapper need ActiveSuport
-#   3) DataMapper it's planning to migrate to ActiveSupport (see: http://wiki.github.com/datamapper/dm-core/roadmap)
-# 
-# Required for Padrino to run:
+# Extensions required for Padrino:
 # 
 #   * Class#cattr_accessor
 #   * Module#alias_method_chain
-#   * String#inflectors (classify, underscore, camelize, etc)
+#   * String#inflectors (classify, underscore, camelize, pluralize, etc)
 #   * Array#extract_options!
 #   * Object#blank?
 #   * Object#present?
@@ -38,7 +36,7 @@ require 'active_support/core_ext/module'
 require 'active_support/ordered_hash'
 
 ##
-# Define our Ordered Hash
+# Define our own OrderedHash based on AS::OrderedHash
 # 
 unless defined?(SupportLite::OrderedHash)
   module SupportLite
@@ -47,7 +45,7 @@ unless defined?(SupportLite::OrderedHash)
 end
 
 ##
-# We new alwasy :to_params in a Hash
+# Alias allowing for use of either method to get query parameters
 # 
 unless Hash.method_defined?(:to_params)
   class Hash 
@@ -56,6 +54,6 @@ unless Hash.method_defined?(:to_params)
 end
 
 ##
-# Load our locales
+# Loads our locales configuration files
 # 
 I18n.load_path += Dir["#{File.dirname(__FILE__)}/locale/*.yml"]

data/padrino-core.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{padrino-core}
-  s.version = "0.8.5"
+  s.version = "0.9.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Padrino Team", "Nathan Esquenazi", "Davide D'Agostino", "Arthur Chiu"]
-  s.date = %q{2010-02-18}
+  s.date = %q{2010-02-23}
   s.default_executable = %q{padrino}
   s.description = %q{The Padrino core gem required for use of this framework}
   s.email = %q{padrinorb@gmail.com}
@@ -27,6 +27,9 @@ Gem::Specification.new do |s|
      "bin/padrino",
      "lib/padrino-core.rb",
      "lib/padrino-core/application.rb",
+     "lib/padrino-core/application/mounter.rb",
+     "lib/padrino-core/application/rendering.rb",
+     "lib/padrino-core/application/routing.rb",
      "lib/padrino-core/caller.rb",
      "lib/padrino-core/cli/adapter.rb",
      "lib/padrino-core/cli/base.rb",
@@ -39,7 +42,6 @@ Gem::Specification.new do |s|
      "lib/padrino-core/locale/en.yml",
      "lib/padrino-core/locale/it.yml",
      "lib/padrino-core/logger.rb",
-     "lib/padrino-core/mounter.rb",
      "lib/padrino-core/reloader.rb",
      "lib/padrino-core/server.rb",
      "lib/padrino-core/support_lite.rb",
@@ -80,8 +82,8 @@ Gem::Specification.new do |s|
       s.add_runtime_dependency(%q<i18n>, [">= 0.3.2"])
       s.add_runtime_dependency(%q<usher>, [">= 0.6.2"])
       s.add_runtime_dependency(%q<thor>, [">= 0.13.0"])
-      s.add_runtime_dependency(%q<bundler>, ["= 0.9.5"])
-      s.add_runtime_dependency(%q<activesupport>, [">= 2.3.5"])
+      s.add_runtime_dependency(%q<bundler>, ["= 0.9.7"])
+      s.add_runtime_dependency(%q<activesupport>, ["= 2.3.5"])
       s.add_development_dependency(%q<shoulda>, [">= 2.10.3"])
       s.add_development_dependency(%q<mocha>, [">= 0.9.7"])
       s.add_development_dependency(%q<rack-test>, [">= 0.5.0"])
@@ -91,8 +93,8 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<i18n>, [">= 0.3.2"])
       s.add_dependency(%q<usher>, [">= 0.6.2"])
       s.add_dependency(%q<thor>, [">= 0.13.0"])
-      s.add_dependency(%q<bundler>, ["= 0.9.5"])
-      s.add_dependency(%q<activesupport>, [">= 2.3.5"])
+      s.add_dependency(%q<bundler>, ["= 0.9.7"])
+      s.add_dependency(%q<activesupport>, ["= 2.3.5"])
       s.add_dependency(%q<shoulda>, [">= 2.10.3"])
       s.add_dependency(%q<mocha>, [">= 0.9.7"])
       s.add_dependency(%q<rack-test>, [">= 0.5.0"])
@@ -103,8 +105,8 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<i18n>, [">= 0.3.2"])
     s.add_dependency(%q<usher>, [">= 0.6.2"])
     s.add_dependency(%q<thor>, [">= 0.13.0"])
-    s.add_dependency(%q<bundler>, ["= 0.9.5"])
-    s.add_dependency(%q<activesupport>, [">= 2.3.5"])
+    s.add_dependency(%q<bundler>, ["= 0.9.7"])
+    s.add_dependency(%q<activesupport>, ["= 2.3.5"])
     s.add_dependency(%q<shoulda>, [">= 2.10.3"])
     s.add_dependency(%q<mocha>, [">= 0.9.7"])
     s.add_dependency(%q<rack-test>, [">= 0.5.0"])

data/test/fixtures/apps/complex.rb

@@ -21,7 +21,7 @@ Complex1Demo.controllers do
 end
 
 Complex2Demo.controllers do
-  get("(/)"){ "The magick number is: 40!" } # Change only the number!!!
+  get("(/)"){ "The magick number is: 33!" } # Change only the number!!!
 end
 
 Padrino.load!

data/test/fixtures/apps/simple.rb

@@ -11,7 +11,7 @@ end
 
 SimpleDemo.controllers do
   get "/" do
-    'The magick number is: 12!' # Change only the number!!!
+    'The magick number is: 39!' # Change only the number!!!
   end
 end
 

data/test/test_application.rb

@@ -147,25 +147,4 @@ class TestApplication < Test::Unit::TestCase
       end
     end
   end
-
-  context 'for application i18n functionality' do
-
-    should 'have auto_locale disabled' do
-      mock_app do
-        assert !auto_locale
-      end
-    end
-
-    should 'set locale when auto_locale is enabled' do
-      mock_app do
-        enable :auto_locale
-        get("/:locale"){ I18n.locale.to_s }
-      end
-
-      %w(it de fr).each do |lang|
-        get("/#{lang}")
-        assert_equal lang, body
-      end
-    end
-  end
 end

data/test/test_routing.rb

@@ -12,7 +12,22 @@ class TestRouting < Test::Unit::TestCase
     assert_equal "okey", body
   end
 
-  should 'match correcly similar paths' do
+  should "parse routes with question marks" do
+    mock_app do
+      get("/foo/?"){ "okey" }
+      post('/unauthenticated/?') { "no access" }
+    end
+    get "/foo"
+    assert_equal "okey", body
+    get "/foo/"
+    assert_equal "okey", body
+    post "/unauthenticated"
+    assert_equal "no access", body
+    post "/unauthenticated/"
+    assert_equal "no access", body
+  end
+
+  should 'match correctly similar paths' do
     mock_app do
       get("/my/:foo_id"){ params[:foo_id] }
       get("/my/:bar_id/bar"){ params[:bar_id] }
@@ -189,6 +204,26 @@ class TestRouting < Test::Unit::TestCase
     assert_equal "foo_bar_index", body
   end
 
+  should 'use named controllers with array routes' do
+    mock_app do
+      controller :admin do
+        get(:index){ "index" }
+        get(:show, :with => :id){ "show #{params[:id]}" }
+      end
+      controllers :foo, :bar do
+        get(:index){ "foo_bar_index" }
+      end
+    end
+    get "/admin"
+    assert_equal "index", body
+    get "/admin/show/1"
+    assert_equal "show 1", body
+    assert_equal "/admin", @app.url(:admin, :index)
+    assert_equal "/admin/show/1", @app.url(:admin, :show, :id => 1)
+    get "/foo/bar"
+    assert_equal "foo_bar_index", body
+  end
+
   should 'reset routes' do
     mock_app do
       get("/"){ "foo" }
@@ -214,4 +249,37 @@ class TestRouting < Test::Unit::TestCase
     assert_equal "edit 1", body
   end
 
-end
+  should "apply parent to route" do
+    mock_app do
+      controllers :project do
+        get(:index, :parent => :user) { "index #{params[:user_id]}" }
+        get(:edit, :with => :id, :parent => :user) { "edit #{params[:id]} #{params[:user_id]}"}
+        get(:show, :with => :id, :parent => [:user, :product]) { "show #{params[:id]} #{params[:user_id]} #{params[:product_id]}"}
+      end
+    end
+    get "/user/1/project"
+    assert_equal "index 1", body
+    get "/user/1/project/edit/2"
+    assert_equal "edit 2 1", body
+    get "/user/1/product/2/project/show/3"
+    assert_equal "show 3 1 2", body
+
+  end
+
+  should "apply parent to controller" do
+    mock_app do
+      controller :project, :parent => :user do
+        get(:index) { "index #{params[:user_id]}"}
+        get(:edit, :with => :id, :parent => :user) { "edit #{params[:id]} #{params[:user_id]}"}
+        get(:show, :with => :id, :parent => :product) { "show #{params[:id]} #{params[:user_id]} #{params[:product_id]}"}
+      end
+    end
+    get "/user/1/project"
+    assert_equal "index 1", body
+    get "/user/1/project/edit/2"
+    assert_equal "edit 2 1", body
+    get "/user/1/product/2/project/show/3"
+    assert_equal "show 3 1 2", body
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: padrino-core
 version: !ruby/object:Gem::Version 
-  version: 0.8.5
+  version: 0.9.0
 platform: ruby
 authors: 
 - Padrino Team
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-18 00:00:00 +01:00
+date: 2010-02-23 00:00:00 -08:00
 default_executable: padrino
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -63,7 +63,7 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 0.9.5
+        version: 0.9.7
     version: 
 - !ruby/object:Gem::Dependency 
   name: activesupport
@@ -71,7 +71,7 @@ dependencies:
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">="
+    - - "="
       - !ruby/object:Gem::Version 
         version: 2.3.5
     version: 
@@ -133,6 +133,9 @@ files:
 - bin/padrino
 - lib/padrino-core.rb
 - lib/padrino-core/application.rb
+- lib/padrino-core/application/mounter.rb
+- lib/padrino-core/application/rendering.rb
+- lib/padrino-core/application/routing.rb
 - lib/padrino-core/caller.rb
 - lib/padrino-core/cli/adapter.rb
 - lib/padrino-core/cli/base.rb
@@ -145,7 +148,6 @@ files:
 - lib/padrino-core/locale/en.yml
 - lib/padrino-core/locale/it.yml
 - lib/padrino-core/logger.rb
-- lib/padrino-core/mounter.rb
 - lib/padrino-core/reloader.rb
 - lib/padrino-core/server.rb
 - lib/padrino-core/support_lite.rb