fortitude 0.0.1

data/spec/system/needs_system_spec.rb

@@ -0,0 +1,368 @@
+describe "Fortitude needs", :type => :system do
+  def required
+    Fortitude::Widget::REQUIRED_NEED
+  end
+
+  it "should return the current needs from .needs, with or without arguments" do
+    parent = widget_class
+    child = widget_class(:superclass => parent)
+
+    expect(parent.needs).to eq({ })
+    expect(parent.needs(:foo)).to eq(:foo => required)
+    expect(parent.needs(:bar => 'def_bar')).to eq(:foo => required, :bar => 'def_bar')
+
+    expect(child.needs).to eq(:foo => required, :bar => 'def_bar')
+    expect(child.needs(:bar)).to eq(:foo => required, :bar => required)
+    expect(child.needs(:baz => 'def_baz')).to eq(:foo => required, :bar => required, :baz => 'def_baz')
+  end
+
+  it "should allow you to override a 'needs' method, and use #super" do
+    klass = widget_class do
+      needs :foo
+
+      def foo
+        "xx" + super + "yy"
+      end
+
+      def content
+        p "foo is: #{foo}"
+      end
+    end
+
+    expect(render(klass.new(:foo => 'aaa'))).to eq("<p>foo is: xxaaayy</p>")
+  end
+
+  describe "shadowing" do
+    it "should shadow tags with needs, not the other way around" do
+      klass = widget_class do
+        needs :p, :div => 'whatever'
+
+        def content
+          text "p is: #{p}, div is: #{div}"
+        end
+      end
+
+      expect(render(klass.new(:p => 'aaa'))).to eq("p is: aaa, div is: whatever")
+    end
+
+    it "should still allow access to tags using tag_*" do
+      klass = widget_class do
+        needs :p, :div => 'whatever'
+
+        def content
+          tag_p "this is a p"
+          tag_div "this is a div"
+          text "p is: #{p}, div is: #{div}"
+        end
+      end
+
+      expect(render(klass.new(:p => 'bbb'))).to eq("<p>this is a p</p><div>this is a div</div>p is: bbb, div is: whatever")
+    end
+
+    it "should still allow access to text, comment, rawtext, and javascript using tag_*" do
+      klass = widget_class do
+        needs :text => 'foo', :comment => 'bar', :rawtext => 'baz', :javascript => 'quux'
+
+        def content
+          tag_text "text is: #{text}"
+          tag_comment "comment is: #{comment}"
+          tag_rawtext "rawtext is: #{rawtext}"
+          tag_javascript "javascript is: #{javascript}"
+        end
+      end
+
+      expect(render(klass)).to eq(%{text is: foo<!-- comment is: bar -->rawtext is: baz<script>javascript is: quux</script>})
+    end
+
+    it "should raise an error if you pass a block to a 'needs' method and debugging is on" do
+      klass = widget_class do
+        debug true
+        needs :p
+
+        def content
+          p { text "this is not run" }
+          text "p is: #{p}"
+        end
+      end
+
+      expect { render(klass.new(:p => 'aaa')) }.to raise_error(Fortitude::Errors::BlockPassedToNeedMethod)
+    end
+
+    it "should not raise an error if you pass a block to a 'needs' method and debugging is off" do
+      klass = widget_class do
+        needs :p
+
+        def content
+          p { text "this is not run" }
+          text "p is: #{p}"
+        end
+      end
+
+      expect(render(klass.new(:p => 'aaa'))).to eq("p is: aaa")
+    end
+  end
+
+  describe "names" do
+    BAD_METHOD_NAMES = [ " ", "0123", "0foo", "?baz", "!yo", "!", "?", "abc??" ]
+
+    BAD_METHOD_NAMES.each do |bad_method_name|
+      it "should fail if you try to use a name for a need that's not a valid method name, like #{bad_method_name.inspect}" do
+        expect { widget_class { needs bad_method_name } }.to raise_error(ArgumentError)
+        expect { widget_class { needs bad_method_name.to_sym } }.to raise_error(ArgumentError)
+      end
+
+      it "should ignore any extra assigns that aren't valid method names, like #{bad_method_name.inspect}" do
+        wc = widget_class do
+          extra_assigns :use
+
+          def content
+            rawtext assigns.to_hash.inspect
+          end
+        end
+
+        expect(render(wc.new(bad_method_name => "foobar", :foo => 'bar'))).to eq("{:foo=>\"bar\"}")
+      end
+    end
+
+    VALID_METHOD_NAMES = [ "o01239014", "______", "_", "foo?", "bar!", "_0123" ]
+
+    VALID_METHOD_NAMES.each do |valid_method_name|
+      it "should allow you to use corner-case names for a need, like #{valid_method_name.inspect}" do
+        wc = widget_class do
+          needs valid_method_name.to_sym
+
+          attr_accessor :method_name
+
+          def content
+            eval("p \"value: \#{#{method_name}}\"")
+          end
+        end
+
+        i = wc.new(valid_method_name => "foo")
+        i.method_name = valid_method_name
+
+        expect(render(i)).to eq("<p>value: foo</p>")
+      end
+
+      it "should allow you to pass corner-case names for an extra assign, like #{valid_method_name.inspect}" do
+        wc = widget_class do
+          extra_assigns :use
+
+          attr_accessor :method_name
+
+          def content
+            eval("p \"value: \#{#{method_name}}\"")
+          end
+        end
+
+        i = wc.new(valid_method_name => "foo")
+        i.method_name = valid_method_name
+
+        expect(render(i)).to eq("<p>value: foo</p>")
+      end
+    end
+  end
+
+  describe "inheritance" do
+    it "should require needs from all superclasses" do
+      grandparent = widget_class { needs :foo }
+      parent = widget_class(:superclass => grandparent) { needs :bar }
+      child = widget_class(:superclass => parent) do
+        needs :baz
+        def content
+          text "foo: #{foo}, bar: #{bar}, baz: #{baz}"
+        end
+      end
+
+      expect { child.new }.to raise_error(Fortitude::Errors::MissingNeed)
+      expect { child.new(:foo => 'f') }.to raise_error(Fortitude::Errors::MissingNeed)
+      expect { child.new(:foo => 'f', :bar => 'b') }.to raise_error(Fortitude::Errors::MissingNeed)
+      expect(render(child.new(:foo => 'f', :bar => 'b', :baz => 'z'))).to eq("foo: f, bar: b, baz: z")
+
+      expect(grandparent.needs).to eq({ :foo => required })
+      expect(parent.needs).to eq({ :foo => required, :bar => required })
+      expect(child.needs).to eq({ :foo => required, :bar => required, :baz => required })
+    end
+
+    it "should let you add needs later, and it should apply to both that class and any subclasses" do
+      parent = widget_class_with_content { text "parent" }
+      child = widget_class(:superclass => parent) do
+        needs :bar
+        def content
+          super
+          text "; child: bar: #{bar}"
+        end
+      end
+
+      expect(render(parent)).to eq("parent")
+      expect(render(child.new(:bar => "the_bar"))).to eq("parent; child: bar: the_bar")
+      expect(parent.needs).to eq({ })
+      expect(child.needs).to eq({ :bar => required })
+
+      parent.class_eval { needs :foo }
+      child.class_eval do
+        def content
+          super
+          text "; child: bar: #{bar}; foo: #{foo}"
+        end
+      end
+
+      expect { parent.new }.to raise_error(Fortitude::Errors::MissingNeed)
+      expect { child.new(:bar => 'the_bar') }.to raise_error(Fortitude::Errors::MissingNeed)
+
+      expect(render(parent.new(:foo => "the_foo"))).to eq("parent")
+      expect(render(child.new(:foo => "the_foo", :bar => "the_bar"))).to eq("parent; child: bar: the_bar; foo: the_foo")
+
+      expect(parent.needs).to eq(:foo => required)
+      expect(child.needs).to eq(:foo => required, :bar => required)
+    end
+  end
+
+  describe "defaults" do
+    it "should allow supplying defaults, and allow overriding them" do
+      c = widget_class do
+        needs :foo, :bar => 'def_bar', :baz => 'def_baz'
+        def content
+          text "foo: #{foo}, bar: #{bar}, baz: #{baz}"
+        end
+      end
+
+      expect { c.new }.to raise_error(Fortitude::Errors::MissingNeed)
+      expect(render(c.new(:foo => 'the_foo'))).to eq("foo: the_foo, bar: def_bar, baz: def_baz")
+      expect(render(c.new(:foo => 'the_foo', :baz => 'the_baz'))).to eq("foo: the_foo, bar: def_bar, baz: the_baz")
+
+      expect(c.needs).to eq(:foo => required, :bar => 'def_bar', :baz => 'def_baz')
+    end
+
+    it "should inherit defaults properly" do
+      parent = widget_class do
+        needs :foo, :bar => 'def_bar', :baz => 'def_baz'
+        def content
+          text "foo: #{foo}, bar: #{bar}, baz: #{baz}"
+        end
+      end
+
+      child = widget_class(:superclass => parent) do
+        needs :baz => 'child_def_baz', :quux => 'child_quux'
+        def content
+          super
+          text "; baz: #{baz}, quux: #{quux}"
+        end
+      end
+
+      expect(render(parent.new(:foo => 'the_foo'))).to eq('foo: the_foo, bar: def_bar, baz: def_baz')
+      expect { child.new }.to raise_error(Fortitude::Errors::MissingNeed)
+      expect(render(child.new(:foo => 'the_foo'))).to eq('foo: the_foo, bar: def_bar, baz: child_def_baz; baz: child_def_baz, quux: child_quux')
+
+      expect(parent.needs).to eq(:foo => required, :bar => 'def_bar', :baz => 'def_baz')
+      expect(child.needs).to eq(:foo => required, :bar => 'def_bar', :baz => 'child_def_baz', :quux => 'child_quux')
+    end
+
+    it "should allow overriding a default with a requirement" do
+      parent = widget_class do
+        needs :foo, :bar => 'def_bar'
+      end
+
+      child = widget_class(:superclass => parent) do
+        needs :bar
+        def content
+          text "foo: #{foo}, bar: #{bar}"
+        end
+      end
+
+      expect { child.new(:foo => 'the_foo') }.to raise_error(Fortitude::Errors::MissingNeed)
+      expect(render(child.new(:foo => 'the_foo', :bar => 'the_bar'))).to eq('foo: the_foo, bar: the_bar')
+
+      expect(parent.needs).to eq(:foo => required, :bar => 'def_bar')
+      expect(child.needs).to eq(:foo => required, :bar => required)
+    end
+
+    it "should allow overriding a requirement with a default" do
+      parent = widget_class do
+        needs :foo, :bar
+      end
+
+      child = widget_class(:superclass => parent) do
+        needs :foo => 'def_foo', :bar => 'def_bar'
+        def content
+          text "foo: #{foo}, bar: #{bar}"
+        end
+      end
+
+      expect(render(child.new)).to eq('foo: def_foo, bar: def_bar')
+      expect(render(child.new(:bar => 'the_bar'))).to eq('foo: def_foo, bar: the_bar')
+
+      expect(parent.needs).to eq(:foo => required, :bar => required)
+      expect(child.needs).to eq(:foo => 'def_foo', :bar => 'def_bar')
+    end
+  end
+
+  describe "extra assigns" do
+    it "should, by default, ignore assigns it doesn't need" do
+      c = widget_class do
+        needs :foo
+        def content
+          bar_value = begin
+            bar
+          rescue => e
+            e.class.name
+          end
+
+          text "foo: #{foo}, bar: #{bar_value}"
+        end
+      end
+
+      expect(render(c.new(:foo => 'the_foo', :bar => 'the_bar'))).to eq('foo: the_foo, bar: NameError')
+    end
+
+    it "should ignore assigns it doesn't need, if told to" do
+      c = widget_class do
+        extra_assigns :ignore
+        needs :foo
+        def content
+          bar_value = begin
+            bar
+          rescue => e
+            e.class.name
+          end
+
+          text "foo: #{foo}, bar: #{bar_value}"
+        end
+      end
+
+      expect(render(c.new(:foo => 'the_foo', :bar => 'the_bar'))).to eq('foo: the_foo, bar: NameError')
+    end
+
+    it "should fail if passed assigns it doesn't need, if asked to" do
+      c = widget_class do
+        extra_assigns :error
+        needs :foo
+        def content
+          text "foo: #{foo}"
+        end
+      end
+
+      expect { c.new(:foo => 'the_foo', :bar => 'the_bar') }.to raise_error(Fortitude::Errors::ExtraAssigns, /bar/i)
+      expect(render(c.new(:foo => 'the_foo'))).to eq("foo: the_foo")
+    end
+
+    it "should use extra assigns it doesn't need, if asked to" do
+      c = widget_class do
+        extra_assigns :use
+        needs :foo
+        def content
+          bar_value = begin
+            bar
+          rescue => e
+            e.class.name
+          end
+
+          text "foo: #{foo}; bar: #{bar_value}"
+        end
+      end
+
+      expect(render(c.new(:foo => 'the_foo'))).to eq('foo: the_foo; bar: NameError')
+      expect(render(c.new(:foo => 'the_foo', :bar => 'the_bar'))).to eq('foo: the_foo; bar: the_bar')
+    end
+  end
+end

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