fortitude 0.0.4-java

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

data/spec/system/start_end_comments_system_spec.rb

@@ -0,0 +1,363 @@
+describe "Fortitude start/end comments support", :type => :system do
+  def eb(widget_class, expected_depth = 0)
+    "BEGIN #{widget_class.name} depth #{expected_depth}"
+  end
+
+  def ee(widget_class, expected_depth = 0)
+    "END #{widget_class.name} depth #{expected_depth}"
+  end
+
+  it "should not add comments by default" do
+    wc = widget_class do
+      def content
+        p "hi!"
+      end
+    end
+
+    expect(render(wc)).to eq("<p>hi!</p>")
+  end
+
+  it "should add comments if asked to" do
+    wc = widget_class do
+      start_and_end_comments true
+
+      def content
+        p "hi!"
+      end
+    end
+
+    expect(render(wc)).to eq("<!-- #{eb(wc)} --><p>hi!</p><!-- #{ee(wc)} -->")
+  end
+
+  it "should add passed assigns, including defaults" do
+    wc = widget_class do
+      start_and_end_comments true
+
+      needs :foo, :bar => nil, :baz => 'def_baz', :quux => 'the_quux'
+
+      def content
+        p "hi"
+      end
+    end
+
+    result = render(wc.new(:foo => 'the_foo', :bar => /whatever/i, :quux => 'the_quux'))
+    expect(result).to match(%r{^<!-- #{eb(wc)}: })
+    expect(result).to match(%r{:foo => \"the_foo\"})
+    expect(result).to match(%r{:bar => /whatever/i})
+    expect(result).to match(%r{:baz => \(DEFAULT\) \"def_baz\"})
+    expect(result).to match(%r{:quux => \"the_quux\"})
+    expect(result).to match(%r{ --><p>hi</p><!-- #{ee(wc)} -->$})
+  end
+
+  it "should not display extra assigns if we're not using them" do
+    wc = widget_class do
+      needs :foo
+      start_and_end_comments true
+
+      def content
+        p "hi"
+      end
+    end
+
+    expect(render(wc.new(:foo => 'bar', :bar => 'baz'))).to eq("<!-- #{eb(wc)}: " +
+      ":foo => \"bar\" --><p>hi</p><!-- #{ee(wc)} -->")
+  end
+
+  it "should display extra assigns if we're using them" do
+    wc = widget_class do
+      needs :foo
+      start_and_end_comments true
+      extra_assigns :use
+
+      def content
+        p "hi"
+      end
+    end
+
+    result = render(wc.new(:foo => 'bar', :bar => 'baz'))
+    expect(result).to match(%r{^<!-- #{eb(wc)}: })
+    expect(result).to match(%r{:foo => \"bar\"})
+    expect(result).to match(%r{:bar => \"baz\"})
+    expect(result).to match(%r{--><p>hi</p><!-- #{ee(wc)} -->})
+  end
+
+  it "should not display all of the text of long assigns" do
+    wc = widget_class do
+      needs :foo
+      start_and_end_comments true
+
+      def content
+        p "hi"
+      end
+    end
+
+    assigns = { :foo => "a" * 1000 }
+    text = render(wc.new(assigns))
+
+    expect(text).to match(%r{^<!-- #{eb(wc)}: :foo => \"aaaaa})
+    expect(text).to match(%r{aaa... --><p>hi</p><!-- #{ee(wc)} -->$})
+    expect(text.length).to be < 500
+    expect(text).not_to match("a" * 500)
+  end
+
+  it "should, by default, use #inspect, not #to_s, for assigns" do
+    obj = Object.new
+    class << obj
+      def to_s
+        "THIS IS TO_S"
+      end
+
+      def inspect
+        "THIS IS INSPECT"
+      end
+    end
+
+    wc = widget_class do
+      needs :foo
+      start_and_end_comments true
+
+      def content
+        p "hi"
+      end
+    end
+
+    expect(render(wc.new(:foo => obj))).to eq("<!-- #{eb(wc)}: " +
+      ":foo => THIS IS INSPECT --><p>hi</p><!-- #{ee(wc)} -->")
+  end
+
+  it "should allow overriding the text returned for assigns" do
+    obj = Object.new
+    class << obj
+      def to_s
+        "THIS IS TO_S"
+      end
+
+      def inspect
+        "THIS IS INSPECT"
+      end
+
+      def to_fortitude_comment_string
+        "THIS IS TO_FORTITUDE_COMMENT_STRING"
+      end
+    end
+
+    wc = widget_class do
+      needs :foo
+      start_and_end_comments true
+
+      def content
+        p "hi"
+      end
+    end
+
+    expect(render(wc.new(:foo => obj))).to eq("<!-- #{eb(wc)}: " +
+      ":foo => THIS IS TO_FORTITUDE_COMMENT_STRING --><p>hi</p><!-- #{ee(wc)} -->")
+  end
+
+  it "should order the comment text in whatever order the needs are declared" do
+    needed = [ ]
+    5.times { needed << "need#{rand(1_000_000_000)}".to_sym }
+    needed = needed.shuffle
+
+    wc = widget_class do
+      start_and_end_comments true
+
+      def content
+        p "hi"
+      end
+    end
+
+    remaining_needed = needed.dup
+    while remaining_needed.length > 0
+      this_slice = remaining_needed.shift(rand(3))
+      wc.needs *this_slice
+    end
+
+    params = { }
+    needed.shuffle.each { |n| params[n] = "value-#{n}" }
+
+    text = render(wc.new(params))
+
+    expected_output = "<!-- #{eb(wc)}: "
+    expected_output << needed.map do |n|
+      ":#{n} => \"value-#{n}\""
+    end.join(", ")
+    expected_output << " --><p>hi</p><!-- #{ee(wc)} -->"
+  end
+
+  it "should display the depth at which a widget is being rendered" do
+    inner = widget_class do
+      start_and_end_comments true
+      def content
+        text "hi!"
+      end
+    end
+
+    middle = widget_class do
+      start_and_end_comments true
+      cattr_accessor :klass
+      def content
+        widget klass.new
+      end
+    end
+
+    outer = widget_class do
+      start_and_end_comments true
+      cattr_accessor :klass
+      def content
+        widget klass.new
+      end
+    end
+
+    outer.klass = middle
+    middle.klass = inner
+
+    expect(render(outer)).to eq(
+      "<!-- #{eb(outer, 0)} -->" +
+      "<!-- #{eb(middle, 1)} -->" +
+      "<!-- #{eb(inner, 2)} -->" +
+      "hi!" +
+      "<!-- #{ee(inner, 2)} -->" +
+      "<!-- #{ee(middle, 1)} -->" +
+      "<!-- #{ee(outer, 0)} -->")
+  end
+
+  it "should display the depth at which a widget is being rendered, even if outer widgets aren't rendering comments" do
+    inner = widget_class do
+      start_and_end_comments true
+      def content
+        text "hi!"
+      end
+    end
+
+    middle = widget_class do
+      cattr_accessor :klass
+      def content
+        widget klass.new
+      end
+    end
+
+    outer = widget_class do
+      cattr_accessor :klass
+      def content
+        widget klass.new
+      end
+    end
+
+    outer.klass = middle
+    middle.klass = inner
+
+    expect(render(outer)).to eq(
+      "<!-- #{eb(inner, 2)} -->" +
+      "hi!" +
+      "<!-- #{ee(inner, 2)} -->")
+  end
+
+  it "should put comments on their own lines if we're formatting output" do
+    wc = widget_class do
+      start_and_end_comments true
+      format_output true
+
+      def content
+        text "hi"
+      end
+    end
+
+    expect(render(wc)).to eq(%{<!-- #{eb(wc)} -->
+hi
+<!-- #{ee(wc)} -->})
+  end
+
+  it "should put comments on their own lines, nested inside another widget, if we're formatting output" do
+    outer = widget_class do
+      format_output true
+      cattr_accessor :klass
+
+      def content
+        div do
+          div do
+            widget klass.new
+          end
+        end
+      end
+    end
+
+    inner = widget_class do
+      start_and_end_comments true
+      format_output true
+
+      def content
+        text "hi"
+      end
+    end
+
+    outer.klass = inner
+    expect(render(outer)).to eq(%{<div>
+  <div>
+    <!-- #{eb(inner, 1)} -->
+    hi
+    <!-- #{ee(inner, 1)} -->
+  </div>
+</div>})
+  end
+
+  it "should put assignments on their own lines, with indentation, if they're long enough and we're formatting output" do
+    outer = widget_class do
+      format_output true
+      cattr_accessor :klass
+
+      def content
+        div do
+          div do
+            widget klass.new(:foo => "a" * 1000, :bar => "b" * 1000)
+          end
+        end
+      end
+    end
+
+    inner = widget_class do
+      needs :foo, :bar
+      start_and_end_comments true
+      format_output true
+
+      def content
+        text "hi"
+      end
+    end
+
+    outer.klass = inner
+
+    result = render(outer)
+    expect(result).to match(%r{^<div>\n  <div>\n    <!-- #{eb(inner, 1)}:\n         :}m)
+    expect(result).to match(%r{^         :foo => \"a{97}...\n})
+    expect(result).to match(%r{^         :bar => \"b{97}...\n})
+    expect(result).to match(%r{^     -->$})
+    expect(result).to match(%r{^    hi})
+    expect(result).to match(%r{^    <!-- #{ee(inner, 1)} -->\n  </div>\n</div>$}m)
+  end
+
+  BAD_VALUES = [ ">foo", "fo -- bar", "--", "->bar", "baz-" ]
+
+  BAD_VALUES.each do |bad_value|
+    it "should escape any potentially invalid-comment text in assign values, like #{bad_value.inspect}" do
+      wc = widget_class do
+        needs :foo
+        start_and_end_comments true
+
+        def content
+          p "hi"
+        end
+      end
+
+      instance = wc.new(:foo => bad_value)
+      text = render(instance)
+      # expect(text).to match(%r{^<!-- #{eb(wc)}: :foo => (.*) --><p>hi</p><!-- #{ee(wc)} -->$})
+      if text =~ %r{^<!-- #{eb(wc)}: :foo => (.*) --><p>hi</p><!-- #{ee(wc)} -->$}
+        data = $1
+        expect(data).not_to match(/\-\-/)
+      else
+        raise "Text does not match: #{text.inspect}"
+      end
+    end
+  end
+end