fortitude 0.9.4-java → 0.9.5-java

data/fortitude.gemspec

@@ -25,25 +25,42 @@ Gem::Specification.new do |s|
     s.extensions << "ext/fortitude_native_ext/extconf.rb"
   end
 
-  activesupport_spec = if RUBY_VERSION =~ /^1\.8\./
-    [ ">= 3.0", "< 4.0" ]
-  else
-    [ ">= 3.0" ]
+  activesupport_spec = [ ">= 3.0" ]
+  ref_spec = [ ">= 1.0.5" ]
+  rake_spec = [ ">= 1.0" ]
+  json_spec = [ ">= 1.0" ]
+
+  if RUBY_VERSION =~ /^1\.8\./
+    activesupport_spec << "< 4.0"
+    ref_spec << "< 2.0.0"
+    rake_spec << "< 11.0.0"
+    json_spec << "< 2.0.0"
+  elsif RUBY_VERSION =~ /^1\.9\./
+    activesupport_spec << "< 5.0"
+    json_spec << "< 2.0.0"
+  elsif RUBY_VERSION =~ /^2\.[01]\./
+    activesupport_spec << "< 5.0"
   end
 
   s.add_dependency "activesupport", *activesupport_spec
-  s.add_dependency "ref", ">= 1.0.5"
+  s.add_dependency "ref", *ref_spec
+
+  s.add_development_dependency "rake", *rake_spec
+  s.add_development_dependency "json", *json_spec
 
   s.add_development_dependency "bundler", "~> 1.5"
-  s.add_development_dependency "rake"
   s.add_development_dependency "rspec", "~> 2.99"
   s.add_development_dependency "rake-compiler"
-  s.add_development_dependency "json"
   s.add_development_dependency "tilt", "~> 2.0"
-  s.add_development_dependency "oop_rails_server", ">= 0.0.7"
+  s.add_development_dependency "oop_rails_server", ">= 0.0.22"
 
   # This is because i18n >= 0.7 is incompatible with Ruby 1.8.x.
   if RUBY_VERSION =~ /^1\.8\./
     s.add_development_dependency "i18n", "~> 0.6.0", "< 0.7.0"
   end
+
+  # This is because 'tins' >= 1.7.0 is incompatible with Ruby < 2.0.0.
+  if RUBY_VERSION =~ /^1\./
+    s.add_development_dependency "tins", "< 1.7.0"
+  end
 end

data/lib/fortitude/erector.rb

@@ -1,3 +1,5 @@
+require 'fortitude/support/method_overriding'
+
 module Fortitude
   module Erector
     class << self
@@ -31,6 +33,10 @@ module Fortitude
         return is_erector_widget_class?(widget_class.superclass)
       end
 
+      def erector_widget_base_class_if_available
+        ::Erector::Widget if is_erector_available?
+      end
+
       def is_erector_widget?(widget)
         is_erector_widget_class?(widget.class)
       end
@@ -48,27 +54,29 @@ module Fortitude
       private
       attr_reader :erector_output
     end
-  end
-end
 
-if ::Fortitude::Erector.is_erector_available?
-  ::Erector::AbstractWidget.class_eval do
-    def widget_with_fortitude(target, assigns = {}, options = {}, &block)
-      if (target.kind_of?(::Class) && target < ::Fortitude::Widget)
-        target = target.new(assigns)
-      end
+    module ErectorAbstractWidgetOverrides
+      def widget_uniwith_fortitude(original_method, target, assigns = {}, options = {}, &block)
+        if (target.kind_of?(::Class) && target < ::Fortitude::Widget)
+          target = target.new(assigns)
+        end
 
-      if target.kind_of?(::Fortitude::Widget)
-        rendering_context = ::Fortitude::RenderingContext.new(
-          :delegate_object => parent,
-          :output_buffer_holder => ::Fortitude::Erector::ErectorOutputBufferHolder.new(output),
-          :helpers_object => helpers)
-        return target.render_to(rendering_context, &block)
-      else
-        return widget_without_fortitude(target, assigns, options, &block)
+        if target.kind_of?(::Fortitude::Widget)
+          rendering_context = ::Fortitude::RenderingContext.new(
+            :delegate_object => parent,
+            :output_buffer_holder => ::Fortitude::Erector::ErectorOutputBufferHolder.new(output),
+            :helpers_object => helpers)
+          return target.render_to(rendering_context, &block)
+        else
+          return original_method.call(target, assigns, options, &block)
+        end
       end
     end
-
-    alias_method_chain :widget, :fortitude
   end
 end
+
+if ::Fortitude::Erector.is_erector_available?
+  ::Fortitude::MethodOverriding.override_methods(
+    ::Erector::AbstractWidget, ::Fortitude::Erector::ErectorAbstractWidgetOverrides, :fortitude,
+    [ :widget ])
+end

data/lib/fortitude/errors.rb

@@ -153,16 +153,27 @@ you simply need to convert these to "p :class => :some_class" or
     class NoBlockToYieldTo < Base
       attr_reader :widget
 
-      def initialize(widget)
-        super(%{You're trying to call 'yield' (or 'yield_from_widget', or the Erector-compatibility method 'call_block')
+      def initialize(widget, local_jump_exception = nil)
+        @local_jump_exception = local_jump_exception
+        @widget = widget
+
+        message = %{You're trying to call 'yield' (or 'yield_from_widget', or the Erector-compatibility method 'call_block')
 from the widget #{widget}; however, there is nothing to yield to. Fortitude
 looks for something to yield to in this order:
   1. A block passed to a yield at render time directly (usually via the 'widget' call);
   2. A block passed to the constructor of the widget;
   3. The layout the widget is being rendered in.
 None of these exist here, and so calling 'yield', 'yield_from_widget', or 'call_block' is an
-undefined operation.})
-        @widget = widget
+undefined operation.}
+
+        if @local_jump_exception
+          message += %{
+
+This was caused by a #{@local_jump_exception.class.name}, which is: #{@local_jump_exception}:\n
+    #{@local_jump_exception.backtrace.join("\n    ")}}
+        end
+
+        super(message)
       end
     end
   end

data/lib/fortitude/extensions/fortitude_ruby_ext.rb

@@ -2,10 +2,35 @@ require 'erb'
 
 ::String.class_eval do
   def fortitude_append_escaped_string(output)
+    _fortitude_append_escaped_string(output, false)
+  end
+
+  TABLE_FOR_ESCAPE_ATTRIBUTE_VALUE__ = {
+    '&' => '&',
+    '"' => '"'
+  }
+
+  PROC_FOR_ESCAPE_ATTRIBUTE_VALUE__ = Proc.new do |match|
+    TABLE_FOR_ESCAPE_ATTRIBUTE_VALUE__[match]
+  end
+
+  if RUBY_VERSION =~ /^1\.8\./
+    def _fortitude_append_escaped_string_for_value(output)
+      output.original_concat(self.gsub(/[&\"]/, &PROC_FOR_ESCAPE_ATTRIBUTE_VALUE__))
+    end
+  else
+    def _fortitude_append_escaped_string_for_value(output)
+      output.original_concat(self.gsub(/[&\"]/, TABLE_FOR_ESCAPE_ATTRIBUTE_VALUE__))
+    end
+  end
+
+  def _fortitude_append_escaped_string(output, for_attribute_value)
     raise ArgumentError, "You can only append to a String" unless output.kind_of?(String)
 
     if html_safe?
       output.original_concat(self)
+    elsif for_attribute_value
+      _fortitude_append_escaped_string_for_value(output)
     else
       output.original_concat(ERB::Util.html_escape(self))
     end
@@ -33,8 +58,8 @@ end
     each do |key, value|
       if value.kind_of?(Hash)
         new_prefix = case prefix
-        when String then fortitude_append_to(key, prefix.dup)
-        when nil then fortitude_append_to(key, "".html_safe)
+        when String then fortitude_append_to(key, prefix.dup, false)
+        when nil then fortitude_append_to(key, "".html_safe, false)
         else raise ArgumentError, "You can only use a String as a prefix"
         end
 
@@ -52,19 +77,19 @@ end
           else raise ArgumentError, "You can only use a String as a prefix"
           end
 
-          fortitude_append_to(key, target)
+          fortitude_append_to(key, target, false)
 
           if value == true
             if allows_bare_attributes
               # nothing here
             else
               target.original_concat(::Hash::FORTITUDE_EQUALS_QUOTE)
-              fortitude_append_to(key, target)
+              fortitude_append_to(key, target, false)
               target.original_concat(::Hash::FORTITUDE_QUOTE)
             end
           else
             target.original_concat(::Hash::FORTITUDE_EQUALS_QUOTE)
-            fortitude_append_to(value, target)
+            fortitude_append_to(value, target, true)
             target.original_concat(::Hash::FORTITUDE_QUOTE)
           end
         end
@@ -75,17 +100,17 @@ end
   end
 
   private
-  def fortitude_append_to(object, output)
+  def fortitude_append_to(object, output, for_attribute_value)
     case object
-    when String then object.fortitude_append_escaped_string(output)
-    when Symbol then object.to_s.fortitude_append_escaped_string(output)
+    when String then object._fortitude_append_escaped_string(output, for_attribute_value)
+    when Symbol then object.to_s._fortitude_append_escaped_string(output, for_attribute_value)
     when Array then object.each_with_index do |o,i|
       output.original_concat(" ") if i > 0
-      fortitude_append_to(o, output)
+      fortitude_append_to(o, output, for_attribute_value)
     end
     when nil then nil
     when Integer then output.original_concat(object.to_s)
-    else object.to_s.fortitude_append_escaped_string(output)
+    else object.to_s._fortitude_append_escaped_string(output, for_attribute_value)
     end
   end
 end

data/lib/fortitude/rails/helpers.rb

@@ -4,20 +4,77 @@ module Fortitude
       class << self
         def helper(name, options = { })
           @helpers ||= { }
-          @helpers[name] = options
+          @helpers[normalize_helper_name(name)] = options
         end
 
         def helper_options(name)
-          @helpers[name.to_s.strip.downcase.to_sym]
+          @helpers[normalize_helper_name(name)]
         end
 
         def apply_refined_helpers_to!(o)
+          o.send(:include, ::Rails.application.routes.url_helpers)
           @helpers.each do |name, options|
             o.helper(name, options)
           end
         end
+
+        ALL_BUILTIN_HELPER_MODULES = {
+          ActionView::Helpers => %w{
+            ActiveModelHelper
+            ActiveModelInstanceTag
+            AssetTagHelper
+            AssetUrlHelper
+            AtomFeedHelper
+            CacheHelper
+            CaptureHelper
+            CsrfHelper
+            DateHelper
+            DebugHelper
+            FormHelper
+            FormOptionsHelper
+            FormTagHelper
+            JavaScriptHelper
+            NumberHelper
+            OutputSafetyHelper
+            RecordTagHelper
+            SanitizeHelper
+            TagHelper
+            TextHelper
+            TranslationHelper
+            UrlHelper
+          }
+        }
+
+        def declare_all_builtin_rails_helpers!
+          ALL_BUILTIN_HELPER_MODULES.each do |base_module, constant_names|
+            constant_names.each do |constant_name|
+              if base_module.const_defined?(constant_name)
+                helper_module = base_module.const_get(constant_name)
+                helper_module.public_instance_methods.each do |helper_method_name|
+                  # This is because ActionView::Helpers::FormTagHelper exposes #embed_authenticity_token_in_remote_forms=
+                  # as a public instance method. This seems like it should not be included as a helper.
+                  # next if helper_method_name.to_s == 'embed_authenticity_token_in_remote_forms='
+                  helper helper_method_name
+                end
+              end
+            end
+          end
+
+          helper :default_url_options
+        end
+
+        private
+        def normalize_helper_name(name)
+          name.to_s.strip.downcase.to_sym
+        end
       end
 
+      # This gives us all built-in Rails helpers, whether they're refined or not; our re-declarations of helpers,
+      # below, will override any of these. We need to grab all built-in Rails helpers because we want them all
+      # formally declared -- that is, even if +automatic_helper_access+ is set to +false+, built-in Rails helpers
+      # should still work properly.
+      declare_all_builtin_rails_helpers!
+
       # tags/
       # active_model_helper
       # asset_tag_helper

data/lib/fortitude/rails/railtie.rb

@@ -1,5 +1,7 @@
 require 'fortitude/rendering_context'
 require 'fortitude/rails/fortitude_rails_helpers'
+require 'fortitude/support/method_overriding'
+require 'thread'
 
 if defined?(ActiveSupport)
   ActiveSupport.on_load(:before_initialize) do
@@ -23,6 +25,33 @@ end
 module Fortitude
   module Rails
     class Railtie < ::Rails::Railtie
+      class << self
+        def _fortitude_view_roots
+          @_fortitude_view_roots_mutex.synchronize do
+            raise "@_fortitude_view_roots has not yet been set" unless @_fortitude_view_roots
+            @_fortitude_view_roots
+          end
+        end
+
+        def _fortitude_view_roots=(x)
+          @_fortitude_view_roots_mutex.synchronize do
+            if @_fortitude_view_roots_locked
+              raise "@_fortitude_view_roots was locked, and cannot be changed. It was locked at:\n  #{@_fortitude_view_roots_locked}"
+            end
+
+            @_fortitude_view_roots = x
+          end
+        end
+
+        def _lock_fortitude_view_roots!
+          @_fortitude_view_roots_mutex.synchronize do
+            @_fortitude_view_roots_locked ||= caller.join("\n")
+          end
+        end
+      end
+
+      @_fortitude_view_roots_mutex = Mutex.new
+
       config.after_initialize do
         if Fortitude.refine_rails_helpers
           require 'fortitude/rails/helpers'
@@ -45,14 +74,14 @@ module Fortitude
         # Why so hard?
         #
         # We're trying to do something that ActiveSupport::Dependencies -- which is what Rails uses for
-        # class autoloading -- doesn't really support. We want app/views to be on the autoload path,
+        # class autoloading -- doesn't really support. We want all view paths to be on the autoload path,
         # because there are now Ruby classes living there. (It usually isn't just because all that's there
         # are template source files, not actual Ruby code.) That isn't an issue, though -- adding it
         # is trivial (just do
-        # <tt>ActiveSupport::Dependencies.autoload_paths << File.join(Rails.root, 'app/views')</tt>).
+        # <tt>ActiveSupport::Dependencies.autoload_paths += ::Rails.application.paths['app/views'].expanded</tt>).
         #
-        # The real issue is that we want the class <tt>app/views/foo/bar.rb</tt> to define a class called
-        # <tt>Views::Foo::Bar</tt>, not just plain <tt>Foo::Bar</tt>. This is what's different from what
+        # The real issue is that we want the class (<em>e.g.</em>) <tt>app/views/foo/bar.rb</tt> to define a class
+        # called <tt>Views::Foo::Bar</tt>, not just plain <tt>Foo::Bar</tt>. This is what's different from what
         # ActiveSupport::Dependencies normally supports; it expects the filesystem path underneath the
         # root to be exactly identical to the fully-qualified class name.
         #
@@ -62,208 +91,260 @@ module Fortitude
         # potential for conflicts is enormous.
         #
         # As such, we have this code. We'll walk through it step-by-step; note that at the end we *do*
-        # add app/views/ to the autoload path, so all this code is doing is just dealing with the fact that
+        # add all view paths to the autoload path, so all this code is doing is just dealing with the fact that
         # the fully-qualified classname (<tt>Views::Foo::Bar</tt>) has one extra component on the front of it
         # (<tt>Views::</tt>) when compared to the subpath (<tt>foo/bar.rb</tt>) underneath what's on the autoload
         # path (<tt>app/views</tt>).
 
-        # Go compute our views root.
-        views_root = File.expand_path(File.join(::Rails.root, 'app', 'views'))
+        # Go compute our view roots.
+        #
+        # Rails 3.0.x doesn't define #expanded on ::Rails::Paths::Path; it also has a different way of getting at
+        # the view paths (<tt>::Rails.application.paths.app.views</tt>, rather than
+        # <tt>::Rails.application.paths['app/views']</tt>). So, if we're on Rails 3.0.x, we simply inline the
+        # equivalent code here.
+        view_roots = if ::Rails.version =~ /^3\.0\./
+          paths = ::Rails.application.paths.app.views
+
+          result = []
 
-        # Now, do all this work inside ::ActiveSupport::Dependencies...
-        ::ActiveSupport::Dependencies.module_eval do
-          @@_fortitude_views_root = views_root
+          paths.each do |p|
+            root_path = p.instance_variable_get("@root")
+            root = if root_path then root_path.path else ::Rails.root end
+            glob = p.instance_variable_get("@glob")
 
-          def self._fortitude_views_root
-            @@_fortitude_views_root
-          end
+            path = File.expand_path(p, root)
 
-          # This is the method that gets called to auto-generate namespacing empty
-          # modules (_e.g._, the toplevel <tt>Views::</tt> module) for directories
-          # under an autoload path.
-          #
-          # The original method says:
-          #
-          # "Does the provided path_suffix correspond to an autoloadable module?
-          # Instead of returning a boolean, the autoload base for this module is
-          # returned."
-          #
-          # So, we just need to strip off the leading +views/+ from the +path_suffix+,
-          # and see if that maps to a directory underneath <tt>app/views/</tt>; if so,
-          # we'll return the path to <tt>.../app/views/</tt>. Otherwise, we just
-          # delegate back to the superclass method.
-          def autoloadable_module_with_fortitude?(path_suffix)
-            if path_suffix =~ %r{^views(/.*)?$}i
-              # If we got here, then we were passed a subpath of views/....
-              subpath = $1
-
-              if subpath.blank? || File.directory?(File.join(@@_fortitude_views_root, subpath))
-                return @@_fortitude_views_root
+            if glob && File.directory?(path)
+              Dir.chdir(path) do
+                result.concat(Dir.glob(glob).map { |file| File.join path, file }.sort)
               end
-            end
-
-            with_fortitude_views_removed_from_autoload_path do
-              autoloadable_module_without_fortitude?(path_suffix)
+            else
+              result << path
             end
           end
 
-          alias_method_chain :autoloadable_module?, :fortitude
-
-          # When we delegate back to original methods, we want them to act as if
-          # <tt>app/views/</tt> is _not_ on the autoload path. In order to be thread-safe
-          # about that, we couple this method with our override of the writer side of the
-          # <tt>mattr_accessor :autoload_paths</tt>, which simply prefers the thread-local
-          # that we set to the actual underlying variable.
-          def with_fortitude_views_removed_from_autoload_path
-            begin
-              Thread.current[:_fortitude_autoload_paths_override] = autoload_paths - [ @@_fortitude_views_root ]
-              yield
-            ensure
-              Thread.current[:_fortitude_autoload_paths_override] = nil
+          result.uniq!
+          result
+        else
+          ::Rails.application.paths['app/views'].expanded
+        end
+
+        ::Fortitude::Rails::Railtie._fortitude_view_roots = view_roots
+
+        module ActiveSupportDependenciesOverrides
+          class << self
+            # When we delegate back to original methods, we want them to act as if
+            # all view roots are _not_ on the autoload path. In order to be thread-safe
+            # about that, we couple this method with our override of the writer side of the
+            # <tt>mattr_accessor :autoload_paths</tt>, which simply prefers the thread-local
+            # that we set to the actual underlying variable.
+            def with_fortitude_views_removed_from_autoload_path
+              begin
+                Thread.current[:_fortitude_autoload_paths_override] =
+                  ::ActiveSupport::Dependencies.autoload_paths -
+                  ::Fortitude::Rails::Railtie._fortitude_view_roots
+
+                yield
+              ensure
+                Thread.current[:_fortitude_autoload_paths_override] = nil
+              end
             end
           end
 
-          # The use of 'class_eval' here may seem funny, and I think it is, but, without it,
-          # the +@@autoload_paths+ gets interpreted as a class variable for this *Railtie*,
-          # rather than for ::ActiveSupport::Dependencies. (Why is that? Got me...)
-          class_eval <<-EOS
-            def self.autoload_paths
-              Thread.current[:_fortitude_autoload_paths_override] || @@autoload_paths
+          module Common
+            def autoload_paths_uniwith_fortitude(original_method)
+              Thread.current[:_fortitude_autoload_paths_override] || original_method.call
             end
-          EOS
 
-          # The original method says:
-          #
-          # "Search for a file in autoload_paths matching the provided suffix."
-          #
-          # So, we just look to see if the given +path_suffix+ is specifying something like
-          # <tt>views/foo/bar</tt> or the fully-qualified version thereof; if so, we glue it together properly,
-          # removing the initial <tt>views/</tt> first. (Otherwise, the mechanism would expect
-          # <tt>Views::Foo::Bar</tt> to show up in <tt>app/views/views/foo/bar</tt> (yes, a double
-          # +views+), since <tt>app/views</tt> is on the autoload path.)
-          def search_for_file_with_fortitude(path_suffix)
-            # Remove any ".rb" extension, if present...
-            new_path_suffix = path_suffix.sub(/(\.rb)?$/, "")
-
-            found_subpath = if new_path_suffix =~ %r{^views(/.*)$}i
-              $1
-            elsif new_path_suffix =~ %r{^#{Regexp.escape(@@_fortitude_views_root)}(/.*)$}i
-              $1
+            # This is the method that gets called to auto-generate namespacing empty
+            # modules (_e.g._, the toplevel <tt>Views::</tt> module) for directories
+            # under an autoload path.
+            #
+            # The original method says:
+            #
+            # "Does the provided path_suffix correspond to an autoloadable module?
+            # Instead of returning a boolean, the autoload base for this module is
+            # returned."
+            #
+            # So, we just need to strip off the leading +views/+ from the +path_suffix+,
+            # and see if that maps to a directory underneath one of our view roots; if so,
+            # we'll return the path to that view root. Otherwise, we just
+            # delegate back to the superclass method.
+            def autoloadable_module_uniwith_fortitude?(original_method, path_suffix)
+              if path_suffix =~ %r{^(views)(/.*)?$}i
+                # If we got here, then we were passed a subpath of views/....
+                prefix = $1
+                subpath = $2
+
+                if subpath.blank?
+                  ::Fortitude::Rails::Railtie._fortitude_view_roots.each do |view_root|
+                    return view_root if File.basename(view_root).strip.downcase == prefix.strip.downcase
+                  end
+                else
+                  ::Fortitude::Rails::Railtie._fortitude_view_roots.each do |view_root|
+                    return view_root if File.directory?(File.join(view_root, subpath))
+                  end
+                end
+              end
+
+              ActiveSupportDependenciesOverrides.with_fortitude_views_removed_from_autoload_path do
+                original_method.call(path_suffix)
+              end
             end
 
-            if found_subpath
-              full_path = File.join(@@_fortitude_views_root, "#{found_subpath}")
-              directory = File.dirname(full_path)
+            # The original method says:
+            #
+            # "Search for a file in autoload_paths matching the provided suffix."
+            #
+            # So, we just look to see if the given +path_suffix+ is specifying something like
+            # <tt>views/foo/bar</tt> or the fully-qualified version thereof; if so, we glue it together properly,
+            # removing the initial <tt>views/</tt> first. (Otherwise, the mechanism would expect
+            # <tt>Views::Foo::Bar</tt> to show up in <tt>app/views/views/foo/bar</tt> (yes, a double
+            # +views+), since <tt>app/views</tt> is on the autoload path.)
+            def search_for_file_uniwith_fortitude(original_method, path_suffix)
+              # Remove any ".rb" extension, if present...
+              new_path_suffix = path_suffix.sub(/(\.rb)?$/, "")
+
+              found_subpath = nil
+              if new_path_suffix =~ %r{^views(/.*)$}i
+                found_subpath = $1
+              else
+                ::Fortitude::Rails::Railtie._fortitude_view_roots.each do |view_root|
+                  if new_path_suffix =~ %r{^#{Regexp.escape(view_root)}(/.*)$}i
+                    found_subpath = $1
+                    break
+                  end
+                end
+              end
 
-              if File.directory?(directory)
-                filename = File.basename(full_path)
+              if found_subpath
+                ::Fortitude::Rails::Railtie._fortitude_view_roots.each do |view_root|
+                  full_path = File.join(view_root, "#{found_subpath}")
+                  directory = File.dirname(full_path)
 
-                regexp1 = /^_?#{Regexp.escape(filename)}\./
-                regexp2 = /\.rb$/i
-                applicable_entries = Dir.entries(directory).select do |entry|
-                  ((entry == filename) || (entry =~ regexp1 && entry =~ regexp2)) && File.file?(File.join(directory, entry))
-                end
-                return nil if applicable_entries.length == 0
+                  if File.directory?(directory)
+                    filename = File.basename(full_path)
+
+                    regexp1 = /^_?#{Regexp.escape(filename)}\./
+                    regexp2 = /\.rb$/i
+                    applicable_entries = Dir.entries(directory).select do |entry|
+                      ((entry == filename) || (entry =~ regexp1 && entry =~ regexp2)) && File.file?(File.join(directory, entry))
+                    end
+
+                    return nil if applicable_entries.length == 0
 
-                # Prefer those without an underscore
-                without_underscore = applicable_entries.select { |e| e !~ /^_/ }
-                applicable_entries = without_underscore if without_underscore.length > 0
+                    # Prefer those without an underscore
+                    without_underscore = applicable_entries.select { |e| e !~ /^_/ }
+                    applicable_entries = without_underscore if without_underscore.length > 0
 
-                entry_to_use = applicable_entries.sort_by { |e| e.length }.reverse.first
-                return File.join(directory, entry_to_use)
+                    entry_to_use = applicable_entries.sort_by { |e| e.length }.reverse.first
+                    return File.join(directory, entry_to_use)
+                  end
+                end
               end
-            end
 
-            # Make sure that we remove the views autoload path before letting the rest of
-            # the dependency mechanism go searching for files, or else <tt>app/views/foo/bar.rb</tt>
-            # *will* be found when looking for just <tt>::Foo::Bar</tt>.
-            with_fortitude_views_removed_from_autoload_path { search_for_file_without_fortitude(path_suffix) }
+              # Make sure that we remove the views autoload path before letting the rest of
+              # the dependency mechanism go searching for files, or else <tt>app/views/foo/bar.rb</tt>
+              # *will* be found when looking for just <tt>::Foo::Bar</tt>.
+              ActiveSupportDependenciesOverrides.with_fortitude_views_removed_from_autoload_path do
+                original_method.call(path_suffix)
+              end
+            end
           end
-
-          alias_method_chain :search_for_file, :fortitude
         end
 
-        # Two important comments here:
-        #
-        # 1: We also need to patch ::Rails::Engine.eager_load! so that it loads classes under app/views/. However, we
-        # can't just add it to the normal eager load paths, because that will allow people to do "require 'foo/bar'"
-        # and have it match app/views/foo/bar.rb, which we don't want. So, instead, we load these classes ourselves.
-        # Note that we ALSO have to do things slightly differently than Rails does it, because we need to skip loading
-        # 'foo.rb' if 'foo.html.rb' exists -- and because we have to require the fully-qualified pathname, since
-        # app/views is not actually on the load path.
-        #
-        # 2: I (ageweke) added this very late in the path of Fortitude development, after trying to use Fortitude in a
-        # deployment (production) environment in which widgets just weren't getting loaded at all. Yet there's something
-        # I don't understand: clearly, without this code, widgets will not be eager-loaded (which is probably not a
-        # great thing for performance reasons)...but I think they still should get auto-loaded and hence actually work
-        # just fine. But they don't in that environment (you'll get errors like "uninitialized constant Views::Base").
-        # Since I understand what's going on and have the fix for it here, that's fine...except that I can't seem to
-        # write a spec for it, because I don't know how to actually *make* it fail. If anybody comes along later and
-        # knows what would make it fail (and I double-checked, and we don't have autoloading disabled in production or
-        # anything like that), let me know, so that I can write a spec for this. Thanks!
-        ::Rails::Engine.class_eval do
-          def eager_load_with_fortitude!
-            eager_load_without_fortitude!
+        ::Fortitude::MethodOverriding.override_methods(
+          ::ActiveSupport::Dependencies, ActiveSupportDependenciesOverrides::Common, :fortitude,
+          [ :search_for_file, :autoloadable_module?, :autoload_paths ])
+
+        eigenclass = ::ActiveSupport::Dependencies.module_eval "class << self; self; end"
+        ::Fortitude::MethodOverriding.override_methods(
+          eigenclass, ActiveSupportDependenciesOverrides::Common, :fortitude,
+          [ :autoload_paths ])
+
+        module RailsEngineOverrides
+          # Two important comments here:
+          #
+          # 1: We also need to patch ::Rails::Engine.eager_load! so that it loads classes under all view roots. However, we
+          # can't just add them to the normal eager load paths, because that will allow people to do "require 'foo/bar'"
+          # and have it match app/views/foo/bar.rb, which we don't want. So, instead, we load these classes ourselves.
+          # Note that we ALSO have to do things slightly differently than Rails does it, because we need to skip loading
+          # 'foo.rb' if 'foo.html.rb' exists -- and because we have to require the fully-qualified pathname, since
+          # app/views is not actually on the load path.
+          #
+          # 2: I (ageweke) added this very late in the path of Fortitude development, after trying to use Fortitude in a
+          # deployment (production) environment in which widgets just weren't getting loaded at all. Yet there's something
+          # I don't understand: clearly, without this code, widgets will not be eager-loaded (which is probably not a
+          # great thing for performance reasons)...but I think they still should get auto-loaded and hence actually work
+          # just fine. But they don't in that environment (you'll get errors like "uninitialized constant Views::Base").
+          # Since I understand what's going on and have the fix for it here, that's fine...except that I can't seem to
+          # write a spec for it, because I don't know how to actually *make* it fail. If anybody comes along later and
+          # knows what would make it fail (and I double-checked, and we don't have autoloading disabled in production or
+          # anything like that), let me know, so that I can write a spec for this. Thanks!
+          def eager_load_uniwith_fortitude!(original_method)
+            original_method.call
             eager_load_fortitude_views!
           end
 
           def eager_load_fortitude_views!
-            load_path = ::ActiveSupport::Dependencies._fortitude_views_root
-            all_files = Dir.glob("#{load_path}/**/*.rb")
-            matcher = /\A#{Regexp.escape(load_path.to_s)}\/(.*)\.rb\Z/
+            ::Fortitude::Rails::Railtie._fortitude_view_roots.each do |load_path|
+              all_files = Dir.glob("#{load_path}/**/*.rb")
+              matcher = /\A#{Regexp.escape(load_path.to_s)}\/(.*)\.rb\Z/
 
-            all_files.sort.each do |full_path|
-              filename = File.basename(full_path, ".rb")
-              directory = File.dirname(full_path)
+              all_files.sort.each do |full_path|
+                filename = File.basename(full_path, ".rb")
+                directory = File.dirname(full_path)
 
-              longer_name_regex = /^#{Regexp.escape(filename)}\..+\.rb$/i
-              longer_name = Dir.entries(directory).detect { |e| e =~ longer_name_regex }
+                longer_name_regex = /^#{Regexp.escape(filename)}\..+\.rb$/i
+                longer_name = Dir.entries(directory).detect { |e| e =~ longer_name_regex }
 
-              unless longer_name
-                require_dependency File.join('views', full_path.sub(matcher, '\1'))
+                unless longer_name
+                  require_dependency File.join('views', full_path.sub(matcher, '\1'))
+                end
               end
             end
           end
-
-          alias_method_chain :eager_load!, :fortitude
         end
 
-        # And, finally, this is where we add our root to the set of autoload paths.
-        ::ActiveSupport::Dependencies.autoload_paths << views_root
-        # app.config.eager_load_paths << views_root
+        ::Fortitude::MethodOverriding.override_methods(
+          ::Rails::Engine, RailsEngineOverrides, :fortitude, [ :eager_load! ])
 
-        # This is our support for partials. Fortitude doesn't really have a distinction between
-        # partials and "full" templates -- everything is just a widget, which is much more elegant --
-        # but we still want you to be able to render a widget <tt>Views::Foo::Bar</tt> by saying
-        # <tt>render :partial => 'foo/bar'</tt> (from ERb, although you can do it from Fortitude if
-        # you want for some reason, too).
-        #
-        # Normally, ActionView only looks for partials in files starting with an underscore. We
-        # do want to allow this, too (in the above case, if you define the widget in the file
-        # <tt>app/views/foo/_bar.rb</tt>, it will still work fine); however, we also want to allow
-        # you to define it in a file that does _not_ start with an underscore ('cause these are
-        # Ruby classes, and that's just plain weird).
-        #
-        # So, we patch #find_templates: if it's looking for a partial, doesn't find one, and is
-        # searching Fortitude templates (the +.rb+ handler), then we try again, turning off the
-        # +partial+ flag, and return that instead.
-        ::ActionView::PathResolver.class_eval do
-          def find_templates_with_fortitude(name, prefix, partial, details)
-            templates = find_templates_without_fortitude(name, prefix, partial, details)
+        # And, finally, this is where we add our view roots to the set of autoload paths.
+        ::ActiveSupport::Dependencies.autoload_paths += view_roots
+
+        module ActionViewPathResolverOverrides
+          # This is our support for partials. Fortitude doesn't really have a distinction between
+          # partials and "full" templates -- everything is just a widget, which is much more elegant --
+          # but we still want you to be able to render a widget <tt>Views::Foo::Bar</tt> by saying
+          # <tt>render :partial => 'foo/bar'</tt> (from ERb, although you can do it from Fortitude if
+          # you want for some reason, too).
+          #
+          # Normally, ActionView only looks for partials in files starting with an underscore. We
+          # do want to allow this, too (in the above case, if you define the widget in the file
+          # <tt>app/views/foo/_bar.rb</tt>, it will still work fine); however, we also want to allow
+          # you to define it in a file that does _not_ start with an underscore ('cause these are
+          # Ruby classes, and that's just plain weird).
+          #
+          # So, we patch #find_templates: if it's looking for a partial, doesn't find one, and is
+          # searching Fortitude templates (the +.rb+ handler), then we try again, turning off the
+          # +partial+ flag, and return that instead.
+          def find_templates_uniwith_fortitude(original_method, name, prefix, partial, details, *args)
+            templates = original_method.call(name, prefix, partial, details, *args)
             if partial && templates.empty? && details[:handlers] && details[:handlers].include?(:rb)
-              templates = find_templates_without_fortitude(name, prefix, false, details.merge(:handlers => [ :rb ]))
+              templates = original_method.call(name, prefix, false, details.merge(:handlers => [ :rb ]), *args)
             end
             templates
           end
-
-          alias_method_chain :find_templates, :fortitude
         end
 
+        ::Fortitude::MethodOverriding.override_methods(
+          ::ActionView::PathResolver, ActionViewPathResolverOverrides, :fortitude, [ :find_templates ])
+
         require "fortitude/rails/template_handler"
         require "fortitude/rails/rendering_methods"
 
-        ::ActionController::Base.send(:include, ::Fortitude::Rails::RenderingMethods)
-        ::ActionMailer::Base.send(:include, ::Fortitude::Rails::RenderingMethods)
+        ::Fortitude::Rails::RenderingMethods.include_into!(::ActionController::Base)
+        ::Fortitude::Rails::RenderingMethods.include_into!(::ActionMailer::Base)
       end
     end
   end