padrino-core 0.5.0 → 0.6.1

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Padrino
+Copyright (c) 2010 Padrino
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -1,18 +1,81 @@
 = padrino-core
 
+Padrino is the godfather of Sinatra.
+
+== Preface
+
+Padrino is a ruby framework build upon the {Sinatra Microframework}[http://www.sinatrarb.com].
+
+Sinatra is a DSL for quickly creating web applications in Ruby with minimal effort.
+  
+The extreme simplicity of this framework is quite refreshing. We have been using Sinatra a great deal
+for recent projects. First for small and simple json and xml web services and then even
+for more complex full-featured applications. 
+
+This gem represents an attempt to make it as fun and easy as possible to code increasingly advanced web applications in Sinatra.
+
+== Introduction
+
+Many people love Sinatra's simplicity and lightweight but often quickly come to miss a great deal
+of functionality provided by other web frameworks such as Rails when building non-trivial applications.
+
+The obvious question in these cases might be "Why not just use rails then?". This can often be a viable option
+but still Rails is quite a large framework with a 'take it or leave it' attitude.
+
+Personally, we have come to love the philosophy of Sinatra which acts as a thin layer on top of rack 
+often allowing middleware to do most of the work and pulling in additional complexity only when required. 
+
+Our goal with this framework is to match the essence of Sinatra and at the same time create a standard library
+of tools, helpers and components that will make Sinatra suitable for more complex applications.
+
+Here is a small list of what Padrino provides:
+
+Generators:: for creating new padrino applications i.e.: <tt>padrino-gen app</tt> or <tt>padrino start</tt> on command line
+MultiApp:: unlike other ruby frameworks Padrino is principally designed for mounting multiple apps at the same time.
+Routing:: Full url named route, named params, respond_to suppor
+Tag Helpers:: helpers such as: <tt>tag</tt>, <tt>content_tag</tt>, <tt>input_tag</tt>, ...
+Asset Helpers:: helpers such as: <tt>link_to</tt>, <tt>image_tag</tt>, <tt>javascript_include_tag</tt>, ...
+Form Helpers:: with builder support such as: <tt>form_tag</tt>, <tt>form_for</tt>, <tt>field_set_tag</tt>, <tt>text_field</tt>, ...
+Text Helpers:: useful formatting extensions like: <tt>relative_time_ago</tt>, <tt>js_escape_html</tt>, <tt>sanitize_html</tt>
+Mailer:: fast, tiny, delivery support for send templating emails (like ActionMailer do)
+Admin:: an ajax admin that displays your records in sortable grids, tree, windows ... as a desktop app can do.
+Logging:: Padrino provide a logger that can interact with your orm or any other library
+Reloading:: With padrino is not necessary like other framework start and restart your server for see changes.
+I18n:: Padrino has a full support of I18n and can autoset locale.
+
+Keep in mind, the user will be able to pull in these components seperately and leave out those that are not required
+or use them altogether for a comprehensive upgrade to Sinatra (a full-stack Padrino application).
+
+Note that all work has been created to be compatible with haml, erb, and erubis and that this gem is intended to be 
+template-agnostic in providing helpers wherever possible.
+
+Please help me brainstorm and fork the project if you have any ideas to contribute.
+
 == Installation
 
-To install the 'full-stack' padrino framework, simply grab the latest version from gemcutter:
+To install the padrino framework, simply grab the latest version from gemcutter:
 
   $ sudo gem install padrino --source http://gemcutter.org
   
 This will install the necessary padrino gems to get you started.
-Now you are ready to use this gem to enhance your existing Sinatra projects or build new Padrino applications.
+Now you are ready to use this gem to enhance your sinatra projects or to create new Padrino applications.
 
 == Usage
 
-For a comprehensive overview of the whole padrino-framework, check out the 
-{Padrino Framework README}[http://github.com/padrino/padrino-framework/blob/master/README.rdoc]
+Padrino is a framework which builds on the existing functionality and Sinatra and provides a variety of 
+additional tools and helpers to extend the foundation. This README and Padrino documentation in general will focus
+on the enhancements to the core Sinatra functionality. To use Padrino, one should be familiar with the basic 
+usage of Sinatra itself. Resources for Sinatra are listed below:
+
+* {Sinatra Introduction}[http://www.sinatrarb.com/intro.html]
+* {Sinatra Book}[http://www.sinatrarb.com/book.html]
+* {Sinatra Github Repo}[http://github.com/sinatra/sinatra]
+
+Below is a guide to how this gem enhances the Sinatra framework as part of a 'full-stack' padrino application.
+For information on how to use a specific gem in isolation within an existing Sinatra project, checkout the README for that 
+individual gem or gems.
+
+== Enhanced Base Application (padrino-core)
 
 Sinatra has support for classes which can be extended to create an application: <tt>Sinatra::Base</tt> and <tt>Sinatra::Application</tt>
 These classes can be extended in order to create a Sinatra web application. These classes provide support for all the basic
@@ -35,11 +98,170 @@ Let us first take a look at the simplest possible Padrino application:
   Padrino.load!
 
   class SimpleApp < Padrino::Application
-    get '/ do
+    get '/' do
       'Hello world'
     end
+    
+    # and for read better we can divide with controllers
+    controller '/admin' do
+      get '/foo' do
+        'Im /admin/foo
+      end
+    end
   end
-  
+
+=== Controllers
+
+Suppose we wanted to add additional routes to our Padrino application, and we want to organize the routes
+within a more structured layout. Simply add a <tt>controllers</tt> or <tt>app/controllers</tt> folder and create a file as such:
+
+  # Simple Example
+  SimpleApp.controllers do
+    get "/test" do
+      "Text to return"
+    end
+  end
+
+== Advanced Routing Support
+
+Padrino provides support for advanced routing functionality not available within Sinatra. This routing
+supports named route aliases and easy access to url paths. The benefits of this is that instead of having to 
+hard-code route urls into every area of your application, now we can just define the urls in a 
+single spot and then attach an alias which can be used to refer to the url throughout the application.
+
+=== Padrino Routing
+
+Urls mapped here can then be defined within a controller:
+
+  # app/controllers/example.rb
+  SimpleApp.controllers do
+    get :index do
+      ...
+    end
+
+    get :account do
+      # access params[:name] and params[:index]
+    end
+  end
+
+and finally referenced anywhere in the application:
+
+  # app/views/example.haml
+  = link_to "Index", url_for(:index)
+  = link_to "Account", url_for(:account, :id => 1, :name => 'first')
+
+=== Inline Route Alias Definitions
+
+The routing plugin also supports inline route definitions in which the url and the named alias
+are defined together within the controller:
+
+  # app/controllers/example.rb
+  SimpleApp.controllers do
+    get :index, :map => '/index' do
+      ...
+    end
+
+    get :account, :map => '/the/accounts/:name/and/:id' do
+      # access params[:name] and params[:index]
+    end
+  end
+
+Routes defined inline this way can be accessed and treated the same way as traditional named aliases.
+
+=== Namespaced Route Aliases
+
+There is also support for namespaced routes which are organized into a larger grouping:
+
+  # app/controllers/example.rb
+  SimpleApp.controllers :admin do
+    get :show do
+      "Im /admin/show"
+    end
+
+    get :index, :map => "/admin/:id" do
+      "Im /admin/#{params[:id]}"
+    end
+  end
+
+You can then reference the urls using the same url_for method: 
+
+  <%= link_to 'admin show page', url_for(:admin_show, :id => 25) %>
+  <%= link_to 'admin index page', url_for(:admin_index, :id => 25) %>
+
+If you don't want named routes you can
+
+  # app/controllers/example.rb
+  SimpleApp.controllers "/admin" do
+    get "/show" do
+      "Im /admin/show"
+    end
+
+    get "other/:id" do
+      "Im /admin/#{params[:id]}"
+    end
+  end
+
+=== Named Params
+
+With Padrino you can use named params!! See these examples
+
+  # app/controllers/example.rb
+  SimpleApp.controllers :admin do
+    get :show, :with => :id do
+      "Im /admin/show/#{params[:id]}"
+    end
+
+    get :other, with => [:id, :name]  do
+      "Im /admin/#{params[:id]}/#{params[:name]}"
+    end
+  end
+
+You can then reference the urls using the same url_for method: 
+
+  <%= link_to 'admin show page', url_for(:admin_show, :id => 25) %>
+  <%= link_to 'admin other page', url_for(:admin_index, :id => 25, :name => :foo) %>
+
+=== Respond To
+
+With Padrino you can simply respond to a given format see example:
+
+  # app/controllers/example.rb
+  SimpleApp.controllers :admin do
+    get :show, :with => :id, :respond_to => :js do
+      "Im /admin/show/#{params[:id]}.#{params[:format]}"
+    end
+
+    get :other, with => [:id, :name], respond_to => [:html, :json] do
+      case content_type
+        when :js    then ... end
+        when :json  then ... end
+      end
+    end
+  end
+
+  <%= link_to 'admin show page', url_for(:admin_show, :id => 25, :format => :js) %>
+  <%= link_to 'admin other page', url_for(:admin_index, :id => 25, :name => :foo) %>
+  <%= link_to 'admin other json page', url_for(:admin_index, :id => 25, :name => :foo, :format => :json) %>
+
+=== Rendering
+
+Unlike Sinatra Padrino support template auto lookup so:
+
+  # look for 'account/index.{erb,haml,...}
+  render 'account/index'
+
+=== Layout
+
+With Padrino you can (like rails do) use for your custom layout, disable it
+
+  class SimpleApp < Padrino::Application
+    
+    # Disable layouts
+    disable layout
+    
+    # Use the layout located in views/layouts/custom.haml
+    layout :custom
+
 === Gemfile Dependency Resolution
   
 While this is a fully operational Padrino application in itself, let us take a look at Padrino's expanded capabilites. First, 
@@ -97,18 +319,6 @@ directory following this convention:
 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)
 
-=== Controllers
-
-Suppose we wanted to add additional routes to our Padrino application, and we want to organize the routes
-within a more structured layout. Simply add a <tt>controllers</tt> or <tt>app/controllers</tt> folder and create a file as such:
-
-  # controllers/example.rb
-  SimpleApp.controllers do
-    get "/test" do
-      "Text to return"
-    end
-  end
-  
 === Application Logging
 
 Padrino also supports robust logging capabilities. By default, logging information will
@@ -200,8 +410,11 @@ The following commands are available:
   # Bootup the Padrino console (irb)
   $ padrino console
   
+  # Run/List tasks
+  $ padrino rake
+
 Using these commands can simplify common tasks making development that much smoother.
 
 == Copyright
 
-Copyright (c) 2009 Padrino. See LICENSE for details.
+Copyright (c) 2010 Padrino. See LICENSE for details.

data/Rakefile

@@ -13,6 +13,7 @@ begin
     gem.executables = ["padrino"]
     gem.add_runtime_dependency     "sinatra",       ">= 0.9.2"
     gem.add_runtime_dependency     "i18n",          ">= 0.3.2"
+    gem.add_runtime_dependency     "usher",         ">= 0.6.2"
     gem.add_runtime_dependency     "thor",          ">= 0.11.8"
     gem.add_development_dependency "haml",          ">= 2.2.1"
     gem.add_runtime_dependency     "bundler",       ">= 0.5.0"

data/VERSION

@@ -1 +1 @@
-0.5.0
+0.6.1

data/bin/padrino

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 %w[rubygems thor].each { |gem| require gem }
-require File.dirname(__FILE__) + "/../lib/padrino-core/tasks"
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../lib"
 
+require "padrino-core/cli"
 arguments = ARGV.any? ? ARGV : ['-h']
-Padrino::Tasks::Base.start(arguments)
+Padrino::Cli::Base.start(arguments)

data/lib/padrino-core.rb

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

data/lib/padrino-core/application.rb

@@ -4,12 +4,47 @@ module Padrino
   # These subclassed applications can be easily mounted into other Padrino applications as well.
   class Application < Sinatra::Application
 
+    # Return the request format, this is useful when we need to respond to a given content_type like:
+    # 
+    #   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:
+    # 
+    #   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)
+      public_dir = File.expand_path(options.public)
+      path = File.expand_path(File.join(public_dir, unescape(path)))
+      path[0, public_dir.length] == public_dir && File.file?(path)
+    end
+
     class << self
       def inherited(subclass)
         CALLERS_TO_IGNORE.concat(PADRINO_IGNORE_CALLERS)
         subclass.default_configuration!
+        Padrino.require_dependencies(File.join(subclass.root, "/models/**/*.rb"))
         super # Loading the subclass
-        subclass.register Padrino::Routing if defined?(Padrino::Routing)
+        subclass.default_filters!
+        subclass.default_routes!
       end
 
       # Hooks into when a new instance of the application is created
@@ -21,12 +56,67 @@ module Padrino
         super
       end
 
-      # Makes the routes defined in the block and in the Modules given
-      # in `extensions` available to the application
-      def controllers(*extensions, &block)
-        instance_eval(&block) if block_given?
-        include(*extensions)  if extensions.any?
+      # 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
+      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:
+      # 
+      #   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)
@@ -50,7 +140,8 @@ module Padrino
 
       # Resets application routes to only routes not defined by the user
       def reset_routes!
-        @routes = Padrino::Application.respond_to?(:dupe_routes) ? Padrino::Application.dupe_routes : {}
+        router.reset!
+        default_routes!
       end
 
       # Setup the application by registering initializers, load paths and logger
@@ -64,7 +155,6 @@ module Padrino
         self.disable :logging # We need do that as default because Sinatra use commonlogger.
         I18n.locale = self.locale
         I18n.load_path += self.translations
-        self.get(""){ redirect("#{options.uri_root}/") } if self.uri_root != "/"
         @_configured = true
       end
 
@@ -93,6 +183,25 @@ module Padrino
           set :padrino_helpers, defined?(Padrino::Helpers)
         end
 
+        def default_routes!
+          # images resources
+          get "/__sinatra__/:image.png" do
+            filename = File.dirname(__FILE__) + "/images/#{params[:image]}.png"
+            send_file filename
+          end
+        end
+
+        # This filter it's used for know the format of the request, and automatically set the content type.
+        def default_filters!
+          before do
+            unless options.static? && options.public? && (request.get? || request.head?) && static_file?(request.path_info)
+              request.path_info =~ /\.([^\.\/]+)$/
+              @_content_type = ($1 || :html).to_sym
+              content_type(@_content_type) rescue content_type('application/octet-stream')
+            end
+          end
+        end
+
         # Calculates any required paths after app_file and root have been properly configured
         # Executes as part of the setup_application! method
         def calculate_paths
@@ -111,7 +220,7 @@ module Padrino
           Dir[@initializer_path].each { |file| register_initializer(file) }
         end
 
-        # Registers all desired padrino extension helpers/routing
+        # Registers all desired padrino extension helpers
         def register_framework_extensions
           register Padrino::Mailer        if padrino_mailer?
           register Padrino::Helpers       if padrino_helpers?
@@ -120,7 +229,7 @@ module Padrino
 
         # Returns the load_paths for the application (relative to the application root)
         def load_paths
-          @load_paths ||= ["urls.rb", "config/urls.rb", "models/*.rb", "mailers/*.rb", "controllers/**/*.rb", "helpers/*.rb"]
+          @load_paths ||= ["urls.rb", "config/urls.rb", "mailers/*.rb", "controllers/**/*.rb", "helpers/*.rb"]
         end
 
         # Requires all files within the application load paths
@@ -144,15 +253,172 @@ module Padrino
           logger.error "The module '#{file_class}Initializer' (#{file_path}) didn't loaded properly!"
           logger.error "   Initializer error was '#{e.message}'"
         end
-      end
+
+      private
+        # Rewrite default because now routes can be:
+        # 
+        #   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
+              lambda { unbound_method.bind(self).call(*@block_params) }
+            else
+              lambda { 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
 
     private
+      # TODO: remove this when sinatra 1.0 will be released
+      # Compatibility with sinatra 0.9.4
+      def static!
+        return if (public_dir = options.public).nil?
+        public_dir = File.expand_path(public_dir)
+
+        path = File.expand_path(public_dir + unescape(request.path_info))
+        return if path[0, public_dir.length] != public_dir
+        return unless File.file?(path)
+
+        send_file path, :disposition => nil
+      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 pass "/:locale/some/foo" we automatically set teh I18n locale to params[:locale]
+      # * if params[:locale] is empty we use the first HTTP_ACCEPT_LANGUAGE
+      def route_eval(&block)
+        if options.auto_locale
+          if params[:locale]
+            I18n.locale = params[:locale].to_sym rescue options.locale
+          end
+        end
+        super
+      end
+
       # Hijacking the sinatra render for do two thing:
       # 
       # * Use layout like rails do
       # * Use render 'path/to/my/template'
       # 
       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 an engine is a string probably is a path so we try to resolve them
         if data.nil?
@@ -178,18 +444,6 @@ module Padrino
         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
-      
-      # When we set :auto_locale, true then:
-      # 
-      # * if we pass "/:locale/some/foo" we automatically set teh I18n locale to params[:locale]
-      # * if params[:locale] is empty we use the first HTTP_ACCEPT_LANGUAGE
-      def route_eval(&block)
-        if options.auto_locale
-          if params[:locale]
-            I18n.locale = params[:locale].to_sym rescue options.locale
-          end
-        end
-        super
-      end
   end
+
 end