html2fortitude 0.0.1

data/spec/system/needs_system_spec.rb

@@ -0,0 +1,73 @@
+describe "html2fortitude 'needs' conversion" do
+  it "should produce no needs if there are no needs" do
+    result = h2f("hello, world")
+    expect(result.needs).to eq({ })
+    expect(result.content_text).to eq("text \"hello, world\"")
+  end
+
+  it "should produce a single need, mapped to nil, if there's just one" do
+    result = h2f("hello, <%= @foo %>")
+    expect(result.needs).to eq({ ":foo" => "nil" })
+    expect(result.content_text).to eq(%{text "hello, "
+text(foo)})
+  end
+
+  it "should produce multiple needs, mapped to nil, if there are multiple" do
+    result = h2f("hello, <%= @foo + @bar %>, <%= @baz %>")
+    expect(result.needs).to eq({
+      ":foo" => "nil", ":bar" => "nil", ":baz" => "nil"
+    })
+    expect(result.content_text).to eq(%{text "hello, "
+text(foo + bar)
+text ", "
+text(baz)})
+  end
+
+  it "should produce needs with no mapping if asked to" do
+    result = h2f("hello, <%= @foo %>", :assigns => :required_needs)
+    expect(result.needs).to eq({ ":foo" => nil })
+    expect(result.content_text).to eq(%{text "hello, "
+text(foo)})
+  end
+
+  it "should produce multiple needs with no mapping if asked to" do
+    result = h2f("hello, <%= @foo + @bar %>", :assigns => :required_needs)
+    expect(result.needs).to eq({ ":foo" => nil, ":bar" => nil })
+    expect(result.content_text).to eq(%{text "hello, "
+text(foo + bar)})
+  end
+
+  it "should turn off needs entirely if asked to" do
+    result = h2f("hello, <%= @foo + @bar %>", :assigns => :no_needs)
+    expect(result.needs).to eq({ })
+    expect(result.content_text).to eq(%{text "hello, "
+text(foo + bar)})
+  end
+
+  it "should produce instance variables in text if asked to" do
+    result = h2f("hello, <%= @foo + @bar %>", :assigns => :instance_variables)
+    expect(result.needs).to eq({ ":foo" => "nil", ":bar" => "nil" })
+    expect(result.content_text).to eq(%{text "hello, "
+text(@foo + @bar)})
+  end
+
+  it "should extract 'needs' from loud ERb" do
+    result = h2f("hello, <%= @foo %>")
+    expect(result.needs).to eq({ ":foo" => "nil" })
+    expect(result.content_text).to eq(%{text "hello, "
+text(foo)})
+  end
+
+  it "should extract 'needs' from silent ERb" do
+    result = h2f("hello, <% @foo %>")
+    expect(result.needs).to eq({ ":foo" => "nil" })
+    expect(result.content_text).to eq(%{text "hello, "
+foo})
+  end
+
+  it "should extract 'needs' from code used as a direct argument to a tag" do
+    result = h2f("<p><%= @foo %></p>")
+    expect(result.needs).to eq({ ":foo" => "nil" })
+    expect(result.content_text).to eq(%{p(foo)})
+  end
+end

data/spec/system/options_system_spec.rb

@@ -0,0 +1,43 @@
+describe "html2fortitude options support" do
+  it "should generate a class descending from Fortitude::Widget::Html5 by default" do
+    result = h2f("hello, world", :class_name => "Some::Class::Name")
+    expect(result.class_name).to eq("Some::Class::Name")
+    expect(result.superclass).to eq("Fortitude::Widget::Html5")
+  end
+
+  it "should generate a class inheriting from the given class if asked to" do
+    result = h2f("hello, world", :class_name => "Some::Other::ClassName", :superclass => "My::Base")
+    expect(result.class_name).to eq("Some::Other::ClassName")
+    expect(result.superclass).to eq("My::Base")
+  end
+
+  it "should generate a method named 'content' by default" do
+    result = h2f("hello, world")
+    expect(result.method_name).to eq("content")
+  end
+
+  it "should generate a method with a different name if asked to" do
+    result = h2f("hello, world", :method => "foobar")
+    expect(result.method_name).to eq("foobar")
+  end
+
+  it "should use { ... } for tag content by default" do
+    expect(h2f_content("<p><span>hi</span></p>")).to eq(%{p {
+  span("hi")
+}})
+  end
+
+  it "should use do ... end instead of { ... } for tag content if asked to" do
+    expect(h2f_content("<p><span>hi</span></p>", :do_end => true)).to eq(%{p do
+  span("hi")
+end})
+  end
+
+  it "should use Ruby 1.8-style Hashes by default" do
+    expect(h2f_content("<p class=\"foo\"/>")).to eq(%{p(:class => "foo")})
+  end
+
+  it "should use Ruby 1.9-style Hashes if asked to" do
+    expect(h2f_content("<p class=\"foo\"/>", :new_style_hashes => true)).to eq(%{p(class: "foo")})
+  end
+end

data/spec/system/other_stuff_system_spec.rb

@@ -0,0 +1,39 @@
+describe "html2fortitude 'other stuff' support" do
+  it "should emit XML Processing Instructions correctly" do
+    expect(h2f_content("<?xml version=\"1.0\" encoding=\"UTF-8\"?>")).to eq(
+      %{rawtext("<?xml version=\"1.0\" encoding=\"UTF-8\"?>")})
+  end
+
+  it "should emit CDATA correctly" do
+    expect(h2f_content(%{hello <![CDATA[
+foo
+bar
+]]>
+world})).to eq(%{text "hello "
+cdata <<-END_OF_CDATA_CONTENT
+foo
+bar
+END_OF_CDATA_CONTENT
+text "world"})
+  end
+
+  it "should emit DTDs correctly" do
+    expect(h2f_content(%{<!DOCTYPE html>})).to eq(%{doctype!})
+  end
+
+  it "should emit comments correctly" do
+    expect(h2f_content(%{hello <!-- something here --> world})).to eq(%{text "hello "
+comment "something here"
+text " world"})
+  end
+
+  it "should emit multiline comments correctly" do
+    expect(h2f_content(%{hello <!-- something
+here
+yo --> world})).to eq(%{text "hello "
+comment %{something
+here
+yo}
+text " world"})
+  end
+end

data/spec/system/rails_system_spec.rb

@@ -0,0 +1,9 @@
+describe "html2fortitude Rails support" do
+  it "should output calls to Rails helpers normally" do
+    expect(h2f_content(%{<%= distance_of_time_in_words 5.minutes.from_now %>})).to eq(%{text(distance_of_time_in_words 5.minutes.from_now)})
+  end
+
+  it "should not output calls to Rails helpers that are transformed to output already" do
+    expect(h2f_content(%{<%= image_tag 'foo' %>})).to eq(%{image_tag 'foo'})
+  end
+end

data/spec/system/tags_system_spec.rb

@@ -0,0 +1,252 @@
+describe "html2fortitude tags handling" do
+  it "should render a very simple tag with just its name" do
+    expect(h2f_content("<p/>")).to eq(%{p})
+    expect(h2f_content("<p></p>")).to eq(%{p})
+  end
+
+  it "should render a very simple tag with attributes" do
+    expect(h2f_content(%{<p foo="bar"/>})).to eq(%{p(:foo => "bar")})
+  end
+
+  it "should render several tags back-to-back correctly" do
+    expect(h2f_content(%{<p/><br/><p/>})).to eq(%{p
+br
+p})
+  end
+
+  it "should render several tags with attributes back-to-back correctly" do
+    expect(h2f_content(%{<p foo="bar"/><br bar="foo"/><p bar="baz"/>})).to eq(%{p(:foo => "bar")
+br(:bar => "foo")
+p(:bar => "baz")})
+  end
+
+  it "should render multiple attributes properly" do
+    result = h2f_content(%{<p foo="bar" bar="baz"/>})
+
+    expect(result).to match(%r{^p\(:[a-z].*"\)$})
+    expect(result).to match(%r{:foo => "bar"})
+    expect(result).to match(%r{:bar => "baz"})
+  end
+
+  it "should render attributes that aren't simple Symbols properly" do
+    expect(h2f_content(%{<p foo-bar="baz"/>})).to eq(%{p("foo-bar" => "baz")})
+  end
+
+  it "should render attributes that have dynamic values properly" do
+    expect(h2f_content(%{<p foo="<%= bar %>"})).to eq(%{p(:foo => bar)})
+  end
+
+  it "should render attributes that have partially dynamic values properly" do
+    expect(h2f_content(%{<p foo="baz <%= bar %> quux"})).to eq(%{p(:foo => "baz \#{bar} quux")})
+  end
+
+  it "should render attributes that have a mix of dynamic and static content for their values properly" do
+    expect(h2f_content(%{<p foo="bar <%= baz %> quux"/>})).to eq(%{p(:foo => "bar \#{baz} quux")})
+  end
+
+  it "should render attributes that have a dynamic key properly" do
+    pending "This doesn't work; html2haml's <haml_loud> system fouls up Nokogiri too badly here"
+    expect(h2f_content(%{<p <%= foo %>="bar"/>})).to eq(%{p foo => "bar"})
+  end
+
+  it "should render attributes that have a mix of dynamic and static content for their keys properly" do
+    pending "This doesn't work; html2haml's <haml_loud> system fouls up Nokogiri too badly here"
+    expect(h2f_content(%{<p foo<%= bar %>baz="bar"/>})).to eq(%{p "foo\#{bar}baz" => "bar"})
+  end
+
+  it "should render a tag containing another tag correctly" do
+    expect(h2f_content(%{<p><br/></p>})).to eq(%{p {
+  br
+}})
+  end
+
+  it "should render a tag containing text correctly" do
+    expect(h2f_content(%{<p>hello, world</p>})).to eq(%{p("hello, world")})
+  end
+
+  it "should render a tag containing text with newlines correctly" do
+    expect(h2f_content(%{<p>hello,
+world</p>})).to eq(%{p(%{hello,
+world})})
+  end
+
+  it "should render a tag with a single child of loud output correctly" do
+    expect(h2f_content(%{<p><%= foo %></p>})).to eq(%{p(foo)})
+  end
+
+  it "should render a tag with multiple children of loud output correctly" do
+    expect(h2f_content(%{<p><%= foo %><%= bar %></p>})).to eq(%{p {
+  text(foo)
+  text(bar)
+}})
+  end
+
+  it "should render a tag with a single child of multiline loud output correctly" do
+    expect(h2f_content(%{<p><%=
+x = 123
+x += 200
+x
+%></p>})).to eq(%{p {
+  x = 123
+  x += 200
+  text(x)
+}})
+  end
+
+  it "should render a tag with a single child of loud output with a semicolon correctly" do
+    expect(h2f_content(%{<p><%= x = 123; x += 200; x %></p>})).to eq(%{p {
+  text(x = 123; x += 200; x)
+}})
+  end
+
+  it "should render a tag with a single child of loud output and attributes correctly" do
+    expect(h2f_content(%{<p aaa="bbb" ccc="ddd"><%= foo %></p>})).to eq(%{p(foo, :aaa => "bbb", :ccc => "ddd")})
+  end
+
+  it "should render a tag with a single child of loud output that needs parentheses and attributes correctly" do
+    expect(h2f_content(%{<p aaa="bbb" ccc="ddd"><%= foo :bar, :baz %></p>})).to eq(%{p((foo :bar, :baz), :aaa => "bbb", :ccc => "ddd")})
+  end
+
+  it "should render a tag with a single child of quiet output correctly" do
+    expect(h2f_content(%{<p><% foo %></p>})).to eq(%{p {
+  foo
+}})
+  end
+
+  it "should render a tag with multiple children of quiet output correctly" do
+    expect(h2f_content(%{<p><% foo %><% bar %></p>})).to eq(%{p {
+  foo
+  bar
+}})
+  end
+
+  it "should render a tag with intermixed quiet and loud output correctly" do
+    expect(h2f_content(%{<p><% foo %><%= bar %><% baz %><%= quux %></p>})).to eq(%{p {
+  foo
+  text(bar)
+  baz
+  text(quux)
+}})
+  end
+
+  it "should turn <script type=\"text/javascript\"> into javascript <<-EOJC ... EOJC" do
+    expect(h2f_content(%{<script type="text/javascript">
+foo
+bar
+baz
+</script>})).to eq(%{javascript <<-END_OF_JAVASCRIPT_CONTENT
+foo
+bar
+baz
+END_OF_JAVASCRIPT_CONTENT})
+  end
+
+  it "should remove CDATA from within 'javascript'" do
+    expect(h2f_content(%{<script type="text/javascript">
+<![CDATA[
+foo
+bar
+baz
+]]>
+</script>})).to eq(%{javascript <<-END_OF_JAVASCRIPT_CONTENT
+foo
+bar
+baz
+END_OF_JAVASCRIPT_CONTENT})
+  end
+
+  it "should turn <script language=\"javascript\"> into javascript <<-EOJC ... EOJC" do
+    expect(h2f_content(%{<script language="javascript">
+foo
+bar
+baz
+</script>})).to eq(%{javascript <<-END_OF_JAVASCRIPT_CONTENT
+foo
+bar
+baz
+END_OF_JAVASCRIPT_CONTENT})
+  end
+
+  it "should turn <script type=\"text/javascript\"> with additional attributes into javascript <<-EOJC ... EOJC with those attributes" do
+    expect(h2f_content(%{<script type="text/javascript" id="bar">
+foo
+bar
+baz
+</script>})).to eq(%{javascript <<-END_OF_JAVASCRIPT_CONTENT, :id => "bar"
+foo
+bar
+baz
+END_OF_JAVASCRIPT_CONTENT})
+  end
+
+  it "should turn other <script> blocks into just script <<-EOSC ... EOSC" do
+    expect(h2f_content(%{<script type="text/vbscript">
+foo
+bar
+baz
+</script>})).to eq(%{script <<-END_OF_SCRIPT_CONTENT, :type => "text/vbscript"
+foo
+bar
+baz
+END_OF_SCRIPT_CONTENT})
+  end
+
+  it "should include attributes in other <script> blocks" do
+    result = h2f_content(%{<script type="text/vbscript" id="bar">
+foo
+bar
+baz
+</script>})
+
+    if result =~ /^script <<-END_OF_SCRIPT_CONTENT, (.*)$/
+      attributes = $1
+
+      expect([
+        %{:type => "text/vbscript", :id => "bar"},
+        %{:id => "bar", :type => "text/vbscript"}
+      ]).to be_include(attributes)
+    else
+      raise "No match: #{script}"
+    end
+
+    expect(result).to match(/^script <<-END_OF_SCRIPT_CONTENT, .*\nfoo\nbar\nbaz\nEND_OF_SCRIPT_CONTENT$/mi)
+  end
+
+  it "should turn <style> tags into style <<-EOSC ... EOSC" do
+    expect(h2f_content(%{<style>
+foo
+bar
+baz
+</style>})).to eq(%{style <<-END_OF_STYLE_CONTENT
+foo
+bar
+baz
+END_OF_STYLE_CONTENT})
+  end
+
+  it "should remove CDATA from within 'style'" do
+    expect(h2f_content(%{<style type="text/css">
+<![CDATA[
+foo
+bar
+baz
+]]>
+</style>})).to eq(%{style <<-END_OF_STYLE_CONTENT, :type => "text/css"
+foo
+bar
+baz
+END_OF_STYLE_CONTENT})
+  end
+
+  it "should turn <style> tags with an attribute into style <<-EOSC, <attribute> ... EOSC" do
+    expect(h2f_content(%{<style id="foo">
+foo
+bar
+baz
+</style>})).to eq(%{style <<-END_OF_STYLE_CONTENT, :id => "foo"
+foo
+bar
+baz
+END_OF_STYLE_CONTENT})
+  end
+end

data/spec/system/text_system_spec.rb

@@ -0,0 +1,106 @@
+describe "html2fortitude text translation" do
+  it "should render simple text with #text" do
+    expect(h2f_content("hello, world")).to eq(%{text "hello, world"})
+  end
+
+  it "should escape '\#{' sequences in its input" do
+    expect(h2f_content("hello, \#{world}")).to eq(%{text "hello, \\\#{world}"})
+  end
+
+  it "should properly escape text that requires escaping" do
+    expect(h2f_content("hello, \"world")).to eq(%{text "hello, \\\"world"})
+  end
+
+  it "should not escape text that doesn't require escaping" do
+    expect(h2f_content("hello, \'world")).to eq(%{text "hello, 'world"})
+  end
+
+  it "should properly handle multiline text" do
+    expect(h2f_content(%{hello
+
+world})).to eq(%{text %{hello
+
+world}})
+  end
+
+  it "should properly handle multiline text with a } in it" do
+    result = h2f_content(<<-EOS)
+hello
+}
+world
+EOS
+    expect(result).to eq(<<-EOS.rstrip)
+text %{hello
+\\}
+world}
+EOS
+  end
+
+  it "should not output empty space" do
+    expect(h2f_content("")).to eq("")
+    expect(h2f_content("    ")).to eq("")
+  end
+
+  it "should allow dynamic content in text" do
+    expect(h2f_content("hello, <% abc %> world")).to eq(
+      %{text "hello, "
+abc
+text " world"})
+  end
+
+  it "should allow loud dynamic content in text" do
+    expect(h2f_content("hello, <%= abc %> world")).to eq(%{text "hello, "
+text(abc)
+text " world"})
+  end
+
+  it "should allow multiline dynamic content in text" do
+    expect(h2f_content(%{hello, <% abc
+def(a, "b")
+ghi %>
+world})).to eq(%{text "hello, "
+abc
+def(a, "b")
+ghi
+
+text "world"})
+  end
+
+  it "should allow loud multiline dynamic content in text" do
+    expect(h2f_content(%{hello, <%= abc
+def(a, "b")
+ghi %>
+world})).to eq(%{text "hello, "
+abc
+def(a, "b")
+text(ghi)
+
+text "world"})
+  end
+
+  it "should eliminate whitespace before a tag" do
+    expect(h2f_content(%{bar
+
+
+<p/>})).to eq(%{text "bar"
+
+
+
+p})
+  end
+
+
+  it "should eliminate whitespace after a tag" do
+    expect(h2f_content(%{<p/>
+
+
+bar})).to eq(%{p
+
+
+text "bar"})
+  end
+
+  it "should skip 'text'/'rawtext' when calling 'render'" do
+    expect(h2f_content(%{<%= render :partial => 'foo/bar' %>})).to eq(%{render :partial => 'foo/bar'})
+  end
+end