fortitude 0.0.7 → 0.0.9

data/spec/rails/erector_coexistence_system_spec.rb

@@ -29,5 +29,21 @@ describe "Erector coexistence support", :type => :rails do
     it "should be able to render an Erector widget in app/v/views" do
       expect_match("erector_widget_in_app_v_views", /<p\s+class\s*=\s*"some_class"\s*>this is Erector: foo = quux<\/p>/)
     end
+
+    it "should be able to render a Fortitude widget using render :widget" do
+      expect_match("render_widget_fortitude", /this is a Fortitude widget/)
+    end
+
+    it "should be able to render an Erector widget using render :widget" do
+      expect_match("render_widget_erector", /this is an Erector widget/, :no_layout => true)
+    end
+
+    it "should be able to render a Fortitude widget with just a class using render :widget" do
+      expect_match("render_widget_fortitude_class", /this is a Fortitude widget/)
+    end
+
+    it "should be able to render an Erector widget with just a class using render :widget" do
+      expect_match("render_widget_erector_class", /this is an Erector widget/, :no_layout => true)
+    end
   end
 end

data/spec/rails/layouts_system_spec.rb

@@ -41,9 +41,14 @@ describe "Rails layout support", :type => :rails do
   end
 
   it "should let you turn off the layout with render :widget" do
-    data = get("render_widget_without_layout")
-    data.should_not match(/default_layout_erb/i)
-    data.should match(/this is the_render_widget/i)
+    unless rails_server.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 = get("render_widget_without_layout")
+      data.should_not match(/default_layout_erb/i)
+      data.should match(/this is the_render_widget/i)
+    end
   end
 
   it "should let you pick an alternate layout for render :widget" do

data/spec/rails/rendering_system_spec.rb

@@ -15,9 +15,31 @@ describe "Rails rendering support", :type => :rails do
       expect(data).to match(/oop_rails_server_base_template/)
     end
 
+    it "should always set a content-type of text/html when using 'render :widget'" do
+      response = get_response("render_widget")
+      expect(response['Content-Type']).to match(/^text\/html/)
+    end
+
+    it "should let you use view helpers from within a widget passed to 'render :widget =>'" do
+      expect_match("render_widget_with_helper", /hello from a widget named Judy/)
+    end
+
+    it "should let you specify just a widget class with 'render :widget =>'" do
+      expect_match("render_widget_class_only", /hello from a simple widget/)
+    end
+
+    it "should let you specify just a widget class with 'render :widget =>', and pass assigns to it" do
+      expect_match("render_widget_class_and_assigns", /hello from a widget named Yaravan/)
+    end
+
     it "should let you omit the layout with 'render :widget =>', if you ask for it" do
-      data = expect_match("render_widget_without_layout", /hello from a widget named Fred/, :no_layout => true)
-      expect(data).not_to match(/oop_rails_server_base_template/)
+      unless rails_server.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 = expect_match("render_widget_without_layout", /hello from a widget named Fred/, :no_layout => true)
+        expect(data).not_to match(/oop_rails_server_base_template/)
+      end
     end
 
     it "should set the Content-Type to text/html when using render :widget" do

data/spec/rails/templates/class_loading_system_spec/app/controllers/class_loading_system_spec_controller.rb

@@ -53,8 +53,12 @@ class ClassLoadingSystemSpecController < ApplicationController
     # nothing here
   end
 
-  def underscore_widget
-    render :text => Views::ClassLoadingSystemSpec::UnderscoreWidget.data
+  def foo
+    # nothing here
+  end
+
+  def bar
+    # nothing here
   end
 
   def require_loaded_underscore_widget_without_views

data/spec/rails/templates/class_loading_system_spec/app/views/class_loading_system_spec/_foo.rb

@@ -0,0 +1,5 @@
+class Views::ClassLoadingSystemSpec::Foo < Fortitude::Widgets::Html5
+  def content
+    p "foo WITH underscore"
+  end
+end

data/spec/rails/templates/class_loading_system_spec/app/views/class_loading_system_spec/bar.html.rb

@@ -0,0 +1,5 @@
+class Views::ClassLoadingSystemSpec::Bar < Fortitude::Widgets::Html5
+  def content
+    p "bar WITH html"
+  end
+end

data/spec/rails/templates/class_loading_system_spec/app/views/class_loading_system_spec/bar.rb

@@ -0,0 +1,5 @@
+class Views::ClassLoadingSystemSpec::Bar < Fortitude::Widgets::Html5
+  def content
+    p "bar WITHOUT html"
+  end
+end

data/spec/rails/templates/class_loading_system_spec/app/views/class_loading_system_spec/foo.rb

@@ -0,0 +1,5 @@
+class Views::ClassLoadingSystemSpec::Foo < Fortitude::Widgets::Html5
+  def content
+    p "foo WITHOUT underscore"
+  end
+end

data/spec/rails/templates/development_mode_system_spec/app/controllers/development_mode_system_spec_controller.rb

@@ -15,6 +15,10 @@ class DevelopmentModeSystemSpecController < ApplicationController
     # nothing here
   end
 
+  def edit
+    # nothing here
+  end
+
   def mailer_view_test
     DevelopmentModeMailer.mailer_view_test.deliver
   end

data/spec/rails/templates/development_mode_system_spec/app/views/base.rb

@@ -0,0 +1,5 @@
+module Views
+  class Base < Fortitude::Widget
+    doctype :html5
+  end
+end

data/spec/rails/templates/development_mode_system_spec/app/views/development_mode_system_spec/form.rb

@@ -0,0 +1,11 @@
+module Views
+  module DevelopmentModeSystemSpec
+    class Form < Views::Base
+      needs :label
+
+      def content
+        p(label)
+      end
+    end
+  end
+end

data/spec/rails/templates/erector_coexistence_system_spec/app/controllers/erector_coexistence_system_spec_controller.rb

@@ -16,4 +16,20 @@ class ErectorCoexistenceSystemSpecController < ApplicationController
   def erector_widget_in_app_v_views
     @foo = "quux"
   end
+
+  def render_widget_fortitude
+    render :widget => ::Views::FortitudeWidget.new
+  end
+
+  def render_widget_erector
+    render :widget => ::Views::ErectorWidget.new
+  end
+
+  def render_widget_fortitude_class
+    render :widget => ::Views::FortitudeWidget
+  end
+
+  def render_widget_erector_class
+    render :widget => ::Views::ErectorWidget
+  end
 end

data/spec/rails/templates/erector_coexistence_system_spec/app/views/erector_widget.rb

@@ -0,0 +1,5 @@
+class Views::ErectorWidget < Erector::Widget
+  def content
+    text "this is an Erector widget"
+  end
+end

data/spec/rails/templates/erector_coexistence_system_spec/app/views/fortitude_widget.rb

@@ -0,0 +1,5 @@
+class Views::FortitudeWidget < Fortitude::Widgets::Html5
+  def content
+    text "this is a Fortitude widget"
+  end
+end

data/spec/rails/templates/localization_system_spec/app/views/localization_system_spec/content_method.rb

@@ -1,4 +1,6 @@
 class Views::LocalizationSystemSpec::ContentMethod < Fortitude::Widgets::Html5
+  use_localized_content_methods true
+
   def localized_content_en
     text "wassup? this is english"
   end

data/spec/rails/templates/rendering_system_spec/app/controllers/rendering_system_spec_controller.rb

@@ -11,6 +11,19 @@ class RenderingSystemSpecController < ApplicationController
     render :widget => Views::WidgetToRender.new(:name => 'Fred')
   end
 
+  def render_widget_with_helper
+    render :widget => Views::WidgetToRenderWithHelper.new
+  end
+
+  def render_widget_class_only
+    render :widget => Views::WidgetToRenderClassOnly
+  end
+
+  def render_widget_class_and_assigns
+    @name = 'Yaravan'
+    render :widget => Views::WidgetToRender
+  end
+
   def render_widget_without_layout
     render :widget => Views::WidgetToRender.new(:name => 'Fred'), :layout => false
   end
@@ -28,7 +41,7 @@ class RenderingSystemSpecController < ApplicationController
   def render_widget_via_inline
     @name = "Fred"
     proc = lambda do
-      p "this is an inline widget named #{shared_variables[:name]}"
+      p "this is an inline widget named #{name}"
     end
     render :inline => proc, :type => :fortitude
   end

data/spec/rails/templates/rendering_system_spec/app/helpers/application_helper.rb

@@ -0,0 +1,5 @@
+module ApplicationHelper
+  def my_name_helper
+    "Judy"
+  end
+end

data/spec/rails/templates/rendering_system_spec/app/views/widget_to_render_class_only.rb

@@ -0,0 +1,5 @@
+class Views::WidgetToRenderClassOnly < Fortitude::Widgets::Html5
+  def content
+    p "hello from a simple widget"
+  end
+end

data/spec/rails/templates/rendering_system_spec/app/views/widget_to_render_with_helper.rb

@@ -0,0 +1,5 @@
+class Views::WidgetToRenderWithHelper < Fortitude::Widgets::Html5
+  def content
+    p "hello from a widget named #{my_name_helper}"
+  end
+end

data/spec/system/doctypes_system_spec.rb

@@ -47,56 +47,64 @@ describe "Fortitude doctype support", :type => :system do
       :allows_dir  => false, :allows_background => false, :allows_frame => false, :closes_void_tags => false,
       :requires_close_void_tags_to_be => nil,
       :doctype_line => '<!DOCTYPE html>',
-      :javascript => :none
+      :javascript => :none,
+      :true_value_has_attribute_value => false
     },
 
     :html4_strict => {
       :allows_dir  => false, :allows_background => false, :allows_frame => false, :closes_void_tags => false,
       :requires_close_void_tags_to_be => false,
       :doctype_line => '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">',
-      :javascript => :type
+      :javascript => :type,
+      :true_value_has_attribute_value => false
     },
 
     :html4_transitional => {
       :allows_dir  => true, :allows_background => true, :allows_frame => false, :closes_void_tags => false,
       :requires_close_void_tags_to_be => false,
       :doctype_line => '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">',
-      :javascript => :type
+      :javascript => :type,
+      :true_value_has_attribute_value => false
     },
 
     :html4_frameset => {
       :allows_dir  => true, :allows_background => true, :allows_frame => true, :closes_void_tags => false,
       :requires_close_void_tags_to_be => false,
       :doctype_line => '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">',
-      :javascript => :type
+      :javascript => :type,
+      :true_value_has_attribute_value => false
     },
 
     :xhtml10_strict => {
       :allows_dir  => false, :allows_background => false, :allows_frame => false, :closes_void_tags => true,
       :requires_close_void_tags_to_be => true,
       :doctype_line => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
-      :javascript => :type_and_cdata
+      :javascript => :type_and_cdata,
+      :true_value_has_attribute_value => true
     },
 
     :xhtml10_transitional => {
       :allows_dir  => true, :allows_background => true, :allows_frame => false, :closes_void_tags => true,
       :requires_close_void_tags_to_be => true,
       :doctype_line => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
-      :javascript => :type_and_cdata
+      :javascript => :type_and_cdata,
+      :true_value_has_attribute_value => true
     },
 
     :xhtml10_frameset => {
       :allows_dir  => true, :allows_background => true, :allows_frame => true, :closes_void_tags => true,
       :requires_close_void_tags_to_be => true,
       :doctype_line => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">',
-      :javascript => :type_and_cdata
+      :javascript => :type_and_cdata,
+      :true_value_has_attribute_value => true
     },
 
     :xhtml11 => {
       :allows_dir  => false, :allows_background => false, :allows_frame => false, :closes_void_tags => true,
       :requires_close_void_tags_to_be => true,
       :doctype_line => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">',
-      :javascript => :type_and_cdata
+      :javascript => :type_and_cdata,
+      :true_value_has_attribute_value => true
     }
   }.each do |doctype, expected_results|
     describe doctype do
@@ -104,6 +112,20 @@ describe "Fortitude doctype support", :type => :system do
         @classes_by_doctype[doctype] ||= wc_with_doctype(doctype)
       }
 
+      it "should #{expected_results[:true_value_has_attribute_value] ? "" : "not "}have an attribute value for attribute values of true" do
+        the_widget_class.class_eval do
+          def content
+            p(:class => true)
+          end
+        end
+
+        if expected_results[:true_value_has_attribute_value]
+          expect(render(the_widget_class)).to eq("<p class=\"class\"></p>")
+        else
+          expect(render(the_widget_class)).to eq("<p class></p>")
+        end
+      end
+
       it "should #{expected_results[:allows_dir] ? "" : "not "}allow <dir>" do
         the_widget_class.class_eval do
           def content

data/spec/system/erector_compatibility_system_spec.rb

@@ -81,4 +81,31 @@ describe "Fortitude Erector compatibility", :type => :system do
       expect(render(wc.new(:foo => "the_foo", :bar => "the_bar"))).to eq("foo: the_foo, bar: the_bar")
     end
   end
+
+  it "should allow calling #call_block as an alias for #yield_from_widget, but not pass the widget instance" do
+    wc_sub = widget_class do
+      def content
+        text "inner_before"
+        call_block
+        text "inner_after"
+      end
+    end
+
+    wc = widget_class do
+      cattr_accessor :other_widget_class
+
+      def content
+        text "before"
+        widget other_widget_class do |*args|
+          raise "invalid: #{args.inspect}" if args.length > 0
+          text "middle"
+        end
+        text "after"
+      end
+    end
+
+    wc.other_widget_class = wc_sub
+
+    expect(render(wc)).to eq("beforeinner_beforemiddleinner_afterafter")
+  end
 end

data/spec/system/localization_system_spec.rb

@@ -1,6 +1,8 @@
 describe "Fortitude native (non-Rails) localization support", :type => :system do
   before :each do
     @klass = widget_class do
+      use_localized_content_methods true
+
       def localized_content_en
         text "english!"
       end
@@ -48,6 +50,8 @@ describe "Fortitude native (non-Rails) localization support", :type => :system d
       @klass = widget_class do
         attr_accessor :widget_locale
 
+        use_localized_content_methods true
+
         def initialize(attributes = { })
           self.widget_locale = attributes.delete(:widget_locale)
           super(attributes)

data/spec/system/needs_system_spec.rb

@@ -16,6 +16,37 @@ describe "Fortitude needs", :type => :system do
     expect(child.needs(:baz => 'def_baz')).to eq(:foo => required, :bar => required, :baz => 'def_baz')
   end
 
+  it "should not rebuild 'needs' at all unless you actually use a widget" do
+    notifications = [ ]
+    ActiveSupport::Notifications.subscribe("fortitude.rebuilding") do |*args|
+      notifications << args
+    end
+
+    wc1 = widget_class do
+      def content
+        p "hello, world"
+      end
+    end
+
+    wc2 = widget_class do
+      needs :foo, :bar, :baz
+
+      def content
+        p "foo: #{foo}, bar: #{bar}"
+      end
+    end
+
+    wc3 = widget_class do
+      needs :foo, :bar
+
+      def content
+        p "foo: #{foo}"
+      end
+    end
+
+    expect(notifications).to eq([ ])
+  end
+
   it "should raise an exception if you try to modify a 'needs' default value" do
     wc = widget_class do
       needs :foo, :bar => [ 'a', 'b' ]

data/spec/system/rebuild_notifications_system_spec.rb

@@ -1,157 +1,252 @@
 describe "Fortitude rebuilding notifications", :type => :system do
   before :each do
-    @notifications = [ ]
-    n = @notifications
-    ActiveSupport::Notifications.subscribe("fortitude.rebuilding") do |*args|
-      n << args
+    @rebuild_notifications = [ ]
+    rbn = @rebuild_notifications
+    ActiveSupport::Notifications.subscribe("fortitude.rebuilding") do |name, start, finish, id, payload|
+      if payload[:what] == :needs && [ ::Fortitude::Widget, ::SystemHelpers::TestWidgetClass ].include?(payload[:class])
+        # So, here's the deal: needs get rebuilt on ::Fortitude::Widget and ::SystemHelpers::TestWidgetClass by
+        # whatever example in this file is the *first* one to actually instantiate a widget, and then not past that
+        # point, since we never change anything need-related on either of those classes. (Which is really important,
+        # or we'd reconfigure Fortitude internally for *all other specs*.)
+        #
+        # As a result, it's much simpler and more reliable to simply ignore these notifications than try to keep track
+        # of which is the first spec to cause these to be rebuilt. Specs below do check things like superclass-subclass
+        # needs invalidation, so we're good there too.
+      else
+        rbn << [ name, start, finish, id, payload ]
+      end
+    end
+
+    @invalidating_notifications = [ ]
+    ivn = @invalidating_notifications
+    ActiveSupport::Notifications.subscribe("fortitude.invalidating") do |name, start, finish, id, payload|
+      ivn << [ name, start, finish, id, payload ]
     end
 
     @wc = widget_class
   end
 
-  def expect_notification(expected_payload)
+  def expect_rebuild_notification(expected_payload)
+    expected_payload = { :class => @wc, :originating_class => @wc }.merge(expected_payload)
+    notification = @rebuild_notifications.detect do |(name, start, finish, id, payload)|
+      payload == expected_payload
+    end
+    raise "Can't find rebuild notification with payload #{expected_payload.inspect}; have: #{@rebuild_notifications.inspect} (invalidating: #{@invalidating_notifications.inspect})" unless notification
+    @rebuild_notifications.delete(notification)
+  end
+
+  def expect_no_more_rebuild_notifications!(what = nil)
+    remaining = @rebuild_notifications
+    remaining = remaining.select { |n| n[4][:what] == what } if what
+
+    if remaining.length > 0
+      raise "Had more rebuild notifications that we didn't expect: #{remaining.inspect}"
+    end
+  end
+
+  def expect_invalidating_notification(expected_payload)
     expected_payload = { :class => @wc, :originating_class => @wc }.merge(expected_payload)
-    notification = @notifications.detect do |(name, start, finish, id, payload)|
+    notification = @invalidating_notifications.detect do |(name, start, finish, id, payload)|
       payload == expected_payload
     end
-    raise "Can't find notification with payload #{expected_payload.inspect}; have: #{@notifications.inspect}" unless notification
-    @notifications.delete(notification)
+    raise "Can't find invalidating notification with payload #{expected_payload.inspect}; have: #{@invalidating_notifications.inspect} (rebuilding: #{@rebuild_notifications.inspect})" unless notification
+    @invalidating_notifications.delete(notification)
   end
 
-  def expect_no_more_notifications!(what = nil)
-    remaining = @notifications
+  def expect_no_more_invalidating_notifications!(what = nil)
+    remaining = @invalidating_notifications
     remaining = remaining.select { |n| n[4][:what] == what } if what
 
     if remaining.length > 0
-      raise "Had more notifications that we didn't expect: #{remaining.inspect}"
+      raise "Had more invalidating notifications that we didn't expect: #{remaining.inspect}"
     end
   end
 
   describe "text methods" do
     it "should fire a notification when rebuilding because format_output has changed" do
       @wc.format_output true
-      expect_notification(:what => :text_methods, :why => :format_output_changed)
-      expect_no_more_notifications!(:text_methods)
+      expect_rebuild_notification(:what => :text_methods, :why => :format_output_changed)
+      expect_no_more_rebuild_notifications!(:text_methods)
 
       @wc.format_output false
-      expect_notification(:what => :text_methods, :why => :format_output_changed)
-      expect_no_more_notifications!(:text_methods)
+      expect_rebuild_notification(:what => :text_methods, :why => :format_output_changed)
+      expect_no_more_rebuild_notifications!(:text_methods)
     end
   end
 
   describe "needs" do
-    it "should fire a notification when rebuilding because a need was declared" do
+    it "should fire an notification when invalidating because a need was declared" do
       @wc.needs :foo
-      expect_notification(:what => :needs, :why => :need_declared)
-      expect_no_more_notifications!(:needs)
+      expect_invalidating_notification(:what => :needs, :why => :need_declared)
+      expect_no_more_invalidating_notifications!(:needs)
 
       @wc.needs :bar => :baz
-      expect_notification(:what => :needs, :why => :need_declared)
-      expect_no_more_notifications!(:needs)
+      expect_invalidating_notification(:what => :needs, :why => :need_declared)
+      expect_no_more_invalidating_notifications!(:needs)
     end
 
-    it "should fire a notification when rebuilding because extra_assigns was changed" do
+    it "should fire a notification when invalidating because extra_assigns was changed" do
       @wc.extra_assigns :use
-      expect_notification(:what => :needs, :why => :extra_assigns_changed)
-      expect_no_more_notifications!(:needs)
+      expect_invalidating_notification(:what => :needs, :why => :extra_assigns_changed)
+      expect_no_more_invalidating_notifications!(:needs)
 
       @wc.extra_assigns :error
-      expect_notification(:what => :needs, :why => :extra_assigns_changed)
-      expect_no_more_notifications!(:needs)
+      expect_invalidating_notification(:what => :needs, :why => :extra_assigns_changed)
+      expect_no_more_invalidating_notifications!(:needs)
     end
 
-    it "should fire a notification when rebuilding because use_instance_variables_for_assigns was changed" do
+    it "should fire a notification when invalidating because use_instance_variables_for_assigns was changed" do
       @wc.use_instance_variables_for_assigns true
-      expect_notification(:what => :needs, :why => :use_instance_variables_for_assigns_changed)
-      expect_no_more_notifications!(:needs)
+      expect_invalidating_notification(:what => :needs, :why => :use_instance_variables_for_assigns_changed)
+      expect_no_more_invalidating_notifications!(:needs)
 
       @wc.use_instance_variables_for_assigns false
-      expect_notification(:what => :needs, :why => :use_instance_variables_for_assigns_changed)
-      expect_no_more_notifications!(:needs)
+      expect_invalidating_notification(:what => :needs, :why => :use_instance_variables_for_assigns_changed)
+      expect_no_more_invalidating_notifications!(:needs)
+    end
+
+    it "should only rebuild needs when a widget is actually instantiated" do
+      expect_no_more_invalidating_notifications!(:needs)
+      expect_no_more_rebuild_notifications!(:needs)
+
+      @wc.new
+
+      expect_no_more_invalidating_notifications!(:needs)
+      expect_rebuild_notification(:what => :needs, :why => :invalid, :class => @wc, :originating_class => @wc)
+      expect_no_more_rebuild_notifications!(:needs)
+    end
+
+    it "should only rebuild needs when a widget is actually instantiated the first time" do
+      expect_no_more_invalidating_notifications!(:needs)
+      expect_no_more_rebuild_notifications!(:needs)
+
+      @wc.new
+
+      expect_no_more_invalidating_notifications!(:needs)
+      expect_rebuild_notification(:what => :needs, :why => :invalid, :class => @wc, :originating_class => @wc)
+      expect_no_more_rebuild_notifications!(:needs)
+
+      @wc.new
+      expect_no_more_invalidating_notifications!(:needs)
+      expect_no_more_rebuild_notifications!(:needs)
+    end
+
+    it "should invalidate multiple times, but not rebuild more than once if multiple things are changed" do
+      @wc.new
+
+      expect_no_more_invalidating_notifications!(:needs)
+      expect_rebuild_notification(:what => :needs, :why => :invalid, :class => @wc, :originating_class => @wc)
+      expect_no_more_rebuild_notifications!(:needs)
+
+      @wc.needs :foobar
+      @wc.use_instance_variables_for_assigns true
+
+      expect_invalidating_notification(:what => :needs, :why => :need_declared, :class => @wc, :originating_class => @wc)
+      expect_invalidating_notification(:what => :needs, :why => :use_instance_variables_for_assigns_changed, :class => @wc, :originating_class => @wc)
+      expect_no_more_invalidating_notifications!(:needs)
+    end
+
+    it "should rebuild on both parent and child classes when a parent class is modified" do
+      wc_child = widget_class(:superclass => @wc)
+
+      expect_no_more_invalidating_notifications!(:needs)
+      expect_no_more_rebuild_notifications!(:needs)
+
+      @wc.needs :foobar
+
+      expect_invalidating_notification(:what => :needs, :why => :need_declared, :class => @wc, :originating_class => @wc)
+      expect_invalidating_notification(:what => :needs, :why => :need_declared, :class => wc_child, :originating_class => @wc)
+      expect_no_more_invalidating_notifications!(:needs)
+      expect_no_more_rebuild_notifications!(:needs)
+
+      wc_child.new(:foobar => 12)
+
+      expect_rebuild_notification(:what => :needs, :why => :invalid, :class => @wc, :originating_class => wc_child)
+      expect_rebuild_notification(:what => :needs, :why => :invalid, :class => wc_child, :originating_class => wc_child)
+      expect_no_more_rebuild_notifications!(:needs)
+      expect_no_more_invalidating_notifications!(:needs)
     end
   end
 
   describe "run_content" do
     it "should fire a notification when rebuilding because an around_content filter was added" do
       @wc.around_content :around1
-      expect_notification(:what => :run_content, :why => :around_content_added)
-      expect_no_more_notifications!(:run_content)
+      expect_rebuild_notification(:what => :run_content, :why => :around_content_added)
+      expect_no_more_rebuild_notifications!(:run_content)
 
       @wc.around_content :around2
-      expect_notification(:what => :run_content, :why => :around_content_added)
-      expect_no_more_notifications!(:run_content)
+      expect_rebuild_notification(:what => :run_content, :why => :around_content_added)
+      expect_no_more_rebuild_notifications!(:run_content)
     end
 
     it "should fire a notification when rebuilding because an around_content filter was removed" do
       @wc.around_content :around1
-      expect_notification(:what => :run_content, :why => :around_content_added)
-      expect_no_more_notifications!(:run_content)
+      expect_rebuild_notification(:what => :run_content, :why => :around_content_added)
+      expect_no_more_rebuild_notifications!(:run_content)
 
       @wc.remove_around_content :around1
-      expect_notification(:what => :run_content, :why => :around_content_removed)
-      expect_no_more_notifications!(:run_content)
+      expect_rebuild_notification(:what => :run_content, :why => :around_content_removed)
+      expect_no_more_rebuild_notifications!(:run_content)
     end
 
-    it "should fire a notification when rebuilding because a localized content method was added" do
+    it "should fire a notification when rebuilding because use_localized_content_methods was changed" do
       @wc.class_eval do
-        def localized_content_en
-          text "foo"
-        end
+        use_localized_content_methods true
       end
-      expect_notification(:what => :run_content, :why => :localized_methods_presence_changed)
-      expect_no_more_notifications!(:run_content)
+      expect_rebuild_notification(:what => :run_content, :why => :use_localized_content_methods_changed)
+      expect_no_more_rebuild_notifications!(:run_content)
 
-      @wc.send(:remove_method, :localized_content_en)
-      expect_notification(:what => :run_content, :why => :localized_methods_presence_changed)
-      expect_no_more_notifications!(:run_content)
+      @wc.send(:use_localized_content_methods, false)
+      expect_rebuild_notification(:what => :run_content, :why => :use_localized_content_methods_changed)
+      expect_no_more_rebuild_notifications!(:run_content)
     end
   end
 
   describe "tag_methods" do
     it "should fire a notification when rebuilding because a tag was added" do
       @wc.tag :foo
-      expect_notification(:what => :tag_methods, :why => :tags_declared)
-      expect_no_more_notifications!(:tag_methods)
+      expect_rebuild_notification(:what => :tag_methods, :why => :tags_declared)
+      expect_no_more_rebuild_notifications!(:tag_methods)
     end
 
     it "should fire a notification when rebuilding because format_output has changed" do
       @wc.format_output true
-      expect_notification(:what => :tag_methods, :why => :format_output_changed)
-      expect_no_more_notifications!(:tag_methods)
+      expect_rebuild_notification(:what => :tag_methods, :why => :format_output_changed)
+      expect_no_more_rebuild_notifications!(:tag_methods)
 
       @wc.format_output false
-      expect_notification(:what => :tag_methods, :why => :format_output_changed)
-      expect_no_more_notifications!(:tag_methods)
+      expect_rebuild_notification(:what => :tag_methods, :why => :format_output_changed)
+      expect_no_more_rebuild_notifications!(:tag_methods)
     end
 
     it "should fire a notification when rebuilding because enforce_element_nesting_rules has changed" do
       @wc.enforce_element_nesting_rules true
-      expect_notification(:what => :tag_methods, :why => :enforce_element_nesting_rules_changed)
-      expect_no_more_notifications!(:tag_methods)
+      expect_rebuild_notification(:what => :tag_methods, :why => :enforce_element_nesting_rules_changed)
+      expect_no_more_rebuild_notifications!(:tag_methods)
 
       @wc.enforce_element_nesting_rules false
-      expect_notification(:what => :tag_methods, :why => :enforce_element_nesting_rules_changed)
-      expect_no_more_notifications!(:tag_methods)
+      expect_rebuild_notification(:what => :tag_methods, :why => :enforce_element_nesting_rules_changed)
+      expect_no_more_rebuild_notifications!(:tag_methods)
     end
 
     it "should fire a notification when rebuilding because enforce_attribute_rules has changed" do
       @wc.enforce_attribute_rules true
-      expect_notification(:what => :tag_methods, :why => :enforce_attribute_rules_changed)
-      expect_no_more_notifications!(:tag_methods)
+      expect_rebuild_notification(:what => :tag_methods, :why => :enforce_attribute_rules_changed)
+      expect_no_more_rebuild_notifications!(:tag_methods)
 
       @wc.enforce_attribute_rules false
-      expect_notification(:what => :tag_methods, :why => :enforce_attribute_rules_changed)
-      expect_no_more_notifications!(:tag_methods)
+      expect_rebuild_notification(:what => :tag_methods, :why => :enforce_attribute_rules_changed)
+      expect_no_more_rebuild_notifications!(:tag_methods)
     end
 
     it "should fire a notification when rebuilding because enforce_id_uniqueness has changed" do
       @wc.enforce_id_uniqueness true
-      expect_notification(:what => :tag_methods, :why => :enforce_id_uniqueness_changed)
-      expect_no_more_notifications!(:tag_methods)
+      expect_rebuild_notification(:what => :tag_methods, :why => :enforce_id_uniqueness_changed)
+      expect_no_more_rebuild_notifications!(:tag_methods)
 
       @wc.enforce_id_uniqueness false
-      expect_notification(:what => :tag_methods, :why => :enforce_id_uniqueness_changed)
-      expect_no_more_notifications!(:tag_methods)
+      expect_rebuild_notification(:what => :tag_methods, :why => :enforce_id_uniqueness_changed)
+      expect_no_more_rebuild_notifications!(:tag_methods)
     end
   end
 
@@ -163,46 +258,46 @@ describe "Fortitude rebuilding notifications", :type => :system do
 
     it "should fire with the right class for text methods" do
       @wc_subclass.format_output true
-      expect_notification(:what => :text_methods, :why => :format_output_changed, :class => @wc_subclass, :originating_class => @wc_subclass)
-      expect_no_more_notifications!(:text_methods)
+      expect_rebuild_notification(:what => :text_methods, :why => :format_output_changed, :class => @wc_subclass, :originating_class => @wc_subclass)
+      expect_no_more_rebuild_notifications!(:text_methods)
 
       @wc.format_output true
-      expect_notification(:what => :text_methods, :why => :format_output_changed, :class => @wc, :originating_class => @wc)
-      expect_notification(:what => :text_methods, :why => :format_output_changed, :class => @wc_subclass, :originating_class => @wc)
-      expect_no_more_notifications!(:text_methods)
+      expect_rebuild_notification(:what => :text_methods, :why => :format_output_changed, :class => @wc, :originating_class => @wc)
+      expect_rebuild_notification(:what => :text_methods, :why => :format_output_changed, :class => @wc_subclass, :originating_class => @wc)
+      expect_no_more_rebuild_notifications!(:text_methods)
     end
 
     it "should fire with the right class for needs" do
       @wc_subclass.extra_assigns :use
-      expect_notification(:what => :needs, :why => :extra_assigns_changed, :class => @wc_subclass, :originating_class => @wc_subclass)
-      expect_no_more_notifications!(:needs)
+      expect_invalidating_notification(:what => :needs, :why => :extra_assigns_changed, :class => @wc_subclass, :originating_class => @wc_subclass)
+      expect_no_more_invalidating_notifications!(:needs)
 
       @wc.extra_assigns :error
-      expect_notification(:what => :needs, :why => :extra_assigns_changed, :class => @wc, :originating_class => @wc)
-      expect_notification(:what => :needs, :why => :extra_assigns_changed, :class => @wc_subclass, :originating_class => @wc)
-      expect_no_more_notifications!(:needs)
+      expect_invalidating_notification(:what => :needs, :why => :extra_assigns_changed, :class => @wc, :originating_class => @wc)
+      expect_invalidating_notification(:what => :needs, :why => :extra_assigns_changed, :class => @wc_subclass, :originating_class => @wc)
+      expect_no_more_invalidating_notifications!(:needs)
     end
 
     it "should fire with the right class for run_content" do
       @wc_subclass.around_content :around1
-      expect_notification(:what => :run_content, :why => :around_content_added, :class => @wc_subclass, :originating_class => @wc_subclass)
-      expect_no_more_notifications!(:run_content)
+      expect_rebuild_notification(:what => :run_content, :why => :around_content_added, :class => @wc_subclass, :originating_class => @wc_subclass)
+      expect_no_more_rebuild_notifications!(:run_content)
 
       @wc.around_content :around2
-      expect_notification(:what => :run_content, :why => :around_content_added, :class => @wc, :originating_class => @wc)
-      expect_notification(:what => :run_content, :why => :around_content_added, :class => @wc_subclass, :originating_class => @wc)
-      expect_no_more_notifications!(:run_content)
+      expect_rebuild_notification(:what => :run_content, :why => :around_content_added, :class => @wc, :originating_class => @wc)
+      expect_rebuild_notification(:what => :run_content, :why => :around_content_added, :class => @wc_subclass, :originating_class => @wc)
+      expect_no_more_rebuild_notifications!(:run_content)
     end
 
     it "should fire with the right class for tag_methods" do
       @wc_subclass.format_output true
-      expect_notification(:what => :tag_methods, :why => :format_output_changed, :class => @wc_subclass, :originating_class => @wc_subclass)
-      expect_no_more_notifications!(:tag_methods)
+      expect_rebuild_notification(:what => :tag_methods, :why => :format_output_changed, :class => @wc_subclass, :originating_class => @wc_subclass)
+      expect_no_more_rebuild_notifications!(:tag_methods)
 
       @wc.format_output true
-      expect_notification(:what => :tag_methods, :why => :format_output_changed, :class => @wc, :originating_class => @wc)
-      expect_notification(:what => :tag_methods, :why => :format_output_changed, :class => @wc_subclass, :originating_class => @wc)
-      expect_no_more_notifications!(:tag_methods)
+      expect_rebuild_notification(:what => :tag_methods, :why => :format_output_changed, :class => @wc, :originating_class => @wc)
+      expect_rebuild_notification(:what => :tag_methods, :why => :format_output_changed, :class => @wc_subclass, :originating_class => @wc)
+      expect_no_more_rebuild_notifications!(:tag_methods)
     end
   end
 end