fortitude 0.0.1

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 id="foo"/>')
+  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/><!-- 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/>")
+  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\"/>")
+  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/></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"/>
+  </p>
+</div>})
+  end
+
+  def format_output_should_be_false(klass)
+    expect(render(klass)).to eq('<div><p><span class="foo"/></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(true, @grandparent, @parent1, @child11, @child12, @parent2, @child21, @child22)
+
+    @parent1.close_void_tags false
+    close_void_tags_should_be(true, @grandparent, @parent2, @child21, @child22)
+    close_void_tags_should_be(false, @parent1, @child11, @child12)
+
+    @parent2.close_void_tags true
+    close_void_tags_should_be(true, @grandparent, @parent2, @child21, @child22)
+    close_void_tags_should_be(false, @parent1, @child11, @child12)
+
+    @grandparent.close_void_tags false
+    close_void_tags_should_be(true, @parent2, @child21, @child22)
+    close_void_tags_should_be(false, @grandparent, @parent1, @child11, @child12)
+
+    @grandparent.close_void_tags true
+    close_void_tags_should_be(true, @grandparent, @parent2, @child21, @child22)
+    close_void_tags_should_be(false, @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

data/spec/system/shared_variable_system_spec.rb

@@ -0,0 +1,120 @@
+describe "Fortitude shared_variable access", :type => :system do
+  describe "explicit shared-variable access" do
+    it "should allow reading a shared variable" do
+      ivars[:foo] = "the_foo"
+      expect(render(widget_class_with_content { text "foo: #{shared_variables[:foo]}" })).to eq("foo: the_foo")
+    end
+
+    it "should allow writing a shared variable" do
+      expect(render(widget_class_with_content { shared_variables[:foo] = "blah"; text "foo: #{shared_variables[:foo]}" })).to eq("foo: blah")
+      expect(ivars[:foo]).to eq("blah")
+    end
+
+    it "shouldn't care if you use a symbol or a string" do
+      ivars[:foo] = "the_foo"
+      expect(render(widget_class_with_content { text "foo: #{shared_variables[:foo]}, #{shared_variables['foo']}"; shared_variables['foo'] = "blah" })).to eq("foo: the_foo, the_foo")
+      expect(ivars[:foo]).to eq("blah")
+    end
+
+    it "should stringify whatever key you give it" do
+      obj = Object.new
+      class << obj
+        def to_s
+          "foo"
+        end
+      end
+
+      ivars[:foo] = "the_foo"
+      expect(render(widget_class_with_content { text "foo: #{shared_variables[obj]}" })).to eq("foo: the_foo")
+    end
+  end
+
+  describe "implicit shared-variable access" do
+    it "should not function unless explicitly turned on" do
+      ivars[:foo] = "the_foo"
+      expect(render(widget_class_with_content { text "foo: #{@foo}"; @bar = "the_bar" })).to eq("foo: ")
+      expect(ivars[:bar]).to eq(nil)
+    end
+
+    it "should allow reading shared variables implicitly" do
+      ivars[:foo] = "the_foo"
+      wc = widget_class do
+        implicit_shared_variable_access true
+        def content
+          text "foo: #{@foo}"
+        end
+      end
+      expect(render(wc.new)).to eq("foo: the_foo")
+    end
+
+    it "should allow writing shared variables implicitly" do
+      ivars[:foo] = "the_foo"
+      wc = widget_class do
+        implicit_shared_variable_access true
+        def content
+          text "foo: #{@foo}"
+          @foo = "bar"
+        end
+      end
+      expect(render(wc.new)).to eq("foo: the_foo")
+      expect(ivars[:foo]).to eq("bar")
+    end
+
+    it "should allow writing shared variables implicitly, even if they weren't defined going in" do
+      wc = widget_class do
+        implicit_shared_variable_access true
+        def content
+          text "foo: #{@foo}"
+          @foo = "bar"
+        end
+      end
+      expect(render(wc.new)).to eq("foo: ")
+      expect(ivars[:foo]).to eq("bar")
+    end
+
+    describe "interactions with use_instance_variables_for_assigns and extra_assigns" do
+      it "should have needs declarations pre-empt shared variables" do
+        wc = widget_class do
+          use_instance_variables_for_assigns true
+          implicit_shared_variable_access true
+          needs :foo, :bar => nil
+
+          def content
+            text "foo: #{@foo}, bar: #{@bar}, baz: #{@baz}"
+            @bar = "widget_bar"
+            @baz = "widget_baz"
+          end
+        end
+
+        ivars[:foo] = "ivar_foo"
+        ivars[:bar] = "ivar_bar"
+        expect(render(wc.new(:foo => 'the_foo'))).to eq("foo: the_foo, bar: , baz: ")
+        expect(ivars[:foo]).to eq("ivar_foo")
+        expect(ivars[:bar]).to eq("ivar_bar")
+      end
+
+      it "should have extra assigns pre-empt shared variables" do
+        wc = widget_class do
+          use_instance_variables_for_assigns true
+          implicit_shared_variable_access true
+          extra_assigns :use
+          needs :foo, :bar => nil
+
+          def content
+            text "foo: #{@foo}, bar: #{@bar}, baz: #{@baz}"
+            @bar = "widget_bar"
+            @baz = "widget_baz"
+          end
+        end
+
+        ivars[:foo] = "ivar_foo"
+        ivars[:bar] = "ivar_bar"
+        ivars[:baz] = "ivar_baz"
+        expect(render(wc.new(:foo => 'the_foo', :baz => 'some_baz'))).to eq("foo: the_foo, bar: , baz: some_baz")
+        expect(ivars[:foo]).to eq("ivar_foo")
+        expect(ivars[:bar]).to eq("ivar_bar")
+        expect(ivars[:baz]).to eq("ivar_baz")
+      end
+    end
+  end
+end