diff options
Diffstat (limited to 'actionpack')
19 files changed, 331 insertions, 184 deletions
diff --git a/actionpack/lib/action_controller.rb b/actionpack/lib/action_controller.rb index 1a3e05cc86..ca826e7bfc 100644 --- a/actionpack/lib/action_controller.rb +++ b/actionpack/lib/action_controller.rb @@ -59,6 +59,7 @@ module ActionController 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' diff --git a/actionpack/lib/action_controller/dispatcher.rb b/actionpack/lib/action_controller/dispatcher.rb index e91babde10..ec40b5c4e6 100644 --- a/actionpack/lib/action_controller/dispatcher.rb +++ b/actionpack/lib/action_controller/dispatcher.rb @@ -5,8 +5,9 @@ module ActionController 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 @@ module ActionController 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 @@ module ActionController 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 diff --git a/actionpack/lib/action_controller/layout.rb b/actionpack/lib/action_controller/layout.rb index d6bcf7a8c1..a0db7acf72 100644 --- a/actionpack/lib/action_controller/layout.rb +++ b/actionpack/lib/action_controller/layout.rb @@ -172,23 +172,10 @@ module ActionController #: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 @@ module ActionController #:nodoc: # 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 @@ module ActionController #:nodoc: 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 diff --git a/actionpack/lib/action_controller/middleware_stack.rb b/actionpack/lib/action_controller/middleware_stack.rb index dbc2fda41e..b739a6d72d 100644 --- a/actionpack/lib/action_controller/middleware_stack.rb +++ b/actionpack/lib/action_controller/middleware_stack.rb @@ -27,7 +27,9 @@ module ActionController 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 @@ module ActionController end def active? + return false unless klass + if @conditional.respond_to?(:call) @conditional.call else @@ -63,11 +67,17 @@ module ActionController 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) diff --git a/actionpack/lib/action_controller/middlewares.rb b/actionpack/lib/action_controller/middlewares.rb index 8ea1b5c7ce..371cf6d8f7 100644 --- a/actionpack/lib/action_controller/middlewares.rb +++ b/actionpack/lib/action_controller/middlewares.rb @@ -4,17 +4,8 @@ use "Rack::Lock", :if => lambda { 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" diff --git a/actionpack/lib/action_controller/reloader.rb b/actionpack/lib/action_controller/reloader.rb new file mode 100644 index 0000000000..46789309cd --- /dev/null +++ b/actionpack/lib/action_controller/reloader.rb @@ -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 diff --git a/actionpack/lib/action_controller/routing/segments.rb b/actionpack/lib/action_controller/routing/segments.rb index 5dda3d4d00..129e87c139 100644 --- a/actionpack/lib/action_controller/routing/segments.rb +++ b/actionpack/lib/action_controller/routing/segments.rb @@ -191,23 +191,19 @@ module ActionController 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 @@ module ActionController "(?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 @@ module ActionController "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 diff --git a/actionpack/lib/action_view/base.rb b/actionpack/lib/action_view/base.rb index 4198725e0d..65b2062337 100644 --- a/actionpack/lib/action_view/base.rb +++ b/actionpack/lib/action_view/base.rb @@ -254,8 +254,8 @@ module ActionView #: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] diff --git a/actionpack/lib/action_view/reloadable_template.rb b/actionpack/lib/action_view/reloadable_template.rb index 3081be60fd..5ef833d75c 100644 --- a/actionpack/lib/action_view/reloadable_template.rb +++ b/actionpack/lib/action_view/reloadable_template.rb @@ -27,49 +27,50 @@ module ActionView #:nodoc: 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 - end - # fill in any newly created gaps - @paths.values.uniq.each do |template| - template.accessible_paths.each {|path| @paths[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 - 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 + # 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 - # 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 @@ module ActionView #:nodoc: def initialize(*args) super - @compiled_methods = [] # we don't ever want to get frozen extend Unfreezable @@ -106,14 +106,11 @@ module ActionView #:nodoc: 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 diff --git a/actionpack/lib/action_view/template.rb b/actionpack/lib/action_view/template.rb index b8e2165ddf..ea838b9b02 100644 --- a/actionpack/lib/action_view/template.rb +++ b/actionpack/lib/action_view/template.rb @@ -6,12 +6,7 @@ module ActionView #:nodoc: 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 @@ module ActionView #:nodoc: # 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 @@ module ActionView #:nodoc: load! unless @loaded @paths[path] end - + private def templates_in_path (Dir.glob("#{@path}/**/*/**") | Dir.glob("#{@path}/**")).each do |file| @@ -88,7 +84,7 @@ module ActionView #:nodoc: end def create_template(file) - Template.new(file.split("#{self}/").last, self) + Template.new(relative_path_for_template_file(file), self) end end diff --git a/actionpack/test/activerecord/render_partial_with_record_identification_test.rb b/actionpack/test/activerecord/render_partial_with_record_identification_test.rb index 147b270808..0a596c7ae0 100644 --- a/actionpack/test/activerecord/render_partial_with_record_identification_test.rb +++ b/actionpack/test/activerecord/render_partial_with_record_identification_test.rb @@ -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 @@ class RenderPartialWithRecordIdentificationTest < ActiveRecordTestCase 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 diff --git a/actionpack/test/controller/dispatcher_test.rb b/actionpack/test/controller/dispatcher_test.rb index 47226f1fc5..7887b7110c 100644 --- a/actionpack/test/controller/dispatcher_test.rb +++ b/actionpack/test/controller/dispatcher_test.rb @@ -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 @@ class DispatcherTest < Test::Unit::TestCase 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 @@ class DispatcherTest < Test::Unit::TestCase 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 @@ class DispatcherTest < Test::Unit::TestCase 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) diff --git a/actionpack/test/controller/layout_test.rb b/actionpack/test/controller/layout_test.rb index 2f5e830fba..28555ee3d1 100644 --- a/actionpack/test/controller/layout_test.rb +++ b/actionpack/test/controller/layout_test.rb @@ -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 @@ class LayoutSetInResponseTest < ActionController::TestCase 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 @@ unless RUBY_PLATFORM =~ /(:?mswin|mingw|bccwin)/ end end end + diff --git a/actionpack/test/controller/middleware_stack_test.rb b/actionpack/test/controller/middleware_stack_test.rb index 2a141697da..918231013a 100644 --- a/actionpack/test/controller/middleware_stack_test.rb +++ b/actionpack/test/controller/middleware_stack_test.rb @@ -73,4 +73,18 @@ class MiddlewareStackTest < ActiveSupport::TestCase 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 diff --git a/actionpack/test/controller/routing_test.rb b/actionpack/test/controller/routing_test.rb index d6fc6fddb2..13ba0c30dd 100644 --- a/actionpack/test/controller/routing_test.rb +++ b/actionpack/test/controller/routing_test.rb @@ -340,6 +340,30 @@ class ControllerSegmentTest < Test::Unit::TestCase 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 @@ class LegacyRouteSetTests < Test::Unit::TestCase 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 @@ class LegacyRouteSetTests < Test::Unit::TestCase 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) diff --git a/actionpack/test/controller/session/cookie_store_test.rb b/actionpack/test/controller/session/cookie_store_test.rb index c94d7b0915..9c93ca6539 100644 --- a/actionpack/test/controller/session/cookie_store_test.rb +++ b/actionpack/test/controller/session/cookie_store_test.rb @@ -23,7 +23,7 @@ class CookieStoreTest < ActionController::IntegrationTest 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 diff --git a/actionpack/test/controller/view_paths_test.rb b/actionpack/test/controller/view_paths_test.rb index 6468283270..8ea13fbe98 100644 --- a/actionpack/test/controller/view_paths_test.rb +++ b/actionpack/test/controller/view_paths_test.rb @@ -42,34 +42,30 @@ class ViewLoadPathsTest < ActionController::TestCase 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 @@ class ViewLoadPathsTest < ActionController::TestCase 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 @@ class ViewLoadPathsTest < ActionController::TestCase 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 diff --git a/actionpack/test/fixtures/layout_tests/alt/layouts/alt.rhtml b/actionpack/test/fixtures/layout_tests/alt/layouts/alt.rhtml new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/actionpack/test/fixtures/layout_tests/alt/layouts/alt.rhtml diff --git a/actionpack/test/template/compiled_templates_test.rb b/actionpack/test/template/compiled_templates_test.rb index a8f8455a54..7d1d7634a8 100644 --- a/actionpack/test/template/compiled_templates_test.rb +++ b/actionpack/test/template/compiled_templates_test.rb @@ -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 @@ class CompiledTemplatesTest < Test::Unit::TestCase 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 @@ class CompiledTemplatesTest < Test::Unit::TestCase 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 |