fortitude 0.9.4 → 0.9.5

data/lib/fortitude/widget/helpers.rb

@@ -41,10 +41,16 @@ module Fortitude
               "effective_block = block"
             end
 
+            call_part = if source_method_name.to_s =~ /\=\s*$/
+              ".send(:#{source_method_name}, "
+            else
+              ".#{source_method_name}("
+            end
+
             text = <<-EOS
     def #{name}(*args, &block)
       #{block_transform}
-      #{prefix}(@_fortitude_rendering_context.helpers_object.#{source_method_name}(*args, &effective_block))#{suffix}
+      #{prefix}(@_fortitude_rendering_context.helpers_object#{call_part}*args, &effective_block))#{suffix}
     end
 EOS
 

data/lib/fortitude/widget/integration.rb

@@ -98,6 +98,10 @@ module Fortitude
           end
         end
 
+        _fortitude_on_class_inheritable_attribute_change(:translation_base) do |attribute_name, old_value, new_value|
+          ::Fortitude::Widget._fortitude_ensure_translation_base_supported_if_needed!
+        end
+
         _fortitude_on_class_inheritable_attribute_change(:start_and_end_comments) do |attribute_name, old_value, new_value|
           if new_value
             around_content :start_and_end_comments

data/lib/fortitude/widget/localization.rb

@@ -8,13 +8,72 @@ module Fortitude
 
       LOCALIZED_CONTENT_PREFIX = "localized_content_"
 
-      # PUBLIC API
-      def t(key, *args)
+      # We do some funny voodoo here, for performance reasons. In localized Rails applications, #t
+      # ("translate this string") is called a LOT. Even small slowdowns in its performance can have a big impact.
+      # As such, we work hard to make this go fast.
+      #
+      # We'd like to support our .translation_base method, which prepends a translation base to any keys passed to #t
+      # that aren't globally specified (e.g., ".foo.bar", not "foo.bar"), but with as little overhead as possible.
+      # (Most people won't use that feature.) So here's what we do:
+      #
+      # - We create one method, #_fortitude_t_without_translation_base, that simply passes through to the helper
+      #   method #t on whatever our helpers object is. This is the "fast" method.
+      # - We create a second method, #_fortutude_t_with_translation_base, that checks the translation_base and applies
+      #   it as needed before calling through to the method #t on whatever our helpers object is. This is the "slow"
+      #   method.
+      # - By default, we alias the fast method to #t. However, we also have a callback whenever translation_base
+      #   is changed (_fortitude_on_class_inheritable_attribute_change(:translation_base), in
+      #   lib/fortitude/widget/integration.rb) that calls our class method
+      #   _fortitude_ensure_translation_base_supported_if_needed!. In turn, that checks recursively to see if _any_
+      #   widget is using the translation_base feature, and, if so, aliases the slow method to #t -- otherwise, it
+      #   aliases the fast method to #t.
+      #
+      # The net result is that we only have to use the slow method if anybody's actually using the translation_base
+      # feature. Otherwise, we can use the fast method. While both of them are plenty "fast" according to most
+      # standards, the difference in performance between them is significant enough (~10-15%) that it makes sense
+      # to perform this optimization. Again, real-world localized Rails applications call #t a _lot_.
+
+      # INTERNAL USE ONLY
+      def _fortitude_t_with_translation_base(key, *args)
         base = self.class.translation_base
         if base && key.to_s =~ /^\./
-          super("#{base}#{key}", *args)
+          invoke_helper(:t, "#{base}#{key}", *args)
         else
-          super(key, *args)
+          invoke_helper(:t, key, *args)
+        end
+      end
+
+      # INTERNAL USE ONLY
+      def _fortitude_t_without_translation_base(*args)
+        invoke_helper(:t, *args)
+      end
+
+      # PUBLIC API
+      alias_method :t, :_fortitude_t_without_translation_base
+
+      module ClassMethods
+        # INTERNAL USE ONLY
+        def _fortitude_ensure_translation_base_supported_if_needed!
+          unless equal?(::Fortitude::Widget)
+            raise ArgumentError, "You must only ever call this on Fortitude::Widget, not #{self}"
+          end
+
+          if _fortitude_translation_base_support_needed?
+            alias_method :t, :_fortitude_t_with_translation_base
+          else
+            alias_method :t, :_fortitude_t_without_translation_base
+          end
+        end
+
+        # INTERNAL USE ONLY
+        def _fortitude_translation_base_support_needed?
+          _fortitude_translation_base_support_needed_for_this_class? ||
+            (direct_subclasses.any?(&:_fortitude_translation_base_support_needed?))
+        end
+
+        # INTERNAL USE ONLY
+        def _fortitude_translation_base_support_needed_for_this_class?
+          translation_base && translation_base.to_s.strip.length > 0
         end
       end
 

data/lib/fortitude/widget/rendering.rb

@@ -28,11 +28,9 @@ module Fortitude
         @_fortitude_output_buffer_holder = rendering_context.output_buffer_holder
         @_fortitude_block_for_content_method = block_for_content_method
 
-        block = lambda { |*args| yield_from_widget(*args) }
-
         rendering_context.record_widget(self) do
           begin
-            run_content(&block)
+            run_content(&_fortitude_run_content_block)
           ensure
             @_fortitude_rendering_context = nil
             @_fortitude_block_for_content_method = nil
@@ -41,7 +39,8 @@ module Fortitude
       end
 
       # PUBLIC API
-      def to_html(rendering_context = ::Fortitude::RenderingContext.new({ }))
+      def to_html(rendering_context = nil)
+        rendering_context ||= ::Fortitude::RenderingContext.default_rendering_context
         render_to(rendering_context)
         rendering_context.output_buffer_holder.output_buffer
       end
@@ -111,24 +110,32 @@ module Fortitude
       end
       private :_fortitude_class_for_new_buffer
 
-      def _fortitude_yield_from_widget(*args)
+      # INTERNAL USE ONLY
+      def _fortitude_run_content_block
         if @_fortitude_block_for_content_method
-          @_fortitude_block_for_content_method.call(*args)
+          @_fortitude_block_for_content_method
         elsif @_fortitude_constructor_block
-          @_fortitude_constructor_block.call(self, *args)
+          lambda { |*args| @_fortitude_constructor_block.call(self, *args) }
+        elsif @_fortitude_rendering_context.effective_yield_block
+          @_fortitude_rendering_context.effective_yield_block
         else
-          @_fortitude_rendering_context.yield_from_widget(self, *args)
+          nil
         end
       end
 
       # PUBLIC API
       def yield_from_widget(*args)
-        _fortitude_yield_from_widget(*args)
+        block = _fortitude_run_content_block
+        if block
+          block.call(*args)
+        else
+          raise Fortitude::Errors::NoBlockToYieldTo.new(self)
+        end
       end
 
       # PUBLIC API (Erector compatibility)
       def call_block
-        _fortitude_yield_from_widget
+        yield_from_widget
       end
     end
   end

data/spec/helpers/fortitude_rails_helpers.rb

@@ -5,15 +5,37 @@ module Spec
         @rails_server_project_root ||= File.expand_path(File.join(File.dirname(__FILE__), '../..'))
       end
 
-      def rails_server_additional_gemfile_lines
-        [
-          "gem 'fortitude', :path => '#{rails_server_project_root}'"
-        ]
+      def rails_server_gemfile_modifier
+        Proc.new do |gemfile|
+          gemfile.set_specs!('fortitude', :path => rails_server_project_root)
+        end
       end
 
       def rails_server_default_version
         ENV['FORTITUDE_SPECS_RAILS_VERSION']
       end
+
+      def rails_server_wraps_template_errors?
+        !! (rails_server.actual_rails_version =~ /^5\./)
+      end
+
+      def expect_actionview_exception(subpath, class_name, message)
+        actual_class_expected = if rails_server_wraps_template_errors?
+          'ActionView::Template::Error'
+        else
+          class_name
+        end
+
+        hash = expect_exception(subpath, actual_class_expected, message)
+
+        if rails_server_wraps_template_errors?
+          cause = hash['exception']['cause']
+          expect(cause).to be
+          expect(cause['class']).to eq(class_name.to_s)
+        end
+
+        hash
+      end
     end
   end
 end

data/spec/rails/capture_system_spec.rb

@@ -23,7 +23,7 @@ describe "Rails capture support", :type => :rails do
   end
 
   it "should be able to provide content in a widget with provide" do
-    skip "Rails 3.0.x doesn't support :provide" if rails_server.rails_version =~ /^3\.0\./
+    skip "Rails 3.0.x doesn't support :provide" if rails_server.actual_rails_version =~ /^3\.0\./
 
     expect_match('widget_provide',
       %r{erb_layout_needing_content}i,

data/spec/rails/class_loading_system_spec.rb

@@ -12,6 +12,9 @@ describe "Rails class-loading support", :type => :rails do
   it "should not create anonymous modules without the Views:: namespace for directories under app/views/" do
     expect_exception('some_namespace', 'NameError', /uninitialized constant SomeNamespace/)
     expect_exception('some_other_namespace', 'NameError', /uninitialized constant SomeNamespace/)
+  end
+
+  it "should create anonymous modules in the Views:: namespace for directories under app/views/" do
     expect_match('views_some_namespace', /Views::SomeNamespace/, :no_layout => true)
     expect_match('views_some_other_namespace', /Views::SomeNamespace::SomeOtherNamespace/, :no_layout => true)
   end
@@ -32,12 +35,23 @@ describe "Rails class-loading support", :type => :rails do
     expect_match('use_models_widget_from_view_widget', /about to run the models widget.*this is the models widget.*ran the models widget/)
   end
 
+  def expect_no_template_error(subpath, controller_name, view_name)
+    # Rails 5 changed this: see https://github.com/rails/rails/issues/20666, https://github.com/rails/rails/issues/19036.
+    if rails_server.actual_rails_version =~ /^5\./
+      regexp = /#{(controller_name + "_controller").camelize}##{view_name.underscore}/
+      expect_exception(subpath, 'ActionController::UnknownFormat', regexp)
+    else
+      regexp = /#{controller_name.underscore}\/#{view_name.underscore}/
+      expect_exception(subpath, 'ActionView::MissingTemplate', regexp)
+    end
+  end
+
   it "should not allow me to define widgets outside of app/views/" do
-    expect_exception('widget_defined_outside_app_views', 'ActionView::MissingTemplate', /class_loading_system_spec\/widget_defined_outside_app_views/)
+    expect_no_template_error('widget_defined_outside_app_views', 'class_loading_system_spec', 'widget_defined_outside_app_views')
   end
 
   it "should not let me define a widget in a file starting with an underscore, and use it for a view" do
-    expect_exception('underscore_view', 'ActionView::MissingTemplate', /class_loading_system_spec\/underscore_view/)
+    expect_no_template_error('underscore_view', 'class_loading_system_spec', 'underscore_view')
   end
 
   it "should prefer widgets defined in a file without an underscore to those with" do

data/spec/rails/complex_helpers_system_spec.rb

@@ -38,6 +38,35 @@ describe "Rails complex helper support", :type => :rails do
         OUTSIDE_AFTER}mix)
   end
 
+  it "should render a block passed to a label correctly" do
+    # See https://stackoverflow.com/questions/6088348/passing-block-to-label-helper-in-rails3.
+    #
+    # With a brand-new install of Rails 3.1.12, and *without* Fortitude installed, the following ERb code:
+    #
+    # <%= form_for :person do |f| %>
+    #   <%= f.label(:name) do %>
+    #      Foo
+    #   <% end %>
+    # <% end %>
+    #
+    # ...results in the following output:
+    #
+    # Foo
+    # <label for="person_name">
+    # Foo
+    # </label></form>
+    #
+    # ...which is clearly incorrect. (In other words, the inner 'Foo' gets generated and picked up twice.)
+    #
+    # In Rails 3.2 and after, this has been fixed, and works perfectly.
+    skip "Rails 3.0/3.1 have a bug with blocks passed to form_for->label" if rails_server.actual_rails_version =~ /^3\.[01]\./
+
+    expect_match("label_block_test",
+      %r{<label.*person_name.*>\s*
+        Foo\s*
+        </label>}mix)
+  end
+
   it "should cache based on a name properly" do
     expect_match("cache_test?a=a1&b=b1",
       /before_cache\(a1,b1\).*inside_cache\(a1,b1\).*after_cache\(a1,b1\)/mi)

data/spec/rails/data_passing_system_spec.rb

@@ -18,7 +18,7 @@ describe "Rails data-passing support", :type => :rails do
   end
 
   it "should give you a reasonable error if you omit a variable" do
-    expect_exception('omitted_variable', 'Fortitude::Errors::MissingNeed', /bar/)
+    expect_actionview_exception('omitted_variable', 'Fortitude::Errors::MissingNeed', /bar/)
   end
 
   it "should not propagate un-needed variables" do
@@ -34,7 +34,7 @@ describe "Rails data-passing support", :type => :rails do
   end
 
   it "should not propagate a controller variable through a view to a child widget without being explicitly passed" do
-    expect_exception('parent_to_child_passing', 'Fortitude::Errors::MissingNeed', /foo/)
+    expect_actionview_exception('parent_to_child_passing', 'Fortitude::Errors::MissingNeed', /foo/)
   end
 
   it "should propagate a controller variable through a view to a child widget without being explicitly passed, if invoked using render :partial" do

data/spec/rails/development_mode_system_spec.rb

@@ -17,7 +17,7 @@ describe "Rails development-mode support", :type => :rails do
     expect_match("reload_widget_with_html_extension", /with_html_extension.*helper: yo/)
     sleep 1
     splat_new_module_for_reload_widget_failing!
-    expect_exception("reload_widget_with_html_extension", NameError, "some_helper")
+    expect_actionview_exception("reload_widget_with_html_extension", NameError, "some_helper")
     sleep 1
     splat_new_module_for_reload_widget!
     expect_match("reload_widget_with_html_extension", /with_html_extension.*helper: yo/)

data/spec/rails/erector_coexistence_system_spec.rb

@@ -1,5 +1,5 @@
 describe "Erector coexistence support", :type => :rails do
-  uses_rails_with_template :erector_coexistence_system_spec, :additional_gemfile_lines => "gem 'erector'"
+  uses_rails_with_template :erector_coexistence_system_spec, :additional_gemfile_modifier => Proc.new { |gemfile| gemfile.ensure_gem!("erector") }
 
   begin
     gem 'erector'

data/spec/rails/helpers_system_spec.rb

@@ -2,12 +2,30 @@ describe "Rails helper support", :type => :rails do
   uses_rails_with_template :helpers_system_spec
 
   it "should support the built-in Rails helpers by default" do
+    skip("Rails 3.1 fails on this test with Ruby 2.3 only") if rails_server.actual_rails_version =~ /^3\.1\./ && RUBY_VERSION =~ /^2\.3\./
     expect_match("basic_helpers",
       /Three months ago: 3 months/mi,
       /A million dollars: \$1,000,000\.00/mi,
       %r{Select datetime:\s*<select.*name="date.*>.*<option.*value="2014".*</option>}mi)
   end
 
+  it 'should support built-in Rails helpers even when automatic_helper_access is false' do
+    expect_match("rails_helpers_without_automatic_helper_access",
+                 /Excitedly: NoMethodError/mi,
+                 /Three months ago: 3 months/mi,
+                 /A million dollars: \$1,000,000\.00/mi,
+                 /class=["']debug_dump["']/mi)
+  end
+
+  it 'should support url helpers even when automatic_helper_access is false' do
+    expect_match('url_helpers_without_automatic_helper_access',
+                 /Excitedly: NoMethodError/mi,
+                 /Root Path: \//,
+                 /Foo Path: \/foo/,
+                 /Foo Url: http:\/\/example.com(:\d+)?\/foo/,
+                 /Foo Url with host override: http:\/\/override.com(:\d+)?\/foo/)
+  end
+
   it "should refine the built-in Rails helpers by default" do
     expect_match("helpers_that_output_when_refined",
       %r{START.*<img.*src="http://example.com/foo".*/><a href="mailto:test@example.com">test@example.com</a><link.*href="http://example.com/bar".*/>END}mi)
@@ -65,11 +83,11 @@ describe "Rails helper support", :type => :rails do
   end
 
   it "should allow turning off automatic helper access" do
-    expect_match("automatic_helpers_disabled", %r{excitedly: NoMethodError; time_ago_in_words: NoMethodError; number_to_currency: \$1,000,000.00})
+    expect_match("automatic_helpers_disabled", %r{excitedly: NoMethodError; time_ago_in_words: 3 months; number_to_currency: \$1,000,000.00})
   end
 
   it "should inherit automatic helper access properly" do
-    expect_match("automatic_helpers_inheritance", %r{C1: excitedly: NoMethodError; time_ago_in_words: NoMethodError; number_to_currency: \$1,000,000.00.*C2: excitedly: awesome!!!; time_ago_in_words: 3 months; number_to_currency: \$1,000,000.00})
+    expect_match("automatic_helpers_inheritance", %r{C1: excitedly: NoMethodError; time_ago_in_words: 3 months; number_to_currency: \$1,000,000.00.*C2: excitedly: awesome!!!; time_ago_in_words: 3 months; number_to_currency: \$1,000,000.00})
   end
 
   it "should allow access to private helpers in exactly the same way as ERb" do

data/spec/rails/layouts_system_spec.rb

@@ -41,7 +41,7 @@ describe "Rails layout support", :type => :rails do
   end
 
   it "should let you turn off the layout with render :widget" do
-    unless rails_server.rails_version =~ /^3\.[01]\./
+    unless rails_server.actual_rails_version =~ /^3\.[01]\./
       # Rails 3.0 and 3.1 simply don't pass the ":layout => false" option specified in the controller through to
       # the renderer we add using ::ActionController.add_renderer. There's really nothing we can do about this,
       # so we let this one particular case fail; it seems like a bug in Rails, not in our code.

data/spec/rails/rendering_system_spec.rb

@@ -37,7 +37,7 @@ describe "Rails rendering support", :type => :rails do
     end
 
     it "should let you omit the layout with 'render :widget =>', if you ask for it" do
-      unless rails_server.rails_version =~ /^3\.[01]\./
+      unless rails_server.actual_rails_version =~ /^3\.[01]\./
         # Rails 3.0 and 3.1 simply don't pass the ":layout => false" option specified in the controller through to
         # the renderer we add using ::ActionController.add_renderer. There's really nothing we can do about this,
         # so we let this one particular case fail; it seems like a bug in Rails, not in our code.
@@ -53,12 +53,12 @@ describe "Rails rendering support", :type => :rails do
     end
 
     it "should let you render a widget with 'render \"foo\" and the full path'" do
-      skip "Rails 4.2 makes this mean something different (render :template, vs. render :file)" unless rails_server.rails_version =~ /^(3\.|4\.[01]\.)/
+      skip "Rails 4.1/4.2 makes this mean something different (render :template, vs. render :file)" unless rails_server.actual_rails_version =~ /^(3\.|4\.0\.)/
       expect_match("render_widget_via_file_path", /hello from a widget named Fred/)
     end
 
     it "should let you render a widget with 'render \"foo\"' and the template path" do
-      skip "Rails 4.2 enables this" if rails_server.rails_version =~ /^(3\.|4\.[01]\.)/
+      skip "Rails 4.2 enables this" if rails_server.actual_rails_version =~ /^(3\.|4\.[01]\.)/
       expect_match("render_widget_via_template_path", /hello, world/)
     end
 
@@ -194,7 +194,7 @@ describe "Rails rendering support", :type => :rails do
     end
 
     it "should let you stream from a widget that's in an ERb layout" do
-      skip("Fortitude streaming test is not supported under Rails 3.0.x") if rails_server.rails_version =~ /^3\.0\./
+      skip("Fortitude streaming test is not supported under Rails 3.0.x") if rails_server.actual_rails_version =~ /^3\.0\./
       skip("Fortitude streaming test is not supported under Ruby 1.8") if RUBY_VERSION =~ /^1\.8\./
 
       chunks = collect_chunks("stream_widget_with_layout")

data/spec/rails/rules_system_spec.rb

@@ -2,11 +2,11 @@ describe "Rails rules support", :type => :rails do
   uses_rails_with_template :rules_system_spec
 
   it "should be able to enforce tag-nesting rules in Rails" do
-    expect_exception('invalidly_nested_tag', Fortitude::Errors::InvalidElementNesting, /div/)
+    expect_actionview_exception('invalidly_nested_tag', Fortitude::Errors::InvalidElementNesting, /div/)
   end
 
   it "should still enforce tag-nesting rules inside a partial" do
-    expect_exception('invalidly_nested_tag_in_partial', Fortitude::Errors::InvalidElementNesting, /div/)
+    expect_actionview_exception('invalidly_nested_tag_in_partial', Fortitude::Errors::InvalidElementNesting, /div/)
   end
 
   it "should not enforce tag-nesting rules at the start of a partial rendered from ERb" do

data/spec/rails/templates/class_loading_system_spec/app/views/some_namespace/some_other_namespace/placeholder.rb

@@ -0,0 +1,5 @@
+class Views::SomeNamespace::SomeOtherNamespace::Placeholder < Fortitude::Widgets::Html5
+  def content
+    raise "this should never be called"
+  end
+end