fortitude 0.9.4 → 0.9.5

data/lib/fortitude/rails/renderer.rb

@@ -10,6 +10,21 @@ module Fortitude
   module Rails
     class Renderer
       class << self
+        def render_file(template_identifier, view_paths, template_handler, local_assigns, &block)
+          expanded_view_paths = view_paths.map do |path|
+            File.expand_path(path.to_s, ::Rails.root.to_s)
+          end
+
+          valid_base_classes = [ ::Fortitude::Widget, ::Fortitude::Erector.erector_widget_base_class_if_available ].compact
+
+          widget_class = ::Fortitude::Widget.widget_class_from_file(template_identifier,
+            :root_dirs => expanded_view_paths, :valid_base_classes => valid_base_classes)
+
+          is_partial = !! File.basename(template_identifier) =~ /^_/
+
+          render(widget_class, template_handler, local_assigns, is_partial, &block)
+        end
+
         # TODO: Refactor this and render :widget => ... support into one method somewhere.
         def render(widget_class, template_handler, local_assigns, is_partial, &block)
           if ::Fortitude::Erector.is_erector_widget_class?(widget_class)

data/lib/fortitude/rails/rendering_methods.rb

@@ -6,8 +6,12 @@ module Fortitude
     module RenderingMethods
       extend ActiveSupport::Concern
 
-      included do
-        alias_method_chain :render, :fortitude
+      class << self
+        def include_into!(target)
+          target.send(:include, self)
+          ::Fortitude::MethodOverriding.override_methods(
+            target, ::Fortitude::Rails::RenderingMethods::Overrides, :fortitude, [ :render ])
+        end
       end
 
       def fortitude_rendering_context_for(delegate_object, yield_block)
@@ -48,55 +52,64 @@ module Fortitude
 
         passed_options = options.dup
         passed_options.delete(:widget)
-        passed_options[:text] = output_buffer.to_s
+
+        output_key = if ::Rails.version =~ /^(3\.)|(4\.0\.)/ then :text else :html end
+        passed_options[output_key] = output_buffer.to_s
         passed_options[:layout] = true unless passed_options.has_key?(:layout)
 
         return controller.render_to_string(passed_options)
       end
 
       def self._fortitude_register_renderer!
-        ::ActionController.add_renderer_without_fortitude(:widget) do |widget, options|
+        ::ActionController.add_renderer(:_fortitude_widget) do |widget, options|
           ::Fortitude::Rails::RenderingMethods._fortitude_render_widget(self, widget, options)
         end
       end
 
-      def render_with_fortitude(*args, &block)
-        if (options = args[0]).kind_of?(Hash) && (widget_block = options[:inline]) && (options[:type] == :fortitude)
-          options.delete(:inline)
-
-          rendering_context = fortitude_rendering_context_for(self, nil)
-          widget_class = Class.new(Fortitude::Widgets::Html5)
-          widget_class.use_instance_variables_for_assigns(true)
-          widget_class.extra_assigns(:use)
-          widget_class.send(:define_method, :content, &widget_block)
-
-          assigns = { }
-          instance_variables.each do |ivar_name|
-            value = instance_variable_get(ivar_name)
-            assigns[$1.to_sym] = value if ivar_name =~ /^@([^_].*)$/
+      module Overrides
+        def render_uniwith_fortitude(original_method, *args, &block)
+          if (options = args[0]).kind_of?(Hash) && (widget_block = options[:inline]) && (options[:type] == :fortitude)
+            options.delete(:inline)
+
+            rendering_context = fortitude_rendering_context_for(self, nil)
+            widget_class = Class.new(Fortitude::Widgets::Html5)
+            widget_class.use_instance_variables_for_assigns(true)
+            widget_class.extra_assigns(:use)
+            widget_class.send(:define_method, :content, &widget_block)
+
+            assigns = { }
+            instance_variables.each do |ivar_name|
+              value = instance_variable_get(ivar_name)
+              assigns[$1.to_sym] = value if ivar_name =~ /^@([^_].*)$/
+            end
+            assigns = assigns.merge(options[:locals] || { })
+
+            widget = widget_class.new(assigns)
+            new_args = [ options.merge(:widget => widget) ] + args[1..-1]
+            return original_method.call(*new_args, &block)
           end
-          assigns = assigns.merge(options[:locals] || { })
 
-          widget = widget_class.new(assigns)
-          new_args = [ options.merge(:widget => widget) ] + args[1..-1]
-          return render_without_fortitude(*new_args, &block)
+          return original_method.call(*args, &block)
         end
+      end
 
-        return render_without_fortitude(*args, &block)
+      module ActionControllerOverrides
+        def add_renderer_uniwith_fortitude(original_method, key, *args, &block)
+          if key == :_fortitude_widget
+            original_method.call(:widget, *args, &block)
+          else
+            original_method.call(key, *args, &block)
+            ::Fortitude::Rails::RenderingMethods._fortitude_register_renderer!
+          end
+        end
       end
     end
   end
 end
 
-::ActionController.module_eval do
-  class << self
-    def add_renderer_with_fortitude(key, *args, &block)
-      add_renderer_without_fortitude(key, *args, &block)
-      ::Fortitude::Rails::RenderingMethods._fortitude_register_renderer!
-    end
-
-    alias_method_chain :add_renderer, :fortitude
-  end
-end
+eigenclass = ::ActionController.class_eval "class << self; self; end"
+::Fortitude::MethodOverriding.override_methods(
+  eigenclass, ::Fortitude::Rails::RenderingMethods::ActionControllerOverrides, :fortitude,
+    [ :add_renderer ])
 
 ::Fortitude::Rails::RenderingMethods._fortitude_register_renderer!

data/lib/fortitude/rails/template_handler.rb

@@ -4,34 +4,65 @@ module Fortitude
   module Rails
     class TemplateHandler
       def call(template, &block)
-        widget_class_name = "views/#{template.identifier =~ %r(views/([^.]*)(\..*)?\.rb) && $1}".camelize
-        is_partial = !! (File.basename(template.identifier) =~ /^_/)
+        # This is a little funny. Under almost every single circumstance, we can, at template-compile time, deduce
+        # what class is inside the template file, and simply call Fortitude::Rails::Renderer.render with that class.
+        #
+        # However, there is one case under which we can't: if you've added to the view paths in the controller
+        # (using something like +append_view_path+), the template you're rendering is in an added view path,
+        # *and* that template has an "un-guessable" class name -- meaning you're doing something seriously strange
+        # in its source code. (See the view_paths_system_spec's test case with an "impossible-to-guess name" for the
+        # exact circumstances.) Under that case, the only way everything can work completely correctly is if we
+        # delay trying to figure out the class name from the template filename until rendering time, when we'll have
+        # the view paths available.
+        #
+        # This second path, however, is slower, because it has to do I/O to figure out that class name. (This adds
+        # about 1ms on my 2013 MacBook Pro with SSD.) So, we try the fast path first, and only fall back to the slow
+        # path if absolutely necessary.
+        expanded_view_paths = ::Rails.application.paths['app/views'].map { |path| File.expand_path(path.to_s, ::Rails.root.to_s) }
+        valid_base_classes = [ ::Fortitude::Widget, ::Fortitude::Erector.erector_widget_base_class_if_available ].compact
+        is_partial = !! File.basename(template.identifier) =~ /^_/
 
-        <<-SRC
-        Fortitude::Rails::Renderer.render(#{widget_class_name}, self, local_assigns, #{is_partial.inspect}) { |*args| yield *args }
-        SRC
+        widget_class = nil
+
+        begin
+          widget_class = ::Fortitude::Widget.widget_class_from_file(template.identifier.to_s,
+            :root_dirs => expanded_view_paths, :valid_base_classes => valid_base_classes)
+
+          <<-SRC
+          Fortitude::Rails::Renderer.render(#{widget_class.name}, self, local_assigns, #{is_partial.inspect}) { |*args| yield *args }
+          SRC
+        rescue Fortitude::Widget::Files::CannotDetermineWidgetClassNameError => cdwcne
+          <<-SRC
+          Fortitude::Rails::Renderer.render_file(#{template.identifier.to_s.inspect}, view_paths, self, local_assigns) { |*args| yield *args }
+          SRC
+        end
       end
 
       def supports_streaming?
         true
       end
-    end
-  end
-end
 
-::ActionView::Template.class_eval do
-  class << self
-    def _fortitude_register_template_handler!
-      register_template_handler_without_fortitude(:rb, Fortitude::Rails::TemplateHandler.new)
+      class << self
+        def register!
+          ::ActionView::Template.register_template_handler(:rb, ::Fortitude::Rails::TemplateHandler.new)
+        end
+      end
     end
 
-    def register_template_handler_with_fortitude(*args, &block)
-      register_template_handler_without_fortitude(*args, &block)
-      ActionView::Template._fortitude_register_template_handler!
-    end
+    module RegisterTemplateHandlerOverrides
+      def register_template_handler_uniwith_fortitude(original_method, *args, &block)
+        original_method.call(*args, &block)
 
-    alias_method_chain :register_template_handler, :fortitude
+        unless args[0] == :rb && args[1].instance_of?(::Fortitude::Rails::TemplateHandler)
+          original_method.call(:rb, ::Fortitude::Rails::TemplateHandler.new)
+        end
+      end
+    end
   end
 end
 
-ActionView::Template._fortitude_register_template_handler!
+eigenclass = ::ActionView::Template.class_eval "class << self; self; end"
+::Fortitude::MethodOverriding.override_methods(
+  eigenclass, ::Fortitude::Rails::RegisterTemplateHandlerOverrides, :fortitude, [ :register_template_handler ])
+
+::Fortitude::Rails::TemplateHandler.register!

data/lib/fortitude/rails/yielded_object_outputter.rb

@@ -4,8 +4,9 @@ module Fortitude
     class YieldedObjectOutputter < YIELDED_OBJECT_OUTPUTTER_SUPERCLASS
       class << self
         def wrap_block_as_needed(output_target, for_method_name, original_block, yielded_methods_to_output)
-          if original_block && yielded_methods_to_output
-            lambda do |yielded_object, *args|
+          if original_block && yielded_methods_to_output && original_block.arity > 0
+            lambda do |*args|
+              yielded_object = args.shift
               outputter = new(output_target, yielded_object, for_method_name, yielded_methods_to_output)
               original_block.call(outputter, *args)
             end

data/lib/fortitude/rendering_context.rb

@@ -5,6 +5,12 @@ module Fortitude
   class RenderingContext
     attr_reader :output_buffer_holder, :instance_variable_set, :helpers_object
 
+    class << self
+      def default_rendering_context
+        new({ })
+      end
+    end
+
     def initialize(options)
       options.assert_valid_keys(:delegate_object, :output_buffer_holder, :helpers_object, :instance_variables_object,
         :yield_block, :render_yield_result)
@@ -188,11 +194,14 @@ module Fortitude
 
     NEWLINE = "\n"
 
-    def yield_from_widget(widget, *args)
-      raise Fortitude::Errors::NoBlockToYieldTo.new(widget) unless @yield_block
-      result = @yield_block.call(*args)
-      @output_buffer_holder.output_buffer << result if @render_yield_result
-      result
+    def effective_yield_block
+      if @yield_block
+        lambda do |*args|
+          result = @yield_block.call(*args)
+          @output_buffer_holder.output_buffer << result if @render_yield_result
+          result
+        end
+      end
     end
 
     def flush!

data/lib/fortitude/support/method_overriding.rb

@@ -0,0 +1,90 @@
+module Fortitude
+  module MethodOverriding
+    class << self
+      # This is Fortitude’s way of maintaining compatibility both with Ruby < 2.0 (no support for Module#prepend)
+      # and Ruby 2.0 and later (alias_method_chain is deprecated). Here’s how it works:
+      #
+      # * For a method 'foo' that you want to override using a 'feature name' of bar, you define a method called
+      #   'foo_uniwith_bar' -- but not in the target module or class (containing the method to be overridden); rather,
+      #   it must be in a separate Module, and, importantly, not one that you have already Module#include'd into the
+      #   target module or class. This method has the same signature as the original, except that it also takes, as a first
+      #   parameter, a #call'able object (typically a Proc or lambda) that represents the original, un-overridden
+      #   method. You use this, instead of calling 'foo_without_bar' or 'super', in order to invoke the original
+      #   method.
+      # * You then call Fortitude::MethodOverriding.override_methods. +target_module+ is the module containing the
+      #   method you want to override, +override_methods_module+ is the module containing your overriding method
+      #   ('foo_uniwith_bar'), +feature_name+ is the name of the feature you're using ('bar'), and +method_names+
+      #   is an Array of Symbols, each of which is the name of a method you want to override (_e.g._, 'foo').
+      #
+      # This class then performs the appropriate logic to use 'alias_method_chain' or Module#prepend appropriately.
+      #
+      # One exception: using Module#prepend seems to cause Fortitude all kinds of problems with JRuby 9.1.5.0 (as of
+      # this writing, the latest version of JRuby). In particular, you get things like a java.lang.BootstrapMethodError
+      # at "require at org/jruby/RubyKernel.java:956", and various java.lang.StackOverflowErrors that seem to make no
+      # sense at all -- and if you use alias_method_chain instead, everything seems to work perfectly. As a result,
+      # we currently fall back to using alias_method_chain on JRuby. (You only get deprecation warnings with this
+      # when running with Rails 5, which is not yet supported by JRuby anyway, at least as of this writing.)
+      def override_methods(target_module, override_methods_module, feature_name, method_names)
+        if RUBY_VERSION =~ /^2\./ && (! ((RUBY_ENGINE || '').to_s.downcase.strip == 'jruby'))
+          override_methods_using_prepend(target_module, override_methods_module, feature_name, method_names)
+        else
+          override_methods_using_alias_method_chain(target_module, override_methods_module, feature_name, method_names)
+        end
+      end
+
+      private
+      def override_methods_using_prepend(target_module, override_methods_module, feature_name, method_names)
+        method_names.each do |method_name|
+          universal_name = universal_method_name(method_name, feature_name)
+
+          override_methods_module.class_eval <<-EOS
+  def #{method_name}(*args, &block)
+    original_method = Proc.new { |*args, &block| super(*args, &block) }
+    #{universal_name}(original_method, *args, &block)
+  end
+EOS
+        end
+
+        target_module.send(:prepend, override_methods_module)
+      end
+
+      def override_methods_using_alias_method_chain(target_module, override_methods_module, feature_name, method_names = nil)
+        method_names.each do |method_name|
+          universal_name = universal_method_name(method_name, feature_name)
+          with_name = with_feature_name(method_name, feature_name)
+          without_name = without_feature_name(method_name, feature_name)
+
+          override_methods_module.class_eval <<-EOS
+  def #{with_name}(*args, &block)
+    original_method = Proc.new { |*args, &block| #{without_name}(*args, &block) }
+    #{universal_name}(original_method, *args, &block)
+  end
+EOS
+
+          target_module.send(:include, override_methods_module)
+          target_module.send(:alias_method_chain, method_name, feature_name)
+        end
+      end
+
+      def suffix_method_name(method_name, suffix)
+        if method_name.to_s =~ /^(.*?)([\?\_\!]+)$/i
+          "#{$1}#{suffix}#{$2}"
+        else
+          "#{method_name}#{suffix}"
+        end
+      end
+
+      def with_feature_name(method_name, feature_name)
+        suffix_method_name(method_name, "_with_#{feature_name}")
+      end
+
+      def without_feature_name(method_name, feature_name)
+        suffix_method_name(method_name, "_without_#{feature_name}")
+      end
+
+      def universal_method_name(method_name, feature_name)
+        suffix_method_name(method_name, "_uniwith_#{feature_name}")
+      end
+    end
+  end
+end

data/lib/fortitude/support/staticized_method.rb

@@ -28,6 +28,18 @@ module Fortitude
       end
 
       def create_method!
+        begin
+          widget_class.instance_method(method_name)
+        rescue NameError => ne
+          raise NameError, %{You declared the method #{method_name.inspect} in class
+#{widget_class.name.inspect} to be a Fortitude static content method,
+but there is no method declared on this class with that name.
+
+(It's possible you simply tried to declare the method static before
+it was defined on that class -- the call to 'static' must come
+_after_ the definition of the method in the class's source code.)}
+        end
+
         unless widget_class.instance_methods.map(&:to_s).include?(dynamic_method_name.to_s)
           widget_class.send(:alias_method, dynamic_method_name, method_name)
         end

data/lib/fortitude/version.rb

@@ -1,3 +1,3 @@
 module Fortitude
-  VERSION = "0.9.4"
+  VERSION = "0.9.5"
 end

data/lib/fortitude/widget/content.rb

@@ -13,8 +13,8 @@ module Fortitude
           out
         end
 
-        def inline_html(assigns = { }, &block)
-          inline_subclass(&block).new(assigns).to_html
+        def inline_html(assigns = { }, rendering_context = nil, &block)
+          inline_subclass(&block).new(assigns).to_html(rendering_context)
         end
 
         # INTERNAL USE ONLY
@@ -43,6 +43,8 @@ module Fortitude
               text += "  " + ("  " * (acm.length - (index + 1))) + "end\n"
             end
             text += "  out\n"
+            text += "rescue LocalJumpError => lje\n"
+            text += "  raise Fortitude::Errors::NoBlockToYieldTo.new(self, lje)\n"
             text += "end"
 
             class_eval(text)

data/lib/fortitude/widget/files.rb

@@ -41,7 +41,7 @@ or add a "magic comment" to the source code of this widget that looks like this:
 
       module ClassMethods
         def widget_class_from_file(filename, options = { })
-          options.assert_valid_keys(:root_dirs, :class_names_to_try, :magic_comment_text)
+          options.assert_valid_keys(:root_dirs, :class_names_to_try, :magic_comment_text, :valid_base_classes)
           filename = File.expand_path(filename)
           source = File.read(filename)
 
@@ -53,18 +53,18 @@ or add a "magic comment" to the source code of this widget that looks like this:
 
             if filename[0..(root_dir.length - 1)].downcase == root_dir.downcase
               subpath = filename[(root_dir.length + 1)..-1]
-              subpath = $1 if subpath =~ /^(.*)\.rb$/i
+              subpath = $1 if subpath =~ %r{^(.*?)\.[^/]+$}i # remove all extensions
               class_names_to_try << subpath.camelize if subpath && subpath.length > 1
             end
           end
 
           widget_class_from_source(source,
             :class_names_to_try => class_names_to_try, :magic_comment_text => options[:magic_comment_text],
-            :filename => filename)
+            :filename => filename, :valid_base_classes => options[:valid_base_classes])
         end
 
         def widget_class_from_source(source, options = { })
-          options.assert_valid_keys(:class_names_to_try, :magic_comment_text, :filename)
+          options.assert_valid_keys(:class_names_to_try, :magic_comment_text, :filename, :valid_base_classes)
 
           magic_comment_texts = Array(options[:magic_comment_text]) + DEFAULT_MAGIC_COMMENT_TEXTS
           all_class_names =
@@ -72,7 +72,7 @@ or add a "magic comment" to the source code of this widget that looks like this:
             Array(options[:class_names_to_try]) +
             scan_source_for_possible_class_names(source)
 
-          out = widget_class_from_class_names(all_class_names)
+          out = widget_class_from_class_names(all_class_names, :valid_base_classes => options[:valid_base_classes])
           resulting_objects = out[:resulting_objects]
 
           unless out[:widget_class]
@@ -82,7 +82,7 @@ or add a "magic comment" to the source code of this widget that looks like this:
               ::Object.class_eval(source)
             end
 
-            out = widget_class_from_class_names(all_class_names)
+            out = widget_class_from_class_names(all_class_names, :valid_base_classes => options[:valid_base_classes])
             resulting_objects += out[:resulting_objects]
           end
 
@@ -133,7 +133,9 @@ or add a "magic comment" to the source code of this widget that looks like this:
           out
         end
 
-        def widget_class_from_class_names(class_names)
+        def widget_class_from_class_names(class_names, options = { })
+          options.assert_valid_keys(:valid_base_classes)
+
           out = {
             :widget_class      => nil,
             :resulting_objects => [ ]
@@ -147,7 +149,7 @@ or add a "magic comment" to the source code of this widget that looks like this:
               nil
             end
 
-            if is_widget_class?(klass)
+            if is_widget_class?(klass, options)
               out[:widget_class] = klass
               break
             elsif klass
@@ -157,15 +159,19 @@ or add a "magic comment" to the source code of this widget that looks like this:
           out
         end
 
-        def is_widget_class?(klass)
+        def is_widget_class?(klass, options = { })
+          options.assert_valid_keys(:valid_base_classes)
+
+          valid_base_classes = Array(options[:valid_base_classes] || ::Fortitude::Widget)
+
           if (! klass)
             false
           elsif (! klass.kind_of?(Class))
             false
-          elsif klass == ::Fortitude::Widget
+          elsif valid_base_classes.include?(klass)
             true
           else
-            is_widget_class?(klass.superclass)
+            is_widget_class?(klass.superclass, :valid_base_classes => valid_base_classes)
           end
         end
       end