TEST_CODEOWNERS/rails
3
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Merge commit 'mainstream/master'

Browse Source
This commit is contained in:
Pratik Naik 2009-02-22 23:52:02 +01:00
commit 21b80f8144
33 changed files with 450 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
actionmailer/lib/action_mailer/base.rb
View File

@ -254,6 +254,8 @@ class Base
private_class_method :new #:nodoc:
class_inheritable_accessor :view_paths
self.view_paths = []
cattr_accessor :logger
@@smtp_settings = {
@ -594,7 +596,7 @@ def template_path
end
def initialize_template_class(assigns)
template = ActionView::Base.new(view_paths, assigns, self)
template = ActionView::Base.new(self.class.view_paths, assigns, self)
template.template_format = default_template_format
template
end

2
actionmailer/test/mail_service_test.rb
View File

@ -975,7 +975,7 @@ def test_starttls_is_not_enabled
class InheritableTemplateRootTest < Test::Unit::TestCase
def test_attr
expected = ("#{File.dirname(__FILE__)}/fixtures/path.with.dots").sub(/\.\//, '')
expected = "#{File.dirname(__FILE__)}/fixtures/path.with.dots"
assert_equal expected, FunkyPathMailer.template_root.to_s
sub = Class.new(FunkyPathMailer)

1
actionpack/lib/action_controller.rb
View File

@ -59,6 +59,7 @@ def self.load_all!
autoload :ParamsParser, 'action_controller/params_parser'
autoload :PolymorphicRoutes, 'action_controller/polymorphic_routes'
autoload :RecordIdentifier, 'action_controller/record_identifier'
autoload :Reloader, 'action_controller/reloader'
autoload :Request, 'action_controller/request'
autoload :RequestForgeryProtection, 'action_controller/request_forgery_protection'
autoload :Rescue, 'action_controller/rescue'

41
actionpack/lib/action_controller/dispatcher.rb
View File

@ -5,8 +5,9 @@ class Dispatcher
class << self
def define_dispatcher_callbacks(cache_classes)
unless cache_classes
# Development mode callbacks
before_dispatch :reload_application
unless self.middleware.include?(Reloader)
self.middleware.insert_after(Failsafe, Reloader)
end
ActionView::Helpers::AssetTagHelper.cache_asset_timestamps = false
end
@ -41,6 +42,30 @@ def to_prepare(identifier = nil, &block)
callback = ActiveSupport::Callbacks::Callback.new(:prepare_dispatch, block, :identifier => identifier)
@prepare_dispatch_callbacks.replace_or_append!(callback)
end
def run_prepare_callbacks
if defined?(Rails) && Rails.logger
logger = Rails.logger
else
logger = Logger.new($stderr)
end
new(logger).send :run_callbacks, :prepare_dispatch
end
def reload_application
# Run prepare callbacks before every request in development mode
run_prepare_callbacks
Routing::Routes.reload
end
def cleanup_application
# Cleanup the application before processing the current request.
ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
ActiveSupport::Dependencies.clear
ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
end
end
cattr_accessor :middleware
@ -87,18 +112,6 @@ def _call(env)
dispatch
end
def reload_application
# Cleanup the application before processing the current request.
ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
ActiveSupport::Dependencies.clear
ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
# Run prepare callbacks before every request in development mode
run_callbacks :prepare_dispatch
Routing::Routes.reload
end
def flush_logger
Base.logger.flush
end

58
actionpack/lib/action_controller/layout.rb
View File

@ -172,23 +172,10 @@ def layout_conditions #:nodoc:
@layout_conditions ||= read_inheritable_attribute(:layout_conditions)
end
def default_layout(format) #:nodoc:
layout = read_inheritable_attribute(:layout) unless format == :js
return layout unless read_inheritable_attribute(:auto_layout)
find_layout(layout, format)
end
def layout_list #:nodoc:
Array(view_paths).sum([]) { |path| Dir["#{path.to_str}/layouts/**/*"] }
end
def find_layout(layout, *formats) #:nodoc:
return layout if layout.respond_to?(:render)
view_paths.find_template(layout.to_s =~ /layouts\// ? layout : "layouts/#{layout}", *formats)
rescue ActionView::MissingTemplate
nil
end
private
def inherited_with_layout(child)
inherited_without_layout(child)
@ -212,35 +199,29 @@ def normalize_conditions(conditions)
# object). If the layout was defined without a directory, layouts is assumed. So <tt>layout "weblog/standard"</tt> will return
# weblog/standard, but <tt>layout "standard"</tt> will return layouts/standard.
def active_layout(passed_layout = nil)
layout = passed_layout || self.class.default_layout(default_template_format)
layout = passed_layout || default_layout
return layout if layout.respond_to?(:render)
active_layout = case layout
when Symbol then __send__(layout)
when Proc then layout.call(self)
else layout
end
if active_layout
if layout = self.class.find_layout(active_layout, @template.template_format)
layout
else
raise ActionView::MissingTemplate.new(self.class.view_paths, active_layout)
end
end
find_layout(active_layout, @template.template_format) if active_layout
end
private
def candidate_for_layout?(options)
template = options[:template] || default_template(options[:action])
if options.values_at(:text, :xml, :json, :file, :inline, :partial, :nothing, :update).compact.empty?
begin
!self.view_paths.find_template(template, default_template_format).exempt_from_layout?
rescue ActionView::MissingTemplate
true
end
end
def default_layout #:nodoc:
layout = self.class.read_inheritable_attribute(:layout) unless default_template_format == :js
return layout unless self.class.read_inheritable_attribute(:auto_layout)
find_layout(layout, default_template_format)
rescue ActionView::MissingTemplate
false
nil
end
def find_layout(layout, *formats) #:nodoc:
view_paths.find_template(layout.to_s =~ /layouts\// ? layout : "layouts/#{layout}", *formats)
end
def pick_layout(options)
@ -273,6 +254,19 @@ def action_has_layout?
end
end
def candidate_for_layout?(options)
template = options[:template] || default_template(options[:action])
if options.values_at(:text, :xml, :json, :file, :inline, :partial, :nothing, :update).compact.empty?
begin
!self.view_paths.find_template(template, default_template_format).exempt_from_layout?
rescue ActionView::MissingTemplate
true
end
end
rescue ActionView::MissingTemplate
false
end
def default_template_format
response.template.template_format
end

16
actionpack/lib/action_controller/middleware_stack.rb
View File

@ -27,7 +27,9 @@ def initialize(klass, *args, &block)
end
def klass
if @klass.is_a?(Class)
if @klass.respond_to?(:call)
@klass.call
elsif @klass.is_a?(Class)
@klass
else
@klass.to_s.constantize
@ -37,6 +39,8 @@ def klass
end
def active?
return false unless klass
if @conditional.respond_to?(:call)
@conditional.call
else
@ -63,11 +67,17 @@ def inspect
def build(app)
if block
klass.new(app, *args, &block)
klass.new(app, *build_args, &block)
else
klass.new(app, *args)
klass.new(app, *build_args)
end
end
private
def build_args
Array(args).map { |arg| arg.respond_to?(:call) ? arg.call : arg }
end
end
def initialize(*args, &block)

13
actionpack/lib/action_controller/middlewares.rb
View File

@ -4,17 +4,8 @@
use "ActionController::Failsafe"
["ActionController::Session::CookieStore",
"ActionController::Session::MemCacheStore",
"ActiveRecord::SessionStore"].each do |store|
use(store, ActionController::Base.session_options,
:if => lambda {
if session_store = ActionController::Base.session_store
session_store.name == store
end
}
)
end
use lambda { ActionController::Base.session_store },
lambda { ActionController::Base.session_options }
use "ActionController::RewindableInput"
use "ActionController::ParamsParser"

14
actionpack/lib/action_controller/reloader.rb Normal file
View File

@ -0,0 +1,14 @@
module ActionController
class Reloader
def initialize(app)
@app = app
end
def call(env)
Dispatcher.reload_application
@app.call(env)
ensure
Dispatcher.cleanup_application
end
end
end

32
actionpack/lib/action_controller/routing/segments.rb
View File

@ -191,23 +191,19 @@ def value_regexp
end
def regexp_chunk
if regexp
if regexp_has_modifiers?
"(#{regexp.to_s})"
else
"(#{regexp.source})"
end
else
"([^#{Routing::SEPARATORS.join}]+)"
end
regexp ? regexp_string : default_regexp_chunk
end
def regexp_string
regexp_has_modifiers? ? "(#{regexp.to_s})" : "(#{regexp.source})"
end
def default_regexp_chunk
"([^#{Routing::SEPARATORS.join}]+)"
end
def number_of_captures
if regexp
regexp.number_of_captures + 1
else
1
end
regexp ? regexp.number_of_captures + 1 : 1
end
def build_pattern(pattern)
@ -244,10 +240,6 @@ def regexp_chunk
"(?i-:(#{(regexp || Regexp.union(*possible_names)).source}))"
end
def number_of_captures
1
end
# Don't URI.escape the controller name since it may contain slashes.
def interpolation_chunk(value_code = local_name)
"\#{#{value_code}.to_s}"
@ -289,8 +281,8 @@ def match_extraction(next_capture)
"params[:#{key}] = PathSegment::Result.new_escaped((match[#{next_capture}]#{" || " + default.inspect if default}).split('/'))#{" if match[" + next_capture + "]" if !default}"
end
def regexp_chunk
regexp || "(.*)"
def default_regexp_chunk
"(.*)"
end
def number_of_captures

4
actionpack/lib/action_view/base.rb
View File

@ -254,8 +254,8 @@ def render(options = {}, local_assigns = {}, &block) #:nodoc:
if options[:layout]
_render_with_layout(options, local_assigns, &block)
elsif options[:file]
tempalte = self.view_paths.find_template(options[:file], template_format)
tempalte.render_template(self, options[:locals])
template = self.view_paths.find_template(options[:file], template_format)
template.render_template(self, options[:locals])
elsif options[:partial]
render_partial(options)
elsif options[:inline]

77
actionpack/lib/action_view/reloadable_template.rb
View File

@ -27,49 +27,50 @@ def [](path)
end
else
load_all_templates_from_dir(templates_dir_from_path(path))
@paths[path]
# don't ever hand out a template without running a stale check
(new_template = @paths[path]) && new_template.reset_cache_if_stale!
end
end
def register_template_from_file(template_file_path)
if !@paths[template_relative_path = template_file_path.split("#{@path}/").last] && File.file?(template_file_path)
register_template(ReloadableTemplate.new(template_relative_path, self))
private
def register_template_from_file(template_full_file_path)
if !@paths[relative_path = relative_path_for_template_file(template_full_file_path)] && File.file?(template_full_file_path)
register_template(ReloadableTemplate.new(relative_path, self))
end
end
end
def register_template(template)
template.accessible_paths.each do |path|
@paths[path] = template
def register_template(template)
template.accessible_paths.each do |path|
@paths[path] = template
end
end
end
# remove (probably deleted) template from cache
def unregister_template(template)
template.accessible_paths.each do |template_path|
@paths.delete(template_path) if @paths[template_path] == template
# remove (probably deleted) template from cache
def unregister_template(template)
template.accessible_paths.each do |template_path|
@paths.delete(template_path) if @paths[template_path] == template
end
# fill in any newly created gaps
@paths.values.uniq.each do |template|
template.accessible_paths.each {|path| @paths[path] ||= template}
end
end
# fill in any newly created gaps
@paths.values.uniq.each do |template|
template.accessible_paths.each {|path| @paths[path] ||= template}
# load all templates from the directory of the requested template
def load_all_templates_from_dir(dir)
# hit disk only once per template-dir/request
@disk_cache[dir] ||= template_files_from_dir(dir).each {|template_file| register_template_from_file(template_file)}
end
end
# load all templates from the directory of the requested template
def load_all_templates_from_dir(dir)
# hit disk only once per template-dir/request
@disk_cache[dir] ||= template_files_from_dir(dir).each {|template_file| register_template_from_file(template_file)}
end
def templates_dir_from_path(path)
dirname = File.dirname(path)
File.join(@path, dirname == '.' ? '' : dirname)
end
# get all the template filenames from the dir
def template_files_from_dir(dir)
Dir.glob(File.join(dir, '*'))
end
def templates_dir_from_path(path)
dirname = File.dirname(path)
File.join(@path, dirname == '.' ? '' : dirname)
end
# get all the template filenames from the dir
def template_files_from_dir(dir)
Dir.glob(File.join(dir, '*'))
end
end
module Unfreezable
@ -78,7 +79,6 @@ def freeze; self; end
def initialize(*args)
super
@compiled_methods = []
# we don't ever want to get frozen
extend Unfreezable
@ -106,14 +106,11 @@ def reset_cache_if_stale!
self
end
# remove any compiled methods that look like they might belong to me
def undef_my_compiled_methods!
@compiled_methods.each {|comp_method| ActionView::Base::CompiledTemplates.send(:remove_method, comp_method)}
@compiled_methods.clear
end
def compile!(render_symbol, local_assigns)
super
@compiled_methods << render_symbol
ActionView::Base::CompiledTemplates.public_instance_methods.grep(/#{Regexp.escape(method_name_without_locals)}(?:_locals_)?/).each do |m|
ActionView::Base::CompiledTemplates.send(:remove_method, m)
end
end
end

24
actionpack/lib/action_view/template.rb
View File

@ -6,12 +6,7 @@ class Path
def initialize(path)
raise ArgumentError, "path already is a Path class" if path.is_a?(Path)
@path = expand_path(path).freeze
end
def expand_path(path)
# collapse any directory dots in path ('.' or '..')
path.starts_with?('/') ? File.expand_path(path) : File.expand_path(path, '/').from(1)
@path = (path.ends_with?(File::SEPARATOR) ? path.to(-2) : path).freeze
end
def to_s
@ -45,22 +40,23 @@ def eql?(path)
# will never match +hello/index.html.erb+.
def [](path)
end
def load!
end
def self.new_and_loaded(path)
returning new(path) do |path|
path.load!
end
end
private
def relative_path_for_template_file(full_file_path)
full_file_path.split("#{@path}/").last
end
end
class EagerPath < Path
def initialize(path)
super
end
def load!
return if @loaded
@ -79,7 +75,7 @@ def [](path)
load! unless @loaded
@paths[path]
end
private
def templates_in_path
(Dir.glob("#{@path}/**/*/**") | Dir.glob("#{@path}/**")).each do |file|
@ -88,7 +84,7 @@ def templates_in_path
end
def create_template(file)
Template.new(file.split("#{self}/").last, self)
Template.new(relative_path_for_template_file(file), self)
end
end

4
actionpack/test/activerecord/render_partial_with_record_identification_test.rb
View File

@ -53,7 +53,7 @@ class RenderPartialWithRecordIdentificationTest < ActiveRecordTestCase
def test_rendering_partial_with_has_many_and_belongs_to_association
get :render_with_has_many_and_belongs_to_association
assert_template 'projects/_project'
assert_equal 'Active RecordActive Controller', @response.body
assert_equal assigns(:developer).projects.map(&:name).join, @response.body
end
def test_rendering_partial_with_has_many_association
@ -82,7 +82,7 @@ def test_render_with_record_collection
def test_render_with_record_collection_and_spacer_template
get :render_with_record_collection_and_spacer_template
assert_equal 'Active Recordonly partialActive Controller', @response.body
assert_equal assigns(:developer).projects.map(&:name).join('only partial'), @response.body
end
def test_rendering_partial_with_has_one_association

13
actionpack/test/controller/dispatcher_test.rb
View File

@ -6,14 +6,17 @@ class DispatcherTest < Test::Unit::TestCase
def setup
ENV['REQUEST_METHOD'] = 'GET'
Dispatcher.middleware = ActionController::MiddlewareStack.new do |middleware|
middlewares = File.expand_path(File.join(File.dirname(__FILE__), "../../lib/action_controller/middlewares.rb"))
middleware.instance_eval(File.read(middlewares))
end
# Clear callbacks as they are redefined by Dispatcher#define_dispatcher_callbacks
Dispatcher.instance_variable_set("@prepare_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
Dispatcher.instance_variable_set("@before_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
Dispatcher.instance_variable_set("@after_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
Dispatcher.stubs(:require_dependency)
@dispatcher = Dispatcher.new
end
def teardown
@ -65,7 +68,7 @@ def test_prepare_callbacks
assert_nil a || b || c
# Run callbacks
@dispatcher.send :run_callbacks, :prepare_dispatch
Dispatcher.run_prepare_callbacks
assert_equal 1, a
assert_equal 2, b
@ -82,7 +85,7 @@ def test_to_prepare_with_identifier_replaces
Dispatcher.to_prepare(:unique_id) { |*args| a = b = 1 }
Dispatcher.to_prepare(:unique_id) { |*args| a = 2 }
@dispatcher.send :run_callbacks, :prepare_dispatch
Dispatcher.run_prepare_callbacks
assert_equal 2, a
assert_equal nil, b
end
@ -91,7 +94,7 @@ def test_to_prepare_with_identifier_replaces
def dispatch(cache_classes = true)
ActionController::Routing::RouteSet.any_instance.stubs(:call).returns([200, {}, 'response'])
Dispatcher.define_dispatcher_callbacks(cache_classes)
@dispatcher.call({})
Dispatcher.new.call({})
end
def assert_subclasses(howmany, klass, message = klass.subclasses.inspect)

14
actionpack/test/controller/layout_test.rb
View File

@ -83,6 +83,13 @@ class HasOwnLayoutController < LayoutTest
layout 'item'
end
class PrependsViewPathController < LayoutTest
def hello
prepend_view_path File.dirname(__FILE__) + '/../fixtures/layout_tests/alt/'
render :layout => 'alt'
end
end
class SetsLayoutInRenderController < LayoutTest
def hello
render :layout => 'third_party_template_library'
@ -130,6 +137,12 @@ def test_exempt_from_layout_honored_by_render_template
ensure
ActionController::Base.exempt_from_layout.delete(/\.rhtml$/)
end
def test_layout_is_picked_from_the_controller_instances_view_path
@controller = PrependsViewPathController.new
get :hello
assert_equal 'layouts/alt', @response.layout
end
end
class RenderWithTemplateOptionController < LayoutTest
@ -178,3 +191,4 @@ def test_symlinked_layout_is_rendered
end
end
end

14
actionpack/test/controller/middleware_stack_test.rb
View File

@ -73,4 +73,18 @@ def setup
end
end
end
test "lazy evaluates middleware class" do
assert_difference "@stack.size" do
@stack.use lambda { BazMiddleware }
end
assert_equal BazMiddleware, @stack.last.klass
end
test "lazy evaluates middleware arguments" do
assert_difference "@stack.size" do
@stack.use BazMiddleware, lambda { :foo }
end
assert_equal [:foo], @stack.last.send(:build_args)
end
end

34
actionpack/test/controller/routing_test.rb
View File

@ -340,6 +340,30 @@ def test_regexp_should_only_match_possible_controllers
end
end
class PathSegmentTest < Test::Unit::TestCase
def segment(options = {})
unless @segment
@segment = ROUTING::PathSegment.new(:path, options)
end
@segment
end
def test_regexp_chunk_should_return_string
segment = segment(:regexp => /[a-z]+/)
assert_kind_of String, segment.regexp_chunk
end
def test_regexp_chunk_should_be_wrapped_with_parenthesis
segment = segment(:regexp => /[a-z]+/)
assert_equal "([a-z]+)", segment.regexp_chunk
end
def test_regexp_chunk_should_respect_options
segment = segment(:regexp => /[a-z]+/i)
assert_equal "((?i-mx:[a-z]+))", segment.regexp_chunk
end
end
class RouteBuilderTest < Test::Unit::TestCase
def builder
@builder ||= ROUTING::RouteBuilder.new
@ -852,6 +876,15 @@ def test_route_with_regexp_for_controller
assert_equal '/content/foo', rs.generate(:controller => "content", :action => "foo")
end
def test_route_with_regexp_and_captures_for_controller
rs.draw do |map|
map.connect ':controller/:action/:id', :controller => /admin\/(accounts|users)/
end
assert_equal({:controller => "admin/accounts", :action => "index"}, rs.recognize_path("/admin/accounts"))
assert_equal({:controller => "admin/users", :action => "index"}, rs.recognize_path("/admin/users"))
assert_raises(ActionController::RoutingError) { rs.recognize_path("/admin/products") }
end
def test_route_with_regexp_and_dot
rs.draw do |map|
map.connect ':controller/:action/:file',
@ -1134,6 +1167,7 @@ def test_route_with_text_default
assert_equal({:controller => "content", :action => 'show_page', :id => 'foo'}, rs.recognize_path("/page/foo"))
token = "\321\202\320\265\320\272\321\201\321\202" # 'text' in russian
token.force_encoding("UTF-8") if token.respond_to?(:force_encoding)
escaped_token = CGI::escape(token)
assert_equal '/page/' + escaped_token, rs.generate(:controller => 'content', :action => 'show_page', :id => token)

2
actionpack/test/controller/session/cookie_store_test.rb
View File

@ -23,7 +23,7 @@ def persistent_session_id
def set_session_value
session[:foo] = "bar"
render :text => Verifier.generate(session.to_hash)
render :text => Rack::Utils.escape(Verifier.generate(session.to_hash))
end
def get_session_value

26
actionpack/test/controller/view_paths_test.rb
View File

@ -42,34 +42,30 @@ def teardown
ActiveSupport::Deprecation.behavior = @old_behavior
end
def assert_view_path_strings_are_equal(expected, actual)
assert_equal(expected.map {|path| path.sub(/\.\//, '')}, actual)
end
def test_template_load_path_was_set_correctly
assert_view_path_strings_are_equal [FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
assert_equal [FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
end
def test_controller_appends_view_path_correctly
@controller.append_view_path 'foo'
assert_view_path_strings_are_equal [FIXTURE_LOAD_PATH, 'foo'], @controller.view_paths.map(&:to_s)
assert_equal [FIXTURE_LOAD_PATH, 'foo'], @controller.view_paths.map(&:to_s)
@controller.append_view_path(%w(bar baz))
assert_view_path_strings_are_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz'], @controller.view_paths.map(&:to_s)
assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz'], @controller.view_paths.map(&:to_s)
@controller.append_view_path(FIXTURE_LOAD_PATH)
assert_view_path_strings_are_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
end
def test_controller_prepends_view_path_correctly
@controller.prepend_view_path 'baz'
assert_view_path_strings_are_equal ['baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
assert_equal ['baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
@controller.prepend_view_path(%w(foo bar))
assert_view_path_strings_are_equal ['foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
assert_equal ['foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
@controller.prepend_view_path(FIXTURE_LOAD_PATH)
assert_view_path_strings_are_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
end
def test_template_appends_view_path_correctly
@ -77,10 +73,10 @@ def test_template_appends_view_path_correctly
class_view_paths = TestController.view_paths
@controller.append_view_path 'foo'
assert_view_path_strings_are_equal [FIXTURE_LOAD_PATH, 'foo'], @controller.view_paths.map(&:to_s)
assert_equal [FIXTURE_LOAD_PATH, 'foo'], @controller.view_paths.map(&:to_s)
@controller.append_view_path(%w(bar baz))
assert_view_path_strings_are_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz'], @controller.view_paths.map(&:to_s)
assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz'], @controller.view_paths.map(&:to_s)
assert_equal class_view_paths, TestController.view_paths
end
@ -89,10 +85,10 @@ def test_template_prepends_view_path_correctly
class_view_paths = TestController.view_paths
@controller.prepend_view_path 'baz'
assert_view_path_strings_are_equal ['baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
assert_equal ['baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
@controller.prepend_view_path(%w(foo bar))
assert_view_path_strings_are_equal ['foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
assert_equal ['foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
assert_equal class_view_paths, TestController.view_paths
end

0
actionpack/test/fixtures/layout_tests/alt/layouts/alt.rhtml vendored Normal file
View File

128
actionpack/test/template/compiled_templates_test.rb
View File

@ -5,18 +5,6 @@ class CompiledTemplatesTest < Test::Unit::TestCase
def setup
@compiled_templates = ActionView::Base::CompiledTemplates
# first, if we are running the whole test suite with ReloadableTemplates
# try to undef all the methods through ReloadableTemplate's interfaces
unless ActionView::Base.cache_template_loading?
ActionController::Base.view_paths.each do |view_path|
view_path.paths.values.uniq!.each do |reloadable_template|
reloadable_template.undef_my_compiled_methods!
end
end
end
# just purge anything that's left
@compiled_templates.instance_methods.each do |m|
@compiled_templates.send(:remove_method, m) if m =~ /^_run_/
end
@ -65,38 +53,124 @@ def test_template_changes_are_reflected_without_cached_template_loading
with_reloading(true) do
assert_equal "Hello world!", render(:file => "test/hello_world.erb")
modify_template "test/hello_world.erb", "Goodbye world!" do
reset_mtime_of('test/hello_world.erb')
assert_equal "Goodbye world!", render(:file => "test/hello_world.erb")
end
reset_mtime_of('test/hello_world.erb')
assert_equal "Hello world!", render(:file => "test/hello_world.erb")
end
end
end
def test_template_becomes_missing_if_deleted_without_cached_template_loading
with_reloading(true) do
assert_equal 'Hello world!', render(:file => 'test/hello_world.erb')
delete_template 'test/hello_world.erb' do
assert_raise(ActionView::MissingTemplate) { render(:file => 'test/hello_world.erb') }
end
assert_equal 'Hello world!', render(:file => 'test/hello_world.erb')
end
end
def test_swapping_template_handler_is_working_without_cached_template_loading
with_reloading(true) do
assert_equal 'Hello world!', render(:file => 'test/hello_world')
delete_template 'test/hello_world.erb' do
rename_template 'test/hello_world_from_rxml.builder', 'test/hello_world.builder' do
assert_equal "<html>\n <p>Hello</p>\n</html>\n", render(:file => 'test/hello_world')
end
end
assert_equal 'Hello world!', render(:file => 'test/hello_world')
end
end
def test_adding_localized_template_will_take_precedence_without_cached_template_loading
with_reloading(true) do
assert_equal 'Hello world!', render(:file => 'test/hello_world')
rename_template 'test/hello_world.da.html.erb', 'test/hello_world.en.html.erb' do
assert_equal 'Hey verden', render(:file => 'test/hello_world')
end
end
end
def test_deleting_localized_template_will_fall_back_to_non_localized_template_without_cached_template_loading
with_reloading(true) do
rename_template 'test/hello_world.da.html.erb', 'test/hello_world.en.html.erb' do
assert_equal 'Hey verden', render(:file => 'test/hello_world')
delete_template 'test/hello_world.en.html.erb' do
assert_equal 'Hello world!', render(:file => 'test/hello_world')
end
assert_equal 'Hey verden', render(:file => 'test/hello_world')
end
end
end
def test_parallel_reloadable_view_paths_are_working
with_reloading(true) do
view_paths_copy = new_reloadable_view_paths
assert_equal 'Hello world!', render(:file => 'test/hello_world')
with_view_paths(view_paths_copy, new_reloadable_view_paths) do
assert_equal 'Hello world!', render(:file => 'test/hello_world')
end
modify_template 'test/hello_world.erb', 'Goodbye world!' do
assert_equal 'Goodbye world!', render(:file => 'test/hello_world')
modify_template 'test/hello_world.erb', 'So long, world!' do
with_view_paths(view_paths_copy, new_reloadable_view_paths) do
assert_equal 'So long, world!', render(:file => 'test/hello_world')
end
assert_equal 'So long, world!', render(:file => 'test/hello_world')
end
end
end
end
private
def render(*args)
view_paths = ActionController::Base.view_paths
view_paths = @explicit_view_paths || ActionController::Base.view_paths
ActionView::Base.new(view_paths, {}).render(*args)
end
def reset_mtime_of(template_name)
unless ActionView::Base.cache_template_loading?
ActionController::Base.view_paths.find_template(template_name).previously_last_modified = 10.seconds.ago
def with_view_paths(*args)
args.each do |view_paths|
begin
@explicit_view_paths = view_paths
yield
ensure
@explicit_view_paths = nil
end
end
end
def modify_template(template, content)
filename = "#{FIXTURE_LOAD_PATH}/#{template}"
def reset_mtime_of(template_name, view_paths_to_use)
view_paths_to_use.find_template(template_name).previously_last_modified = 10.seconds.ago unless ActionView::Base.cache_template_loading?
end
def modify_template(template, content, view_paths_to_use = ActionController::Base.view_paths)
filename = filename_for(template)
old_content = File.read(filename)
begin
File.open(filename, "wb+") { |f| f.write(content) }
reset_mtime_of(template, view_paths_to_use)
yield
ensure
File.open(filename, "wb+") { |f| f.write(old_content) }
reset_mtime_of(template, view_paths_to_use)
end
end
def filename_for(template)
File.join(FIXTURE_LOAD_PATH, template)
end
def rename_template(old_name, new_name)
File.rename(filename_for(old_name), filename_for(new_name))
yield
ensure
File.rename(filename_for(new_name), filename_for(old_name))
end
def delete_template(template, &block)
rename_template(template, File.join(File.dirname(template), "__#{File.basename(template)}"), &block)
end
def with_caching(perform_caching)
old_perform_caching = ActionController::Base.perform_caching
begin
@ -107,19 +181,23 @@ def with_caching(perform_caching)
end
end
def with_reloading(reload_templates)
old_view_paths, old_cache_templates = ActionController::Base.view_paths, ActionView::Base.cache_template_loading
def with_reloading(reload_templates, view_paths_owner = ActionController::Base)
old_view_paths, old_cache_templates = view_paths_owner.view_paths, ActionView::Base.cache_template_loading
begin
ActionView::Base.cache_template_loading = !reload_templates
ActionController::Base.view_paths = view_paths_for(reload_templates)
view_paths_owner.view_paths = view_paths_for(reload_templates)
yield
ensure
ActionController::Base.view_paths, ActionView::Base.cache_template_loading = old_view_paths, old_cache_templates
view_paths_owner.view_paths, ActionView::Base.cache_template_loading = old_view_paths, old_cache_templates
end
end
def new_reloadable_view_paths
ActionView::PathSet.new(CACHED_VIEW_PATHS.map(&:to_s))
end
def view_paths_for(reload_templates)
# reloadable paths are cheap to create
reload_templates ? ActionView::PathSet.new(CACHED_VIEW_PATHS.map(&:to_s)) : CACHED_VIEW_PATHS
reload_templates ? new_reloadable_view_paths : CACHED_VIEW_PATHS
end
end

2
activesupport/CHANGELOG
View File

@ -1,5 +1,7 @@
*Edge*
* Ruby 1.9.1p0 fix: URI.unescape can decode multibyte chars. #2033 [MOROHASHI Kyosuke]
* Time#to_s(:rfc822) uses #formatted_offset instead of unreliable and non-standard %z directive #1899 [Zachary Zolton]
* Make TimeWithZone#to_formatted_s an alias to TimeWithZone#to_s #1796 [Levin Alexander]

24
activesupport/lib/active_support/core_ext/array/conversions.rb
View File

@ -6,14 +6,28 @@ module Conversions
# * <tt>:words_connector</tt> - The sign or word used to join the elements in arrays with two or more elements (default: ", ")
# * <tt>:two_words_connector</tt> - The sign or word used to join the elements in arrays with two elements (default: " and ")
# * <tt>:last_word_connector</tt> - The sign or word used to join the last element in arrays with three or more elements (default: ", and ")
def to_sentence(options = {})
options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
def to_sentence(options = {})
default_words_connector = I18n.translate(:'support.array.words_connector', :locale => options[:locale])
default_two_words_connector = I18n.translate(:'support.array.two_words_connector', :locale => options[:locale])
default_last_word_connector = I18n.translate(:'support.array.last_word_connector', :locale => options[:locale])
options.reverse_merge! :words_connector => default_words_connector, :two_words_connector => default_two_words_connector, :last_word_connector => default_last_word_connector
default_last_word_connector = I18n.translate(:'support.array.last_word_connector', :locale => options[:locale])
# Try to emulate to_senteces previous to 2.3
if options.has_key?(:connector) || options.has_key?(:skip_last_comma)
::ActiveSupport::Deprecation.warn(":connector has been deprecated. Use :words_connector instead", caller) if options.has_key? :connector
::ActiveSupport::Deprecation.warn(":skip_last_comma has been deprecated. Use :last_word_connector instead", caller) if options.has_key? :skip_last_comma
skip_last_comma = options.delete :skip_last_comma
if connector = options.delete(:connector)
options[:last_word_connector] ||= skip_last_comma ? connector : ", #{connector}"
else
options[:last_word_connector] ||= skip_last_comma ? default_two_words_connector : default_last_word_connector
end
end
options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
options.reverse_merge! :words_connector => default_words_connector, :two_words_connector => default_two_words_connector, :last_word_connector => default_last_word_connector
case length
when 0
""

2
activesupport/lib/active_support/core_ext/file/atomic.rb
View File

@ -27,7 +27,7 @@ def atomic_write(file_name, temp_dir = Dir.tmpdir)
old_stat = stat(file_name)
rescue Errno::ENOENT
# No old permissions, write a temp file to determine the defaults
check_name = ".permissions_check.#{Thread.current.object_id}.#{Process.pid}.#{rand(1000000)}"
check_name = join(dirname(file_name), ".permissions_check.#{Thread.current.object_id}.#{Process.pid}.#{rand(1000000)}")
open(check_name, "w") { }
old_stat = stat(check_name)
unlink(check_name)

16
activesupport/lib/active_support/core_ext/uri.rb Normal file
View File

@ -0,0 +1,16 @@
if RUBY_VERSION >= '1.9'
require 'uri'
str = "\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E" # Ni-ho-nn-go in UTF-8, means Japanese.
str.force_encoding(Encoding::UTF_8) if str.respond_to?(:force_encoding)
unless str == URI.unescape(URI.escape(str))
URI::Parser.class_eval do
remove_method :unescape
def unescape(str, escaped = @regexp[:ESCAPED])
enc = (str.encoding == Encoding::US_ASCII) ? Encoding::UTF_8 : str.encoding
str.gsub(escaped) { [$&[1, 2].hex].pack('C') }.force_encoding(enc)
end
end
end
end

18
activesupport/test/core_ext/array_ext_test.rb
View File

@ -48,6 +48,8 @@ def test_to_param_array
end
class ArrayExtToSentenceTests < Test::Unit::TestCase
include ActiveSupport::Testing::Deprecation
def test_plain_array_to_sentence
assert_equal "", [].to_sentence
assert_equal "one", ['one'].to_sentence
@ -56,12 +58,28 @@ def test_plain_array_to_sentence
end
def test_to_sentence_with_words_connector
assert_deprecated(":connector has been deprecated. Use :words_connector instead") do
assert_equal "one, two, three", ['one', 'two', 'three'].to_sentence(:connector => '')
end
assert_deprecated(":connector has been deprecated. Use :words_connector instead") do
assert_equal "one, two, and three", ['one', 'two', 'three'].to_sentence(:connector => 'and ')
end
assert_equal "one two, and three", ['one', 'two', 'three'].to_sentence(:words_connector => ' ')
assert_equal "one & two, and three", ['one', 'two', 'three'].to_sentence(:words_connector => ' & ')
assert_equal "onetwo, and three", ['one', 'two', 'three'].to_sentence(:words_connector => nil)
end
def test_to_sentence_with_last_word_connector
assert_deprecated(":skip_last_comma has been deprecated. Use :last_word_connector instead") do
assert_equal "one, two and three", ['one', 'two', 'three'].to_sentence(:skip_last_comma => true)
end
assert_deprecated(":skip_last_comma has been deprecated. Use :last_word_connector instead") do
assert_equal "one, two, and three", ['one', 'two', 'three'].to_sentence(:skip_last_comma => false)
end
assert_equal "one, two, and also three", ['one', 'two', 'three'].to_sentence(:last_word_connector => ', and also ')
assert_equal "one, twothree", ['one', 'two', 'three'].to_sentence(:last_word_connector => nil)
assert_equal "one, two three", ['one', 'two', 'three'].to_sentence(:last_word_connector => ' ')

12
activesupport/test/core_ext/uri_ext_test.rb Normal file
View File

@ -0,0 +1,12 @@
require 'abstract_unit'
require 'uri'
class URIExtTest < Test::Unit::TestCase
def test_uri_decode_handle_multibyte
str = "\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E" # Ni-ho-nn-go in UTF-8, means Japanese.
str.force_encoding(Encoding::UTF_8) if str.respond_to?(:force_encoding)
assert_equal str, URI.unescape(URI.escape(str))
assert_equal str, URI.decode(URI.escape(str))
end
end

3
railties/lib/console_app.rb
View File

@ -24,7 +24,6 @@ def new_session
#reloads the environment
def reload!
puts "Reloading..."
dispatcher = ActionController::Dispatcher.new($stdout)
dispatcher.reload_application
Dispatcher.reload_application
true
end

14
railties/lib/initializer.rb
View File

@ -167,6 +167,10 @@ def process
load_gems
check_gem_dependencies
# bail out if gems are missing - note that check_gem_dependencies will have
# already called abort() unless $gems_rake_task is set
return unless gems_dependencies_loaded
load_application_initializers
# the framework is now fully initialized
@ -302,7 +306,7 @@ def check_gem_dependencies
if unloaded_gems.size > 0
@gems_dependencies_loaded = false
# don't print if the gems rake tasks are being run
unless $rails_rake_task
unless $gems_rake_task
abort <<-end_error
Missing these required gems:
#{unloaded_gems.map { |gem| "#{gem.name} #{gem.requirement}" } * "\n "}
@ -479,8 +483,8 @@ def initialize_framework_logging
def initialize_framework_views
if configuration.frameworks.include?(:action_view)
view_path = ActionView::PathSet.type_cast(configuration.view_path)
ActionMailer::Base.template_root ||= view_path if configuration.frameworks.include?(:action_mailer)
ActionController::Base.view_paths = view_path if configuration.frameworks.include?(:action_controller) && ActionController::Base.view_paths.empty?
ActionMailer::Base.template_root = view_path if configuration.frameworks.include?(:action_mailer) && ActionMailer::Base.view_paths.blank?
ActionController::Base.view_paths = view_path if configuration.frameworks.include?(:action_controller) && ActionController::Base.view_paths.blank?
end
end
@ -492,7 +496,7 @@ def initialize_routing
ActionController::Routing.controller_paths += configuration.controller_paths
ActionController::Routing::Routes.add_configuration_file(configuration.routes_configuration_file)
ActionController::Routing::Routes.reload
ActionController::Routing::Routes.reload!
end
# Sets the dependency loading mechanism based on the value of
@ -583,7 +587,7 @@ def prepare_dispatcher
return unless configuration.frameworks.include?(:action_controller)
require 'dispatcher' unless defined?(::Dispatcher)
Dispatcher.define_dispatcher_callbacks(configuration.cache_classes)
Dispatcher.new(Rails.logger).send :run_callbacks, :prepare_dispatch
Dispatcher.run_prepare_callbacks
end
def disable_dependency_loading

50
railties/lib/rails/plugin/loader.rb
View File

@ -16,7 +16,7 @@ class Loader
def initialize(initializer)
@initializer = initializer
end
# Returns the plugins to be loaded, in the order they should be loaded.
def plugins
@plugins ||= all_plugins.select { |plugin| should_load?(plugin) }.sort { |p1, p2| order_plugins(p1, p2) }
@ -32,9 +32,9 @@ def all_plugins
@all_plugins ||= locate_plugins
@all_plugins
end
def load_plugins
plugins.each do |plugin|
plugins.each do |plugin|
plugin.load(initializer)
register_plugin_as_loaded(plugin)
end
@ -43,12 +43,12 @@ def load_plugins
ensure_all_registered_plugins_are_loaded!
end
# Adds the load paths for every plugin into the $LOAD_PATH. Plugin load paths are
# added *after* the application's <tt>lib</tt> directory, to ensure that an application
# can always override code within a plugin.
#
# Plugin load paths are also added to Dependencies.load_paths, and Dependencies.load_once_paths.
# Plugin load paths are also added to Dependencies.load_paths, and Dependencies.load_once_paths.
def add_plugin_load_paths
plugins.each do |plugin|
plugin.load_paths.each do |path|
@ -56,7 +56,7 @@ def add_plugin_load_paths
ActiveSupport::Dependencies.load_paths << path
unless Rails.configuration.reload_plugins?
unless configuration.reload_plugins?
ActiveSupport::Dependencies.load_once_paths << path
end
end
@ -64,8 +64,8 @@ def add_plugin_load_paths
$LOAD_PATH.uniq!
end
protected
def configure_engines
if engines.any?
@ -74,20 +74,22 @@ def configure_engines
add_engine_view_paths
end
end
def add_engine_routing_configurations
engines.select(&:routed?).collect(&:routing_file).each do |routing_file|
ActionController::Routing::Routes.add_configuration_file(routing_file)
end
end
def add_engine_controller_paths
ActionController::Routing.controller_paths += engines.collect(&:controller_path)
end
def add_engine_view_paths
# reverse it such that the last engine can overwrite view paths from the first, like with routes
ActionController::Base.view_paths += ActionView::PathSet.new(engines.collect(&:view_path).reverse)
paths = ActionView::PathSet.new(engines.collect(&:view_path).reverse)
ActionController::Base.view_paths.concat(paths)
ActionMailer::Base.view_paths.concat(paths) if configuration.frameworks.include?(:action_mailer)
end
# The locate_plugins method uses each class in config.plugin_locators to
@ -106,7 +108,7 @@ def register_plugin_as_loaded(plugin)
def configuration
initializer.configuration
end
def should_load?(plugin)
# uses Plugin#name and Plugin#valid?
enabled?(plugin) && plugin.valid?
@ -120,21 +122,21 @@ def order_plugins(plugin_a, plugin_b)
plugin_a <=> plugin_b
else
effective_order_of(plugin_a) <=> effective_order_of(plugin_b)
end
end
end
end
def effective_order_of(plugin)
if explicitly_enabled?(plugin)
registered_plugin_names.index(plugin.name)
registered_plugin_names.index(plugin.name)
else
registered_plugin_names.index('all')
end
end
end
def application_lib_index
$LOAD_PATH.index(File.join(RAILS_ROOT, 'lib')) || 0
end
end
def enabled?(plugin)
!explicit_plugin_loading_order? || registered?(plugin)
@ -155,23 +157,23 @@ def explicitly_enabled?(plugin)
def explicitly_registered?(plugin)
explicit_plugin_loading_order? && registered_plugin_names.include?(plugin.name)
end
def registered_plugins_names_plugin?(plugin)
registered_plugin_names.include?(plugin.name) || registered_plugin_names.include?('all')
end
# The plugins that have been explicitly listed with config.plugins. If this list is nil
# then it means the client does not care which plugins or in what order they are loaded,
# then it means the client does not care which plugins or in what order they are loaded,
# so we load all in alphabetical order. If it is an empty array, we load no plugins, if it is
# non empty, we load the named plugins in the order specified.
def registered_plugin_names
configuration.plugins ? configuration.plugins.map(&:to_s) : nil
end
def loaded?(plugin_name)
initializer.loaded_plugins.detect { |plugin| plugin.name == plugin_name.to_s }
end
def ensure_all_registered_plugins_are_loaded!
if explicit_plugin_loading_order?
if configuration.plugins.detect {|plugin| plugin != :all && !loaded?(plugin) }
@ -180,7 +182,7 @@ def ensure_all_registered_plugins_are_loaded!
end
end
end
end
end
end

4
railties/lib/tasks/gems.rake
View File

@ -17,13 +17,13 @@ end
namespace :gems do
task :base do
$rails_rake_task = true
$gems_rake_task = true
Rake::Task[:environment].invoke
end
desc "Build any native extensions for unpacked gems"
task :build do
$rails_rake_task = true
$gems_rake_task = true
require 'rails/gem_builder'
Dir[File.join(Rails::GemDependency.unpacked_path, '*')].each do |gem_dir|
spec_file = File.join(gem_dir, '.specification')

5
railties/test/initializer_test.rb
View File

@ -182,6 +182,7 @@ def assert_framework_path(path)
class InitializerPluginLoadingTests < Test::Unit::TestCase
def setup
@configuration = Rails::Configuration.new
@configuration.frameworks -= [:action_mailer]
@configuration.plugin_paths << plugin_fixture_root_path
@initializer = Rails::Initializer.new(@configuration)
@valid_plugin_path = plugin_fixture_path('default/stubby')
@ -310,8 +311,8 @@ def test_config_defaults_and_settings_should_be_added_to_i18n_defaults
Rails::Initializer.run(:initialize_i18n, config)
assert_equal [
File.expand_path("./test/../../activesupport/lib/active_support/locale/en.yml"),
File.expand_path("./test/../../actionpack/lib/action_view/locale/en.yml"),
File.expand_path(File.dirname(__FILE__) + "/../../activesupport/lib/active_support/locale/en.yml"),
File.expand_path(File.dirname(__FILE__) + "/../../actionpack/lib/action_view/locale/en.yml"),
"my/test/locale.yml",
"my/other/locale.yml" ], I18n.load_path.collect { |path| path =~ /^\./ ? File.expand_path(path) : path }
end

9
railties/test/plugin_loader_test.rb
View File

@ -1,7 +1,9 @@
require 'plugin_test_helper'
$:.unshift File.dirname(__FILE__) + "/../../actionpack/lib"
$:.unshift File.dirname(__FILE__) + "/../../actionmailer/lib"
require 'action_controller'
require 'action_mailer'
# Mocks out the configuration
module Rails
@ -125,14 +127,15 @@ def test_should_add_engine_load_paths_to_Dependencies_load_paths
end
end
def test_engine_controllers_should_have_their_view_path_set_when_loaded
def test_engine_controllers_and_action_mailers_should_have_their_view_path_set_when_loaded
only_load_the_following_plugins!([ :engine ])
@loader.send :add_engine_view_paths
assert_equal [ File.join(plugin_fixture_path('engines/engine'), 'app', 'views').sub(/\A\.\//, '') ], ActionController::Base.view_paths
assert_equal [ File.join(plugin_fixture_path('engines/engine'), 'app', 'views') ], ActionController::Base.view_paths
assert_equal [ File.join(plugin_fixture_path('engines/engine'), 'app', 'views') ], ActionMailer::Base.view_paths
end
def test_should_add_plugin_load_paths_to_Dependencies_load_once_paths
only_load_the_following_plugins! [:stubby, :acts_as_chunky_bacon]