fortitude 0.0.4-java

data/spec/system/other_outputters_system_spec.rb

@@ -0,0 +1,117 @@
+describe "Fortitude other outputting methods", :type => :system do
+  def r(&block)
+    render(widget_class_with_content(&block))
+  end
+
+  def should_render_to(value, &block)
+    expect(r(&block)).to eq(value)
+  end
+
+  describe "comments" do
+    it "should render a simple comment" do
+      should_render_to("<!-- foo -->") { comment "foo" }
+    end
+
+    it "should escape anything potentially comment-ending in a comment" do
+      [ "fo --> oo", "fo -- oo", "fo --", "--", "-----", "---", " -- ", "-- ", " --", "- -",
+        ">", " > ", ">>", "-->" ].each do |string|
+        text = render(widget_class_with_content { comment string })
+        if text =~ /^<!--(.*)-->$/
+          contents = $1
+        else
+          raise "Not a comment?!? #{text.inspect}"
+        end
+
+        # From http://www.w3.org/TR/html5/syntax.html#comments:
+        #
+        # Comments must start with the four character sequence U+003C LESS-THAN SIGN, U+0021 EXCLAMATION MARK,
+        # U+002D HYPHEN-MINUS, U+002D HYPHEN-MINUS (<!--). Following this sequence, the comment may have text,
+        # with the additional restriction that the text must not start with a single ">" (U+003E) character,
+        # nor start with a U+002D HYPHEN-MINUS character (-) followed by a ">" (U+003E) character, nor contain
+        # two consecutive U+002D HYPHEN-MINUS characters (--), nor end with a U+002D HYPHEN-MINUS character (-).
+        # Finally, the comment must be ended by the three character sequence U+002D HYPHEN-MINUS, U+002D HYPHEN-MINUS,
+        # U+003E GREATER-THAN SIGN (-->).
+        expect(contents).not_to match(/\-\-/)
+        expect(contents).not_to match(/^\s*>/)
+        expect(contents).not_to match(/^\s*\->/)
+        expect(contents).not_to match(/>$/)
+      end
+    end
+
+    it "should not escape standard HTML escape characters inside a comment" do
+      expect(render(widget_class_with_content { comment 'mind your "p"s & "q"s' })).to eq('<!-- mind your "p"s & "q"s -->')
+      expect(render(widget_class_with_content { comment 'is 3 < 4, or is 4 > 3?' })).to eq('<!-- is 3 < 4, or is 4 > 3? -->')
+    end
+
+    it "should not allow passing a block" do
+      expect { render { comment { text "hi" } } }.to raise_error(ArgumentError)
+    end
+
+    it "should put comments on their own lines if we're formatting output, and indent them properly" do
+      wc = widget_class do
+        format_output true
+
+        def content
+          div do
+            text "this is really cool"
+            comment "isn't it?"
+            text "man?"
+          end
+        end
+      end
+
+      expect(render(wc)).to eq(%{<div>
+  this is really cool
+  <!-- isn't it? -->
+  man?
+</div>})
+    end
+  end
+
+  describe "cdata" do
+    it "should output data inside CDATA" do
+      wc = widget_class_with_content { cdata "hi there" }
+      expect(render(wc)).to eq(%{<![CDATA[hi there]]>})
+    end
+
+    it "should properly split up a CDATA section if necessary" do
+      wc = widget_class_with_content { cdata "this contains a ]]> cdata end in it" }
+      expect(render(wc)).to eq(%{<![CDATA[this contains a ]]]]><![CDATA[> cdata end in it]]>})
+    end
+
+    it "should properly split up a CDATA section into several pieces if necessary" do
+      wc = widget_class_with_content { cdata "this contains a ]]> cdata end in it and ]]> again" }
+      expect(render(wc)).to eq(%{<![CDATA[this contains a ]]]]><![CDATA[> cdata end in it and ]]]]><![CDATA[> again]]>})
+    end
+
+    it "should not indent CDATA contents or ending, even if we're formatting output" do
+      wc = widget_class do
+        format_output true
+
+        def content
+          div do
+            div do
+              cdata %{hi
+there
+man}
+            end
+          end
+        end
+      end
+
+      expect(render(wc)).to eq(%{<div>
+  <div>
+    <![CDATA[hi
+there
+man]]>
+  </div>
+</div>})
+    end
+  end
+
+  describe "doctype instance method" do
+    it "should output a doctype with any string if asked" do
+      should_render_to("<!DOCTYPE foobar>") { doctype 'foobar' }
+    end
+  end
+end

data/spec/system/rails_not_available_spec.rb

@@ -0,0 +1,11 @@
+describe "Fortitude spec environment" do
+  # This may seem like a weird spec, but we REALLY don't want to be running Fortitude's built-in specs with Rails
+  # available -- because we want to make really sure Fortitude doesn't end up with any kind of Rails dependency
+  # in it. So we added this spec to make sure the specs fail if Rails somehow *is* available.
+  #
+  # Fortitude has lots and lots of Rails-specific tests, but those run in a separate process with a separate Gemfile,
+  # and thus don't need Rails available at the overall Fortitude level.
+  it "should not have Rails available" do
+    expect { ::Rails }.to raise_error(NameError, /Rails/i)
+  end
+end

data/spec/system/rebuild_notifications_system_spec.rb

@@ -0,0 +1,208 @@
+describe "Fortitude rebuilding notifications", :type => :system do
+  before :each do
+    @notifications = [ ]
+    n = @notifications
+    ActiveSupport::Notifications.subscribe("fortitude.rebuilding") do |*args|
+      n << args
+    end
+
+    @wc = widget_class
+  end
+
+  def expect_notification(expected_payload)
+    expected_payload = { :class => @wc, :originating_class => @wc }.merge(expected_payload)
+    notification = @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)
+  end
+
+  def expect_no_more_notifications!(what = nil)
+    remaining = @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}"
+    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)
+
+      @wc.format_output false
+      expect_notification(:what => :text_methods, :why => :format_output_changed)
+      expect_no_more_notifications!(:text_methods)
+    end
+  end
+
+  describe "needs" do
+    it "should fire a notification when rebuilding because a need was declared" do
+      @wc.needs :foo
+      expect_notification(:what => :needs, :why => :need_declared)
+      expect_no_more_notifications!(:needs)
+
+      @wc.needs :bar => :baz
+      expect_notification(:what => :needs, :why => :need_declared)
+      expect_no_more_notifications!(:needs)
+    end
+
+    it "should fire a notification when rebuilding because extra_assigns was changed" do
+      @wc.extra_assigns :use
+      expect_notification(:what => :needs, :why => :extra_assigns_changed)
+      expect_no_more_notifications!(:needs)
+
+      @wc.extra_assigns :error
+      expect_notification(:what => :needs, :why => :extra_assigns_changed)
+      expect_no_more_notifications!(:needs)
+    end
+
+    it "should fire a notification when rebuilding 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)
+
+      @wc.use_instance_variables_for_assigns false
+      expect_notification(:what => :needs, :why => :use_instance_variables_for_assigns_changed)
+      expect_no_more_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)
+
+      @wc.around_content :around2
+      expect_notification(:what => :run_content, :why => :around_content_added)
+      expect_no_more_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)
+
+      @wc.remove_around_content :around1
+      expect_notification(:what => :run_content, :why => :around_content_removed)
+      expect_no_more_notifications!(:run_content)
+    end
+
+    it "should fire a notification when rebuilding because a localized content method was added" do
+      @wc.class_eval do
+        def localized_content_en
+          text "foo"
+        end
+      end
+      expect_notification(:what => :run_content, :why => :localized_methods_presence_changed)
+      expect_no_more_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)
+    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)
+    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)
+
+      @wc.format_output false
+      expect_notification(:what => :tag_methods, :why => :format_output_changed)
+      expect_no_more_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)
+
+      @wc.enforce_element_nesting_rules false
+      expect_notification(:what => :tag_methods, :why => :enforce_element_nesting_rules_changed)
+      expect_no_more_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)
+
+      @wc.enforce_attribute_rules false
+      expect_notification(:what => :tag_methods, :why => :enforce_attribute_rules_changed)
+      expect_no_more_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)
+
+      @wc.enforce_id_uniqueness false
+      expect_notification(:what => :tag_methods, :why => :enforce_id_uniqueness_changed)
+      expect_no_more_notifications!(:tag_methods)
+    end
+  end
+
+  describe "with a subclass" do
+    before :each do
+      @wc = widget_class
+      @wc_subclass = widget_class(:superclass => @wc)
+    end
+
+    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)
+
+      @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)
+    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)
+
+      @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)
+    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)
+
+      @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)
+    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)
+
+      @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)
+    end
+  end
+end

data/spec/system/rendering_context_system_spec.rb

@@ -0,0 +1,83 @@
+describe "Fortitude rendering context interactions", :type => :system do
+  class RcSubclass < Fortitude::RenderingContext
+    attr_reader :widget_calls
+
+    def initialize(*args)
+      super(*args)
+      @widget_calls = [ ]
+    end
+
+    def start_widget!(widget)
+      @widget_calls << [ :start, widget ]
+    end
+
+    def end_widget!(widget)
+      @widget_calls << [ :end, widget ]
+    end
+  end
+
+  def render(widget_or_class, options = { })
+    @rc = RcSubclass.new({ })
+    super(widget_or_class, options.merge(:rendering_context => @rc))
+  end
+
+  it "should call start_widget! and end_widget! on the context when starting and ending a simple widget" do
+    wc = widget_class_with_content { p "foo" }
+    instance = wc.new
+    expect(render(instance)).to eq("<p>foo</p>")
+    expect(@rc.widget_calls).to eq([ [ :start, instance ], [ :end, instance ] ])
+  end
+
+  it "should call start_widget! and end_widget! in the right order with a deeply-nested example" do
+    bottom = widget_class do
+      needs :value
+      def content
+        text "bottom-#{value}"
+      end
+    end
+
+    mid = widget_class do
+      attr_accessor :bottom1, :bottom2
+      def content
+        widget bottom1 if bottom1
+        widget bottom2 if bottom2
+      end
+    end
+
+    top = widget_class do
+      attr_accessor :mid1, :mid2
+      def content
+        widget mid1
+        widget mid2
+      end
+    end
+
+    bottom_a1 = bottom.new(:value => 12345)
+    bottom_a2 = bottom.new(:value => 23456)
+    bottom_b2 = bottom.new(:value => 34567)
+    mid_a = mid.new
+    mid_a.bottom1 = bottom_a1
+    mid_a.bottom2 = bottom_a2
+    mid_b = mid.new
+    mid_b.bottom2 = bottom_b2
+    top = top.new
+    top.mid1 = mid_a
+    top.mid2 = mid_b
+
+    expect(render(top)).to eq("bottom-12345bottom-23456bottom-34567")
+    expect(@rc.widget_calls).to eq([
+      [ :start, top ],
+      [ :start, mid_a ],
+      [ :start, bottom_a1 ],
+      [ :end, bottom_a1 ],
+      [ :start, bottom_a2 ],
+      [ :end, bottom_a2 ],
+      [ :end, mid_a ],
+      [ :start, mid_b ],
+      [ :start, bottom_b2 ],
+      [ :end, bottom_b2 ],
+      [ :end, mid_b ],
+      [ :end, top ]
+      ])
+  end
+end

data/spec/system/setting_inheritance_system_spec.rb

@@ -0,0 +1,585 @@
+describe "Fortitude setting inheritance", :type => :system do
+  # The settings we test here:
+  #   - extra_assigns
+  #   - automatic_helper_access
+  #   - implicit_shared_variable_access
+  #   - use_instance_variables_for_assigns
+  #   - format_output
+  #   - enforce_element_nesting_rules
+  #   - enforce_attribute_rules
+  #   - start_and_end_comments
+  #   - translation_base
+  #   - enforce_id_uniqueness
+  #   - debug
+  #
+  # needs are covered by the needs_system_spec, and around_content is covered by the around_content_system_spec;
+  # these are not tested here because their semantics are quite a bit more complex than the settings here.
+
+  def translation_base_should_be(expected_result, *klasses)
+    klasses.each do |klass|
+      expect(klass.translation_base).to eq(expected_result)
+      send("translation_base_should_be_for_class", expected_result, klass)
+    end
+  end
+
+  def translation_base_should_be_for_class(expected_result, klass)
+    expect(klass.translation_base).to eq(expected_result)
+    ho_class = Class.new do
+      def t(x)
+        "translation_for:#{x}"
+      end
+    end
+    ho = ho_class.new
+
+    rendering_context = rc(:helpers_object => ho)
+    expect(render(klass, :rendering_context => rendering_context)).to eq("translation: translation_for:#{expected_result}.foo.bar.baz")
+  end
+
+
+  def enforce_id_uniqueness_should_be(expected_result, *klasses)
+    klasses.each do |klass|
+      expect(klass.enforce_id_uniqueness).to eq(expected_result)
+      send("enforce_id_uniqueness_should_be_#{expected_result}", klass)
+    end
+  end
+
+  def enforce_id_uniqueness_should_be_true(klass)
+    expect { render(klass) }.to raise_error(Fortitude::Errors::DuplicateId)
+  end
+
+  def enforce_id_uniqueness_should_be_false(klass)
+    expect(render(klass)).to eq('<p id="foo"></p><p id="foo"></p>')
+  end
+
+
+  def start_and_end_comments_should_be(expected_result, *klasses)
+    klasses.each do |klass|
+      expect(klass.start_and_end_comments).to eq(expected_result)
+      send("start_and_end_comments_should_be_#{expected_result}", klass)
+    end
+  end
+
+  def start_and_end_comments_should_be_true(klass)
+    result = render(klass)
+    if result =~ /^(.*BEGIN?)\s*\S+\s*(depth.*END)\s*\S+\s*(depth.*)$/i
+      expect($1).to eq("<!-- BEGIN")
+      expect($2).to eq("depth 0: :baz => (DEFAULT) \"default_baz\" --><p></p><!-- END")
+      expect($3).to eq("depth 0 -->")
+    else
+      raise "result does not match expected pattern: #{result.inspect}"
+    end
+  end
+
+  def start_and_end_comments_should_be_false(klass)
+    expect(render(klass)).to eq("<p></p>")
+  end
+
+
+  def debug_should_be(expected_result, *klasses)
+    klasses.each do |klass|
+      expect(klass.debug).to eq(expected_result)
+      send("debug_should_be_#{expected_result}", klass)
+    end
+  end
+
+  def debug_should_be_true(klass)
+    expect { render(klass) }.to raise_error(Fortitude::Errors::BlockPassedToNeedMethod)
+  end
+
+  def debug_should_be_false(klass)
+    expect(render(klass)).to eq("p is: abc")
+  end
+
+
+  def enforce_attribute_rules_should_be(expected_result, *klasses)
+    klasses.each do |klass|
+      expect(klass.enforce_attribute_rules).to eq(expected_result)
+      send("enforce_attribute_rules_should_be_#{expected_result}", klass)
+    end
+  end
+
+  def enforce_attribute_rules_should_be_true(klass)
+    expect { render(klass) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+
+  def enforce_attribute_rules_should_be_false(klass)
+    expect(render(klass)).to eq("<p foo=\"bar\"></p>")
+  end
+
+
+  def close_void_tags_should_be(expected_result, *klasses)
+    klasses.each do |klass|
+      expect(klass.close_void_tags).to eq(expected_result)
+      send("close_void_tags_should_be_#{expected_result}", klass)
+    end
+  end
+
+  def close_void_tags_should_be_true(klass)
+    expect(render(klass)).to eq("<br/>")
+  end
+
+  def close_void_tags_should_be_false(klass)
+    expect(render(klass)).to eq("<br>")
+  end
+
+
+  def enforce_element_nesting_rules_should_be(expected_result, *klasses)
+    klasses.each do |klass|
+      expect(klass.enforce_element_nesting_rules).to eq(expected_result)
+      send("enforce_element_nesting_rules_should_be_#{expected_result}", klass)
+    end
+  end
+
+  def enforce_element_nesting_rules_should_be_true(klass)
+    expect { render(klass) }.to raise_error(Fortitude::Errors::InvalidElementNesting)
+  end
+
+  def enforce_element_nesting_rules_should_be_false(klass)
+    expect(render(klass)).to eq("<p><div></div></p>")
+  end
+
+
+  def format_output_should_be(expected_result, *klasses)
+    klasses.each do |klass|
+      expect(klass.format_output).to eq(expected_result)
+      send("format_output_should_be_#{expected_result}", klass)
+    end
+  end
+
+  def format_output_should_be_true(klass)
+    expect(render(klass)).to eq(%{<div>
+  <p>
+    <span class="foo"></span>
+  </p>
+</div>})
+  end
+
+  def format_output_should_be_false(klass)
+    expect(render(klass)).to eq('<div><p><span class="foo"></span></p></div>')
+  end
+
+
+  def extra_assigns_should_be(expected_result, *klasses)
+    klasses.each do |klass|
+      expect(klass.extra_assigns).to eq(expected_result)
+      send("extra_assigns_should_be_#{expected_result}", klass)
+    end
+  end
+
+  def extra_assigns_should_be_use(klass)
+    expect(render(klass.new(:foo => 'the_foo'))).to match(/foo: the_foo/)
+  end
+
+  def extra_assigns_should_be_ignore(klass)
+    expect(render(klass.new(:foo => 'the_foo'))).to match(/foo: NameError/)
+  end
+
+  def extra_assigns_should_be_error(klass)
+    expect { klass.new(:foo => 'the_foo') }.to raise_error(Fortitude::Errors::ExtraAssigns)
+  end
+
+
+  def automatic_helper_access_should_be(expected_result, *klasses)
+    klasses.each do |klass|
+      expect(klass.automatic_helper_access).to eq(expected_result)
+      send("automatic_helper_access_should_be_#{expected_result}", klass)
+    end
+  end
+
+  def rc_for_automatic_helper_access
+    @aha_helpers_class ||= Class.new do
+      def helper1
+        "this is helper1!"
+      end
+    end
+
+    rc(:helpers_object => @aha_helpers_class.new)
+  end
+
+  def automatic_helper_access_should_be_true(klass)
+    expect(render(klass.new, :rendering_context => rc_for_automatic_helper_access)).to match(/helper1: this is helper1!/)
+  end
+
+  def automatic_helper_access_should_be_false(klass)
+    expect(render(klass.new, :rendering_context => rc_for_automatic_helper_access)).to match(/helper1: NameError/)
+  end
+
+
+  def implicit_shared_variable_access_should_be(expected_result, *klasses)
+    klasses.each do |klass|
+      expect(klass.implicit_shared_variable_access).to eq(expected_result)
+      send("implicit_shared_variable_access_should_be_#{expected_result}", klass)
+    end
+  end
+
+  def rc_for_implicit_shared_variable_access
+    @isva_obj = Object.new
+    @isva_obj.instance_variable_set("@bar", "this is bar!")
+    rc(:instance_variables_object => @isva_obj)
+  end
+
+  def implicit_shared_variable_access_should_be_true(klass)
+    expect(render(klass.new, :rendering_context => rc_for_implicit_shared_variable_access)).to match(/bar: &quot;this is bar!&quot;/)
+  end
+
+  def implicit_shared_variable_access_should_be_false(klass)
+    expect(render(klass.new, :rendering_context => rc_for_implicit_shared_variable_access)).to match(/bar: nil/)
+  end
+
+
+  def use_instance_variables_for_assigns_should_be(expected_result, *klasses)
+    klasses.each do |klass|
+      expect(klass.use_instance_variables_for_assigns).to eq(expected_result)
+      send("use_instance_variables_for_assigns_should_be_#{expected_result}", klass)
+    end
+  end
+
+  def use_instance_variables_for_assigns_should_be_true(klass)
+    expect(render(klass.new(:baz => 'some_baz'))).to match(/baz: &quot;some_baz&quot;/)
+  end
+
+  def use_instance_variables_for_assigns_should_be_false(klass)
+    expect(render(klass.new(:baz => 'some_baz'))).to match(/baz: nil/)
+  end
+
+  before :each do
+    @grandparent = widget_class do
+      needs :baz => 'default_baz'
+
+      def content
+        foo_value = begin
+          foo
+        rescue => e
+          e.class.name
+        end
+
+        text "foo: #{foo_value}\n"
+
+        helper1_value = begin
+          helper1
+        rescue => e
+          e.class.name
+        end
+
+        text "helper1: #{helper1_value}\n"
+        text "bar: #{@bar.inspect}\n"
+        text "baz: #{@baz.inspect}"
+      end
+    end
+
+    @parent1 = widget_class(:superclass => @grandparent)
+    @child11 = widget_class(:superclass => @parent1)
+    @child12 = widget_class(:superclass => @parent1)
+
+    @parent2 = widget_class(:superclass => @grandparent)
+    @child21 = widget_class(:superclass => @parent2)
+    @child22 = widget_class(:superclass => @parent2)
+  end
+
+  it "should properly inherit extra_assigns" do
+    extra_assigns_should_be(:ignore, @grandparent, @parent1, @child11, @child12, @parent2, @child21, @child22)
+
+    @parent1.extra_assigns :use
+    extra_assigns_should_be(:ignore, @grandparent, @parent2, @child21, @child22)
+    extra_assigns_should_be(:use, @parent1, @child11, @child12)
+
+    @parent2.extra_assigns :error
+    extra_assigns_should_be(:ignore, @grandparent)
+    extra_assigns_should_be(:error, @parent2, @child21, @child22)
+    extra_assigns_should_be(:use, @parent1, @child11, @child12)
+
+    @grandparent.extra_assigns :use
+    extra_assigns_should_be(:error, @parent2, @child21, @child22)
+    extra_assigns_should_be(:use, @grandparent, @parent1, @child11, @child12)
+
+    @grandparent.extra_assigns :ignore
+    extra_assigns_should_be(:error, @parent2, @child21, @child22)
+    extra_assigns_should_be(:use, @parent1, @child11, @child12)
+    extra_assigns_should_be(:ignore, @grandparent)
+
+    @child22.extra_assigns :ignore
+    extra_assigns_should_be(:error, @parent2, @child21)
+    extra_assigns_should_be(:use, @parent1, @child11, @child12)
+    extra_assigns_should_be(:ignore, @grandparent, @child22)
+  end
+
+  it "should properly inherit automatic_helper_access" do
+    automatic_helper_access_should_be(true, @grandparent, @parent1, @child11, @child12, @parent2, @child21, @child22)
+
+    @parent1.automatic_helper_access false
+    automatic_helper_access_should_be(true, @grandparent, @parent2, @child21, @child22)
+    automatic_helper_access_should_be(false, @parent1, @child11, @child12)
+
+    @parent2.automatic_helper_access true
+    automatic_helper_access_should_be(true, @grandparent, @parent2, @child21, @child22)
+    automatic_helper_access_should_be(false, @parent1, @child11, @child12)
+
+    @grandparent.automatic_helper_access false
+    automatic_helper_access_should_be(true, @parent2, @child21, @child22)
+    automatic_helper_access_should_be(false, @grandparent, @parent1, @child11, @child12)
+
+    @grandparent.automatic_helper_access true
+    automatic_helper_access_should_be(true, @grandparent, @parent2, @child21, @child22)
+    automatic_helper_access_should_be(false, @parent1, @child11, @child12)
+  end
+
+  it "should properly inherit close_void_tags" do
+    @grandparent.class_eval do
+      def content
+        br
+      end
+    end
+
+    close_void_tags_should_be(false, @grandparent, @parent1, @child11, @child12, @parent2, @child21, @child22)
+
+    @parent1.close_void_tags true
+    close_void_tags_should_be(false, @grandparent, @parent2, @child21, @child22)
+    close_void_tags_should_be(true, @parent1, @child11, @child12)
+
+    @parent2.close_void_tags false
+    close_void_tags_should_be(false, @grandparent, @parent2, @child21, @child22)
+    close_void_tags_should_be(true, @parent1, @child11, @child12)
+
+    @grandparent.close_void_tags true
+    close_void_tags_should_be(false, @parent2, @child21, @child22)
+    close_void_tags_should_be(true, @grandparent, @parent1, @child11, @child12)
+
+    @grandparent.close_void_tags false
+    close_void_tags_should_be(false, @grandparent, @parent2, @child21, @child22)
+    close_void_tags_should_be(true, @parent1, @child11, @child12)
+  end
+
+  it "should properly inherit format_output" do
+    @grandparent.class_eval do
+      def content
+        div do
+          p do
+            span :class => 'foo'
+          end
+        end
+      end
+    end
+
+    format_output_should_be(false, @grandparent, @parent1, @child11, @child12, @parent2, @child21, @child22)
+
+    @parent1.format_output true
+    format_output_should_be(false, @grandparent, @parent2, @child21, @child22)
+    format_output_should_be(true, @parent1, @child11, @child12)
+
+    @parent2.format_output false
+    format_output_should_be(false, @grandparent, @parent2, @child21, @child22)
+    format_output_should_be(true, @parent1, @child11, @child12)
+
+    @grandparent.format_output true
+    format_output_should_be(false, @parent2, @child21, @child22)
+    format_output_should_be(true, @grandparent, @parent1, @child11, @child12)
+
+    @grandparent.format_output false
+    format_output_should_be(false, @grandparent, @parent2, @child21, @child22)
+    format_output_should_be(true, @parent1, @child11, @child12)
+  end
+
+  it "should properly inherit enforce_element_nesting_rules" do
+    @grandparent.class_eval do
+      def content
+        p { div }
+      end
+    end
+
+    enforce_element_nesting_rules_should_be(false, @grandparent, @parent1, @child11, @child12, @parent2, @child21, @child22)
+
+    @parent1.enforce_element_nesting_rules true
+    enforce_element_nesting_rules_should_be(false, @grandparent, @parent2, @child21, @child22)
+    enforce_element_nesting_rules_should_be(true, @parent1, @child11, @child12)
+
+    @parent2.enforce_element_nesting_rules false
+    enforce_element_nesting_rules_should_be(false, @grandparent, @parent2, @child21, @child22)
+    enforce_element_nesting_rules_should_be(true, @parent1, @child11, @child12)
+
+    @grandparent.enforce_element_nesting_rules true
+    enforce_element_nesting_rules_should_be(false, @parent2, @child21, @child22)
+    enforce_element_nesting_rules_should_be(true, @grandparent, @parent1, @child11, @child12)
+
+    @grandparent.enforce_element_nesting_rules false
+    enforce_element_nesting_rules_should_be(false, @grandparent, @parent2, @child21, @child22)
+    enforce_element_nesting_rules_should_be(true, @parent1, @child11, @child12)
+  end
+
+  it "should properly inherit translation_base" do
+    @grandparent.class_eval do
+      def content
+        text "translation: #{t(".foo.bar.baz")}"
+      end
+    end
+
+    translation_base_should_be(nil, @grandparent, @parent1, @child11, @child12, @parent2, @child21, @child22)
+
+    @parent1.translation_base "aaa.bbb"
+    translation_base_should_be(nil, @grandparent, @parent2, @child21, @child22)
+    translation_base_should_be("aaa.bbb", @parent1, @child11, @child12)
+
+    @child22.translation_base "ccc.ddd"
+    translation_base_should_be(nil, @grandparent, @parent2, @child21)
+    translation_base_should_be("aaa.bbb", @parent1, @child11, @child12)
+    translation_base_should_be("ccc.ddd", @child22)
+
+    @grandparent.translation_base "eee.fff"
+    translation_base_should_be("eee.fff", @grandparent, @parent2, @child21)
+    translation_base_should_be("aaa.bbb", @parent1, @child11, @child12)
+    translation_base_should_be("ccc.ddd", @child22)
+
+    @parent2.translation_base "ggg.hhh"
+    translation_base_should_be("eee.fff", @grandparent)
+    translation_base_should_be("ggg.hhh", @parent2, @child21)
+    translation_base_should_be("aaa.bbb", @parent1, @child11, @child12)
+    translation_base_should_be("ccc.ddd", @child22)
+  end
+
+  it "should properly inherit enforce_id_uniqueness" do
+    @grandparent.class_eval do
+      def content
+        p :id => 'foo'
+        p :id => 'foo'
+      end
+    end
+
+    enforce_id_uniqueness_should_be(false, @grandparent, @parent1, @child11, @child12, @parent2, @child21, @child22)
+
+    @parent1.enforce_id_uniqueness true
+    enforce_id_uniqueness_should_be(false, @grandparent, @parent2, @child21, @child22)
+    enforce_id_uniqueness_should_be(true, @parent1, @child11, @child12)
+
+    @parent2.enforce_id_uniqueness false
+    enforce_id_uniqueness_should_be(false, @grandparent, @parent2, @child21, @child22)
+    enforce_id_uniqueness_should_be(true, @parent1, @child11, @child12)
+
+    @grandparent.enforce_id_uniqueness true
+    enforce_id_uniqueness_should_be(false, @parent2, @child21, @child22)
+    enforce_id_uniqueness_should_be(true, @grandparent, @parent1, @child11, @child12)
+
+    @grandparent.enforce_id_uniqueness false
+    enforce_id_uniqueness_should_be(false, @grandparent, @parent2, @child21, @child22)
+    enforce_id_uniqueness_should_be(true, @parent1, @child11, @child12)
+  end
+
+  it "should properly inherit start_and_end_comments" do
+    @grandparent.class_eval do
+      def content
+        p
+      end
+    end
+
+    start_and_end_comments_should_be(false, @grandparent, @parent1, @child11, @child12, @parent2, @child21, @child22)
+
+    @parent1.start_and_end_comments true
+    start_and_end_comments_should_be(false, @grandparent, @parent2, @child21, @child22)
+    start_and_end_comments_should_be(true, @parent1, @child11, @child12)
+
+    @parent2.start_and_end_comments false
+    start_and_end_comments_should_be(false, @grandparent, @parent2, @child21, @child22)
+    start_and_end_comments_should_be(true, @parent1, @child11, @child12)
+
+    @grandparent.start_and_end_comments true
+    start_and_end_comments_should_be(false, @parent2, @child21, @child22)
+    start_and_end_comments_should_be(true, @grandparent, @parent1, @child11, @child12)
+
+    @grandparent.start_and_end_comments false
+    start_and_end_comments_should_be(false, @grandparent, @parent2, @child21, @child22)
+    start_and_end_comments_should_be(true, @parent1, @child11, @child12)
+  end
+
+  it "should properly inherit debug" do
+    @grandparent.class_eval do
+      needs :p => 'abc'
+
+      def content
+        p { text "hi" }
+        text "p is: #{p}"
+      end
+    end
+
+    debug_should_be(false, @grandparent, @parent1, @child11, @child12, @parent2, @child21, @child22)
+
+    @parent1.debug true
+    debug_should_be(false, @grandparent, @parent2, @child21, @child22)
+    debug_should_be(true, @parent1, @child11, @child12)
+
+    @parent2.debug false
+    debug_should_be(false, @grandparent, @parent2, @child21, @child22)
+    debug_should_be(true, @parent1, @child11, @child12)
+
+    @grandparent.debug true
+    debug_should_be(false, @parent2, @child21, @child22)
+    debug_should_be(true, @grandparent, @parent1, @child11, @child12)
+
+    @grandparent.debug false
+    debug_should_be(false, @grandparent, @parent2, @child21, @child22)
+    debug_should_be(true, @parent1, @child11, @child12)
+  end
+
+  it "should properly inherit enforce_attribute_rules" do
+    @grandparent.class_eval do
+      def content
+        p :foo => 'bar'
+      end
+    end
+
+    enforce_attribute_rules_should_be(false, @grandparent, @parent1, @child11, @child12, @parent2, @child21, @child22)
+
+    @parent1.enforce_attribute_rules true
+    enforce_attribute_rules_should_be(false, @grandparent, @parent2, @child21, @child22)
+    enforce_attribute_rules_should_be(true, @parent1, @child11, @child12)
+
+    @parent2.enforce_attribute_rules false
+    enforce_attribute_rules_should_be(false, @grandparent, @parent2, @child21, @child22)
+    enforce_attribute_rules_should_be(true, @parent1, @child11, @child12)
+
+    @grandparent.enforce_attribute_rules true
+    enforce_attribute_rules_should_be(false, @parent2, @child21, @child22)
+    enforce_attribute_rules_should_be(true, @grandparent, @parent1, @child11, @child12)
+
+    @grandparent.enforce_attribute_rules false
+    enforce_attribute_rules_should_be(false, @grandparent, @parent2, @child21, @child22)
+    enforce_attribute_rules_should_be(true, @parent1, @child11, @child12)
+  end
+
+  it "should properly inherit implicit_shared_variable_access" do
+    implicit_shared_variable_access_should_be(false, @grandparent, @parent1, @child11, @child12, @parent2, @child21, @child22)
+
+    @parent1.implicit_shared_variable_access true
+    implicit_shared_variable_access_should_be(false, @grandparent, @parent2, @child21, @child22)
+    implicit_shared_variable_access_should_be(true, @parent1, @child11, @child12)
+
+    @parent2.implicit_shared_variable_access false
+    implicit_shared_variable_access_should_be(false, @grandparent, @parent2, @child21, @child22)
+    implicit_shared_variable_access_should_be(true, @parent1, @child11, @child12)
+
+    @grandparent.implicit_shared_variable_access true
+    implicit_shared_variable_access_should_be(false, @parent2, @child21, @child22)
+    implicit_shared_variable_access_should_be(true, @grandparent, @parent1, @child11, @child12)
+
+    @grandparent.implicit_shared_variable_access false
+    implicit_shared_variable_access_should_be(false, @grandparent, @parent2, @child21, @child22)
+    implicit_shared_variable_access_should_be(true, @parent1, @child11, @child12)
+  end
+
+  it "should properly inherit use_instance_variables_for_assigns" do
+    use_instance_variables_for_assigns_should_be(false, @grandparent, @parent1, @child11, @child12, @parent2, @child21, @child22)
+
+    @parent1.use_instance_variables_for_assigns true
+    use_instance_variables_for_assigns_should_be(false, @grandparent, @parent2, @child21, @child22)
+    use_instance_variables_for_assigns_should_be(true, @parent1, @child11, @child12)
+
+    @parent2.use_instance_variables_for_assigns false
+    use_instance_variables_for_assigns_should_be(false, @grandparent, @parent2, @child21, @child22)
+    use_instance_variables_for_assigns_should_be(true, @parent1, @child11, @child12)
+
+    @grandparent.use_instance_variables_for_assigns true
+    use_instance_variables_for_assigns_should_be(false, @parent2, @child21, @child22)
+    use_instance_variables_for_assigns_should_be(true, @grandparent, @parent1, @child11, @child12)
+
+    @grandparent.use_instance_variables_for_assigns false
+    use_instance_variables_for_assigns_should_be(false, @grandparent, @parent2, @child21, @child22)
+    use_instance_variables_for_assigns_should_be(true, @parent1, @child11, @child12)
+  end
+end