*Rails 3.1.0 (unreleased)*

* Added config.action_controller.include_all_helpers. By default 'helper :all' is done in ActionController::Base, which includes all the helpers by default. Setting include_all_helpers to false will result in including only application_helper and helper corresponding to controller (like foo_helper for foo_controller). [Piotr Sarnacki]

* Added a convenience idiom to generate HTML5 data-* attributes in tag helpers from a :data hash of options:

s.add_dependency('activemodel', version)

s.add_dependency('rack-cache', '~> 0.5.3')

s.add_dependency('builder', '~> 3.0.0')

s.add_dependency('rack', '~> 1.2.1')

s.add_dependency('rack-test', '~> 0.5.6')

s.add_dependency('rack-mount', '~> 0.6.13')

# A list of all internal methods for a controller. This finds the first

# abstract superclass of a controller, and gets a list of all public

# instance methods on that abstract class. Public instance methods of

def internal_methods

controller = self

controller = controller.superclass until controller.abstract?

controller_path

end

#

def _write_layout_method

remove_possible_method(:_layout)

module Caching

# Action caching is similar to page caching by the fact that the entire

# output of the response is cached, but unlike page caching, every

#

# class ListsController < ApplicationController

# before_filter :authenticate, :except => :public

# caches_page :public

# end

#

#

# <tt>http://david.example.com/lists/show/1</tt> will result in a fragment named

# <tt>david.example.com/lists/show/1</tt>. This allows the cacher to

# differentiate between <tt>david.example.com/lists/</tt> and

# <tt>:action => 'list', :format => :xml</tt>.

#

# You can set modify the default action cache path by passing a

#

#

#

# class ListsController < ApplicationController

# before_filter :authenticate, :except => :public

# caches_action :index, :if => proc do |c|

# !c.request.format.json? # cache if is not a JSON request

# end

# caches_action :show, :cache_path => { :project => 1 },

# :expires_in => 1.hour

#

# else

# end

# end

# end

#

#

module Actions

extend ActiveSupport::Concern

# Manually cache the +content+ in the key determined by +path+. Example:

# cache_page "I'm the cached content", "/lists/show"

return unless perform_caching

instrument_page_cache :write_page, path do

FileUtils.makedirs(File.dirname(path))

end

private

name = (path.empty? || path == "/") ? "/index" : URI.parser.unescape(path.chomp('/'))

return name

end

end

def instrument_page_cache(name, path)

request.path

end

end

end

options.page_cache_directory ||= paths["public"].first

# make sure readers methods get compiled

ActiveSupport.on_load(:action_controller) do

include app.routes.mounted_helpers

end

else

# keep track of creation order to keep the subsequent sort stable

params, q = header.split(/;\s*q=/)

params.strip!

if params =~ TRAILING_STAR_REGEXP

else

end

end

end

end

# input: 'text'

#

# input: 'application'

def parse_data_with_trailing_star(input)

end

# This method is opposite of register method.

#

# Usage:

#

end

end

mattr_accessor :tld_length

self.tld_length = 1

# Returns the complete URL used for this request.

def url

def subdomain(tld_length = @@tld_length)

subdomains(tld_length)

end

end

end

end

require 'active_support/core_ext/hash/except'

require 'active_support/core_ext/object/blank'

require 'active_support/inflector'

module ActionDispatch

module Routing

#

# root :to => 'pages#main'

#

def root(options = {})

match '/', options.reverse_merge(:as => :root)

end

# Mount a Rack-based application to be used within the application.

#

#

# Alternatively:

#

#

# All mounted applications come with routing helpers to access them.

# These are named after the class specified, so for the above example

# the helper is either +some_rack_app_path+ or +some_rack_app_url+.

# To customize this helper's name, use the +:as+ option:

#

#

# This will generate the +exciting_path+ and +exciting_url+ helpers

# which can be used to navigate to this mounted app.

end

def define_generate_prefix(app, name)

_route = @set.named_routes.routes[name.to_sym]

_routes = @set

map_method(:delete, *args, &block)

end

private

def map_method(method, *args, &block)

options = args.extract_options!

# admin_post DELETE /admin/posts/:id(.:format) {:action=>"destroy", :controller=>"admin/posts"}

# === Supported options

#

#

# [:path]

# The path prefix for the routes.

:shallow_path => path, :shallow_prefix => path }.merge!(options)

scope(options) { yield }

end

# === Parameter Restriction

# Allows you to constrain the nested routes based on a set of rules.

# For instance, in order to change the routes to allow for a dot character in the +id+ parameter:

#

# Now routes such as +/posts/1+ will no longer be valid, but +/posts/1.1+ will be.

# The +id+ parameter must match the constraint passed in for this example.

# You may use this to also resrict other parameters:

#

# resources :posts do

end

end

def namespace(path, options = {})

if resource_scope?

nested { super }

include Base

include HttpHelpers

include Scoping

include Resources

include Shorthand

raise_routing_error unless path

return [path, params.keys] if @extras

rescue Rack::Mount::RoutingError

raise_routing_error

end

end

RESERVED_OPTIONS = [:host, :protocol, :port, :subdomain, :domain, :tld_length,

def _generate_prefix(options = {})

nil

handle_positional_args(options)

path = (script_name.blank? ? _generate_prefix(options) : script_name.chomp('/')).to_s

path_options = options.except(*RESERVED_OPTIONS)

path_options = yield(path_options) if block_given?

end

def call(env)

private

end

end

def handle_positional_args(options)

options.merge!(Hash[args.zip(keys).map { |v, k| [k, v] }])

end

end

end

end

# Set the host name to use in the next request.

#

# session.host! "www.example.com"

private

def _mock_session

#

# === Template caching

#

#

# == Builder

#

# form_tag('/upload', :multipart => true)

# # => <form action="/upload" method="post" enctype="multipart/form-data">

#

# <div><%= submit_tag 'Save' %></div>

# <% end -%>

# # => <form action="/posts" method="post"><div><input type="submit" name="submit" value="Save" /></div></form>

require 'action_view/helpers/tag_helper'

module ActionView

# = Action View Translation Helpers

module Helpers

module TranslationHelper

# Delegates to I18n#translate but also performs three additional functions.

#

# Second, it'll scope the key by the current partial if the key starts

# with a period. So if you call <tt>translate(".foo")</tt> from the

# naming convention helps to identify translations that include HTML tags so that

# you know what kind of output to expect when you call translate in a template.

def translate(key, options = {})

if html_safe_translation_key?(key) && translation.respond_to?(:html_safe)

translation.html_safe

else

translation

end

end

alias :t :translate

def args_for_lookup(name, prefix, partial, keys) #:nodoc:

name, prefix = normalize_name(name, prefix)

end

# Support legacy foo.erb names even though we now ignore .erb

METHOD

end

end

def find_all(*args)

elsif options.key?(:file)

with_fallbacks { find_template(options[:file], options[:prefix], false, keys) }

elsif options.key?(:inline)

Template.new(options[:inline], "inline template", handler, :locals => keys)

elsif options.key?(:template)

options[:template].respond_to?(:render) ?

end

arity = @handler.respond_to?(:arity) ? @handler.arity : @handler.method(:call).arity

# Make sure that the resulting String to be evalled is in the

# encoding of the code

end

def handler_class_for_extension(extension)

end

end

end

end

# Normalizes the arguments and passes it on to find_template.

cached(key, [name, prefix, partial], details, locals) do

find_templates(name, prefix, partial, details)

end

def extract_handler_and_format(path, default_formats)

pieces = File.basename(path).split(".")

pieces.shift

format = pieces.last && Mime[pieces.last]

[handler, format]

end

class PageCachingTestController < CachingController

caches_page :ok, :no_content, :if => Proc.new { |c| !c.request.format.json? }

caches_page :found, :not_found

def ok

def trailing_slash

render :text => "Sneak attack"

end

end

class PageCachingTest < ActionController::TestCase

assert File.exist?("#{FILE_STORE_PATH}/page_caching_test/trailing_slash.html")

end

def test_should_cache_with_trailing_slash_on_url

@controller.class.cache_page 'cached content', '/page_caching_test/trailing_slash/'

assert File.exist?("#{FILE_STORE_PATH}/page_caching_test/trailing_slash.html")

def teardown

super

end

def test_html

def setup

super

@request.host = "www.example.com"

end

def teardown

super

end

def test_using_resource

@controller = RenderJsonRespondWithController.new

@request.accept = "application/json"

get :index, :format => :json

end

def test_no_double_render_is_raised

def teardown

super

end

def test_missing_layout_renders_properly

ROUTING = ActionDispatch::Routing

# See RFC 3986, section 3.3 for allowed path characters.

class UriReservedCharactersRoutingTest < Test::Unit::TestCase

def setup

@set = ActionDispatch::Routing::RouteSet.new

@set.draw do

end

def test_route_generation_escapes_unsafe_path_characters

assert_equal "/content/act#{@escaped}ion/var#{@escaped}iable/add#{@escaped}itional-1/add#{@escaped}itional-2",

end

def test_route_recognition_unescapes_path_components

end

def test_route_generation_allows_passing_non_string_values_to_generated_helper

end

end

end

class LegacyRouteSetTests < Test::Unit::TestCase

attr_reader :rs

def setup

def test_default_setup

@rs.draw { match '/:controller(/:action(/:id))' }

assert_equal({:controller => "content", :action => 'index'}, rs.recognize_path("/content"))

assert_equal({:controller => "content", :action => 'show', :id => '10'}, rs.recognize_path("/content/show/10"))

assert_equal({:controller => "admin/user", :action => 'show', :id => '10'}, rs.recognize_path("/admin/user/show/10"))

end

def test_ignores_leading_slash

match ':controller/:admintoken(/:action(/:id))', :controller => /admin\/.+/

match '/:controller(/:action(/:id))'

end

assert_equal({:controller => "admin/user", :admintoken => "foo", :action => "index"},

rs.recognize_path("/admin/user/foo"))

end

def test_route_with_regexp_and_captures_for_controller

end

# Without a file extension

assert_equal '/user/download/file',

rs.recognize_path("/user/download/file"))

# Now, let's try a file with an extension, really a dot (.)

assert_equal '/user/download/file.jpg',

rs.recognize_path("/user/download/file.jpg"))

end

rs.draw do

root :to => 'content#list', :as => 'home'

end

end

def test_named_route_with_option

rs.draw do

match 'page/:title' => 'content#show_page', :as => 'page'

end

assert_equal("http://test.host/page/new%20stuff",

end

def test_named_route_with_default

rs.draw do

match 'page/:title' => 'content#show_page', :title => 'AboutPage', :as => 'page'

end

end

def test_named_route_with_path_prefix

match 'page' => 'content#show_page', :as => 'page'

end

end

assert_equal("http://test.host/my/page",

end

def test_named_route_with_blank_path_prefix

match 'page' => 'content#show_page', :as => 'page'

end

end

assert_equal("http://test.host/page",

end

def test_named_route_with_nested_controller

rs.draw do

match 'admin/user' => 'admin/user#index', :as => "users"

end

assert_equal("http://test.host/admin/user",

end

def test_optimised_named_route_with_host

rs.draw do

match 'page' => 'content#show_page', :as => 'pages', :host => 'foo.com'

end

end

def setup_for_named_route

rs.draw do

root :to => "hello#index"

end

end

def test_named_route_with_regexps

:year => /\d+/, :month => /\d+/, :day => /\d+/

match ':controller/:action/:id'

end

end

def test_changing_controller

@rs.draw { match ':controller/:action/:id' }

end

def test_paths_escaped

end

# No / to %2F in URI, only for query params.

end

def test_non_controllers_cannot_be_matched

rs.draw do

match 'post/:id' => 'post#show', :constraints => { :id => /\d+/ }, :as => 'post'

end

end

def test_dynamic_path_allowed

match '*path' => 'content#show_file'

end

end

def test_dynamic_recall_paths_allowed

match '*path' => 'content#show_file'

end

end

def test_backwards

match ':controller(/:action(/:id))'

end

end

def test_route_with_fixnum_default

match ':controller/:action/:id'

end

assert_equal({:controller => "content", :action => 'show_page', :id => 1 }, rs.recognize_path("/page"))

assert_equal({:controller => "content", :action => 'show_page', :id => '1'}, rs.recognize_path("/page/1"))

match ':controller/:action/:id'

end

token = "\321\202\320\265\320\272\321\201\321\202" # 'text' in russian

token.force_encoding(Encoding::BINARY) if token.respond_to?(:force_encoding)

escaped_token = CGI::escape(token)

end

def test_action_expiry

@rs.draw { match ':controller(/:action(/:id))' }

end

def test_requirement_should_prevent_optional_id

match 'post/:id' => 'post#show', :constraints => {:id => /\d+/}, :as => 'post'

end

assert_raise ActionController::RoutingError do

end

end

match ':controller/:action/:id'

end

end

def test_set_to_nil_forgets

end

assert_equal '/pages/2005',

assert_equal '/pages/2005/6',

assert_equal '/pages/2005/6/12',

assert_equal '/pages/2005/6/4',

assert_equal '/pages/2005/6',

assert_equal '/pages/2005',

end

def test_root_url_generation_with_controller_and_action

root :to => "content#index"

end

end

def test_named_root_url_generation_with_controller_and_action

root :to => "content#index", :as => 'home'

end

end

def test_named_route_method

match ':controller(/:action(/:id))'

end

end

def test_named_routes_array

match ':controller/:action/:id'

end

end

def setup_request_method_routes_for(method)

match '/posts/new/:action' => 'subpath_books'

end

end

def test_failed_constraints_raises_exception_with_violated_constraints

match 'foos/:id' => 'foos#show', :as => 'foo_with_requirement', :constraints => { :id => /\d+/ }

end

assert_raise(ActionController::RoutingError) do

end

end

assert_not_nil hash

assert_equal %w(cc ac), [hash[:controller], hash[:action]]

end

end

class RouteSetTest < ActiveSupport::TestCase

def set

@set ||= ROUTING::RouteSet.new

end

match ':controller/:action/:id.:format'

match ':controller/:action/:id'

end

end

def test_extra_keys_not_first

assert_equal "http://test.host/admin/users", controller.send(:users_url)

assert_equal '/admin/users', controller.send(:users_path)

end

def test_named_route_url_method_with_anchor

assert_equal 1, set.routes.size

assert_equal({:controller => 'users', :action => 'index', :id => '10'}, set.recognize_path('/users/index/10'))

assert_equal({:controller => 'users', :action => 'index', :id => '10'}, set.recognize_path('/users/index/10/'))

match "/people/list", :controller => "people", :action => "list"

end

assert_equal "/people/list", url

end

def test_generate_changes_controller_module

set.draw { match ':controller/:action/:id' }

current = { :controller => "bling/bloop", :action => "bap", :id => 9 }

end

def test_id_is_sticky_when_it_ought_to_be

match ':controller/:id/:action'

end

assert_equal "/people/7/destroy", url

end

match ':controller/:action/:id'

end

assert_equal "/about", url

end

set.draw { match ':controller/:action/:id' }

args = { :controller => "foo", :action => "bar", :id => "7", :x => "y" }

assert_equal ["/foo/bar/7", [:x]], set.generate_extras(args)

assert_equal [:x], set.extra_keys(args)

end

end

args = { :controller => "foo", :action => "bar", :id => "7", :x => "y" }

end

def test_generate_with_blank_path_prefix

end

args = { :controller => "foo", :action => "bar", :id => "7", :x => "y" }

end

def test_named_routes_are_never_relative_to_modules

match '/connection' => 'connection#index', :as => 'family_connection'

end

assert_equal "/connection/connection", url

assert_equal "/connection", url

end

set.draw do

match ':controller(/:action(/:id))'

end

{:controller => 'books', :action => 'index'},

{:controller => 'books', :action => 'show', :id => '10'}

)

match 'show_weblog/:parameter' => 'weblog#show'

match ':controller(/:action(/:id))'

end

{:action => 'edit', :parameter => 1},

{:controller => 'weblog', :action => 'show', :parameter => 1}

)

match '/posts(.:format)' => 'posts#index'

end

{:controller => 'posts'},

{:controller => 'posts', :action => 'index', :format => 'xml'}

)

{:controller => 'posts', :format => 'xml'},

{:controller => 'posts', :action => 'index', :format => 'xml'}

)

def test_expiry_determination_should_consider_values_with_to_param

set.draw { match 'projects/:project_id/:controller/:action' }

end

def test_named_route_in_nested_resource

assert_raise ArgumentError do

set.draw do

match 'page/:name' => 'pages#show',

end

end

end

assert_nothing_raised do

set.draw do

match 'page/:name' => 'pages#show',

end

end

assert_nothing_raised do

set.draw do

match 'page/:name' => 'pages#show',

( #Either

david #The Creator

| #Or

jamis #The Deployer

end

end

end

:constraints => {:name => /(david|jamis)/i}

end

assert_equal "/page/david", url

assert_raise ActionController::RoutingError do

end

assert_equal "/page/JAMIS", url

end

end

end

set.draw do

match 'page/:name' => 'pages#show',

:constraints => {:name => / # Desperately overcommented regexp

)/xi}

end

end

def test_routes_with_symbols

match '/hello' => 'bar#index'

end

assert_equal({:controller => "foo", :action => "index"}, set.recognize_path('/'))

assert_equal({:controller => "bar", :action => "index"}, set.recognize_path('/hello'))

match '/cars/:action/:person/:car/', :controller => 'cars'

end

assert_equal({:controller => "cars", :action => "buy", :person => "1", :car => "2"}, set.recognize_path('/cars/buy/1/2'))

end

match '/books/:action.rss', :controller => 'books'

end

assert_equal({:controller => "books", :action => "list"}, set.recognize_path('/books/list.rss'))

end

match '/books(/:action(.:format))', :controller => 'books'

end

assert_equal({:controller => "books", :action => "list", :format => "rss"}, set.recognize_path('/books/list.rss'))

assert_equal({:controller => "books", :action => "list", :format => "xml"}, set.recognize_path('/books/list.xml'))

assert_equal({:controller => "books", :action => "index"}, set.recognize_path('/books'))

end

@set = nil

set.draw { match("/:controller(/:action(/:id))") }

assert_equal({:controller => "content", :action => "index"}, set.recognize_path('/content'))

assert_equal({:controller => "content", :action => "index"}, set.recognize_path('/content/index'))

assert_equal({:controller => "content", :action => "show", :id => "1"}, set.recognize_path('/content/show/1'))

end

end

def test_default_route_should_omit_default_action

end

def test_default_route_should_include_default_action_when_id_present

end

def test_default_route_should_work_with_action_but_no_id

end

def test_default_route_should_uri_escape_pluses

expected = { :controller => 'pages', :action => 'show', :id => 'hello world' }

assert_equal expected, default_route_set.recognize_path('/pages/show/hello%20world')

expected[:id] = 'hello+world'

assert_equal expected, default_route_set.recognize_path('/pages/show/hello+world')

assert_equal expected, default_route_set.recognize_path('/pages/show/hello%2Bworld')

end

def test_build_empty_query_string

end

def test_build_query_string_with_nil_value

end

def test_simple_build_query_string

end

def test_convert_ints_build_query_string

end

def test_escape_spaces_build_query_string

end

def test_expand_array_build_query_string

end

def test_escape_spaces_build_query_string_selected_keys

end

def test_generate_with_default_params

match ':controller/:action/:id'

end

end

def test_generate_with_optional_params_recalls_last_request

last_request = set.recognize_path("/blog/2006/07/28").freeze

assert_equal({:controller => "blog", :action => "show_date", :year => "2006", :month => "07", :day => "28"}, last_request)

end

private

end

class RackMountIntegrationTests < ActiveSupport::TestCase

Model = Struct.new(:to_param)

Mapping = lambda {

end

def test_generate

end

def test_generate_extras

assert_equal Mime::MOBILE, Mime::LOOKUP['text/x-mobile']

assert_equal Mime::MOBILE, Mime::EXTENSION_LOOKUP['mobile']

assert !defined?(Mime::MOBILE), "Mime::MOBILE should not be defined"

assert !Mime::LOOKUP.has_key?('text/x-mobile'), "Mime::LOOKUP should not have key ['text/x-mobile]"

assert !Mime::EXTENSION_LOOKUP.has_key?('mobile'), "Mime::EXTENSION_LOOKUP should not have key ['mobile]"

test "parse text with trailing star at the beginning" do

accept = "text/*, text/html, application/json, multipart/form-data"

parsed = Mime::Type.parse(accept)

end

test "parse text with trailing star in the end" do

accept = "text/html, application/json, multipart/form-data, text/*"

parsed = Mime::Type.parse(accept)

end

test "parse text with trailing star" do

accept = "text/*"

parsed = Mime::Type.parse(accept)

end

test "parse application with trailing star" do

accept = "application/*"

parsed = Mime::Type.parse(accept)

end

test "parse without q" do

assert_equal Mime::GIF, Mime::SET.last

end

ensure

end

end

class TestRoutingMount < ActionDispatch::IntegrationTest

Router = ActionDispatch::Routing::RouteSet.new

Router.draw do

SprocketsApp = lambda { |env|

[200, {"Content-Type" => "text/html"}, ["#{env["SCRIPT_NAME"]} -- #{env["PATH_INFO"]}"]]

mount SprocketsApp, :at => "/sprockets"

mount SprocketsApp => "/shorthand"

scope "/its_a" do

mount SprocketsApp, :at => "/sprocket"

end

get "/shorthand/omg"

assert_equal "/shorthand -- /omg", response.body

end

end \ No newline at end of file

require 'abstract_unit'

class RequestTest < ActiveSupport::TestCase

test "remote ip" do

request = stub_request 'REMOTE_ADDR' => '1.2.3.4'

assert_equal '1.2.3.4', request.remote_ip

end

end

stub_controllers do |routes|

Routes = routes

Routes.draw do

match 'account/login', :to => redirect("/login")

match 'secure', :to => redirect("/secure/login")

constraints(lambda { |req| true }) do

match 'account/overview'

end

end

end

def test_openid

with_test_routes do

get '/openid/login'

class RenderJsonTestException < Exception

def to_json(options = nil)

end

end

%'"#{template.class} #{view.class}"'

end

def test_render_inline_with_template_handler_with_view

ActionView::Template.register_template_handler :with_view, WithViewHandler

assert_equal 'ActionView::Template ActionView::Base', @view.render(:inline => "Hello, World!", :type => :with_view)

include ActionView::Helpers::TagHelper

include ActionView::Helpers::TranslationHelper

def setup

end

translate :foo, :locale => 'en'

end

def test_returns_missing_translation_message_wrapped_into_span

end

def test_translation_returning_an_array

end

end

end

end

def test_translate_does_not_mark_plain_text_as_safe_html

end

def test_translate_marks_translations_named_html_as_safe_html

end

def test_translate_marks_translations_with_a_html_suffix_as_safe_html

end

def test_translation_returning_an_array_ignores_html_suffix

end

end