undies 2.2.1 → 3.0.0.rc.1

data/test/element_test.rb

@@ -1,57 +1,28 @@
 require "assert"
-
-require 'undies/node'
-require "undies/output"
-require "undies/template"
-
+require 'undies/io'
 require "undies/element"
 
 
-class Undies::Element
-
-  class BasicTests < Assert::Context
-    desc 'an element'
-    before do
-      @e = Undies::Element.new(:div)
-    end
-    subject { @e }
-
-    should have_class_methods :hash_attrs
-    should have_instance_method :prefix, :to_str
-
-    should "be a Node" do
-      assert_kind_of Undies::Node, subject
-    end
+module Undies::Element
 
-    should "store its name as a string" do
-      assert_equal "div", subject.instance_variable_get("@name")
-    end
+  class ElementBasicTests < Assert::Context
+    desc 'a element'
+    subject { Undies::Element }
 
-    should "know its name" do
-      assert_equal "div", subject.class.node_name(subject)
-    end
+    should have_instance_methods :hash_attrs, :escape_attr_value
+    should have_instance_methods :open, :closed
 
-    should "know its start/end tags" do
-      assert_equal "<div />", subject.class.start_tag(subject)
-      assert_empty subject.class.end_tag(subject)
+    should "build an open element with the `open` method" do
+      assert_kind_of Undies::Element::Open, subject.open(:div)
     end
 
-    should "have no content itself" do
-      assert_empty subject.class.content(subject)
-    end
-
-    should "have no builds by default" do
-      assert_empty subject.class.builds(subject)
-      assert_empty subject.class.builds(nil)
-    end
-
-    should "have no children by default" do
-      assert_equal false, subject.class.children(subject)
+    should "build a closed element with the `closed` method" do
+      assert_kind_of Undies::Element::Closed, subject.closed(:br)
     end
 
   end
 
-  class HashAttrsTest < BasicTests
+  class HashAttrsTest < ElementBasicTests
     desc "the element class hash_attrs util"
 
     should "convert an empty hash to element attrs" do
@@ -83,6 +54,17 @@ class Undies::Element
       assert_includes 'escaped="not &amp; escaped"', attrs
     end
 
+    should "convert a nested array to element attrs" do
+      attrs = Undies::Element.hash_attrs({
+        :class => "testing", :id => "test_2",
+        :nested => [:something, 'is_awesome', 1]
+      })
+      assert_match /^\s{1}/, attrs
+      assert_included 'class="testing"', attrs
+      assert_included 'id="test_2"', attrs
+      assert_included 'nested="something is_awesome 1"', attrs
+    end
+
     should "convert a nested hash to element attrs" do
       attrs = Undies::Element.hash_attrs({
         :class => "testing", :id => "test_2",
@@ -95,159 +77,4 @@ class Undies::Element
     end
   end
 
-
-  class CSSProxyTests < BasicTests
-
-    should "respond to any method ending in '!' as an id proxy" do
-      assert subject.respond_to?(:asdgasdg!)
-    end
-
-    should "proxy id attr with methods ending in '!'" do
-      assert_equal({
-        :id => 'thing1'
-      }, subject.class.attrs(subject.thing1!))
-    end
-
-    should "proxy id attr with last method call ending in '!'" do
-      assert_equal({
-        :id => 'thing2'
-      }, subject.class.attrs(subject.thing1!.thing2!))
-    end
-
-    should "set id attr to explicit if called last " do
-      assert_equal({
-        :id => 'thing3'
-      }, subject.class.attrs(subject.thing1!.thing2!(:id => 'thing3')))
-    end
-
-    should "set id attr to proxy if called last" do
-      assert_equal({
-        :id => 'thing1'
-      }, subject.class.attrs(subject.thing2!(:id => 'thing3').thing1!))
-    end
-
-    should "respond to any other method as a class proxy" do
-      assert_respond_to :asdgasdg, subject
-    end
-
-    should "proxy single html class attr" do
-      assert_equal({
-        :class => 'thing'
-      }, subject.class.attrs(subject.thing))
-    end
-
-    should "proxy multi html class attrs" do
-      assert_equal({
-        :class => 'list thing awesome'
-      }, subject.class.attrs(subject.list.thing.awesome))
-    end
-
-    should "set class attr with explicit if called last " do
-      assert_equal({
-        :class => 'list'
-      }, subject.class.attrs(subject.thing.awesome(:class => "list")))
-    end
-
-    should "update class attr with proxy if called last" do
-      assert_equal({
-        :class => 'list is good'
-      }, subject.class.attrs(subject.thing.awesome(:class => "list is").good))
-    end
-
-    should "proxy mixed class and id selector attrs" do
-      subject.thing1!.awesome({:class => "list is", :id => "thing2"}).good.thing3!
-
-      assert_equal({
-        :class => 'list is good',
-        :id => "thing3"
-      }, subject.class.attrs(subject))
-    end
-
-  end
-
-  class SerializeTests < BasicTests
-    before do
-      @output = Undies::Output.new(StringIO.new(@out = ""))
-    end
-
-    should "serialize with no child elements" do
-      Undies::Template.new(Undies::Source.new do
-        element(:br)
-      end, {}, @output)
-
-      assert_equal "<br />", @out
-    end
-
-    should "serialize with attrs" do
-      Undies::Template.new(Undies::Source.new do
-        element(:br, :class => 'big')
-      end, {}, @output)
-
-      assert_equal '<br class="big" />', @out
-    end
-
-    should "serialize with attrs that have double-quotes" do
-      Undies::Template.new(Undies::Source.new do
-        element(:br, :class => '"this" is double-quoted')
-      end, {}, @output)
-
-      assert_equal '<br class="&quot;this&quot; is double-quoted" />', @out
-    end
-
-    should "serialize with attrs and content" do
-      Undies::Template.new(Undies::Source.new do
-        element(:strong, {:class => 'big'}) { __ "Loud Noises!" }
-      end, {}, @output)
-
-      assert_equal '<strong class="big">Loud Noises!</strong>', @out
-    end
-
-    should "serialize element proxy id call" do
-      Undies::Template.new(Undies::Source.new do
-        element(:div).thing1! { _ "stuff" }
-      end, {}, @output)
-
-      assert_equal "<div id=\"thing1\">stuff</div>", @out
-    end
-
-    should "serialize element proxy class call" do
-      Undies::Template.new(Undies::Source.new do
-        element(:div).thing { _ "stuff" }
-      end, {}, @output)
-
-      assert_equal "<div class=\"thing\">stuff</div>", @out
-    end
-
-    should "serialize content from separate content blocks" do
-      Undies::Template.new(Undies::Source.new do
-        element(:div){ _ "stuff" }.thing1!{ _ " and more stuff" }
-      end, {}, @output)
-
-      assert_equal "<div id=\"thing1\">stuff and more stuff</div>", @out
-    end
-
-    should "serialize nested elements with pp" do
-      output = Undies::Output.new(StringIO.new(@out = ""), :pp => 4)
-      src = Undies::Source.new do
-        element(:div) {
-          element(:span) { _ "Content!" }
-          __ "Raw"
-          element(:span) { _ "More content" }
-          element(:div).hi {
-            _ "first build"
-          }.there.you! {
-            _ "second build"
-          }
-        }
-      end
-      templ = Undies::Template.new(src, {}, output)
-      assert_equal "<div>
-    <span>Content!</span>Raw
-    <span>More content</span>
-    <div class=\"hi there\" id=\"you\">first buildsecond build</div>
-</div>", @out
-    end
-
-  end
-
 end

data/test/fixtures/write_thing.rb

@@ -2,19 +2,19 @@ class WriteThing
 
   # this is used in testing the write buffer
 
-  def self.hi(thing)
+  def __hi
     'hi'
   end
 
-  def self.hello(thing)
+  def __hello
     'hello'
   end
 
-  def self.hithere(thing)
+  def __hithere
     'hithere'
   end
 
-  def self.prefix(thing, meth, level, indent)
+  def __prefix(meth, level, indent)
     "#{level > 0 ? "\n": ''}#{' '*level*indent}"
   end
 

data/test/helper.rb

@@ -2,3 +2,87 @@
 
 # add root dir to the load path
 $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
+
+require 'undies'
+
+module Undies
+  module Element
+
+    module CSSProxyMacro
+
+      def proxy_css_methods
+        called_from = caller.first
+        Assert::Macro.new("have style attributes") do
+
+          should "respond to any method ending in '!' as an id proxy", called_from do
+            assert subject.respond_to?(:asdgasdg!)
+          end
+
+          should "proxy id attr with methods ending in '!'", called_from do
+            assert_equal({
+              :id => 'thing1'
+            }, subject.thing1!.instance_variable_get("@attrs"))
+          end
+
+          should "proxy id attr with last method call ending in '!'", called_from do
+            assert_equal({
+              :id => 'thing2'
+            }, subject.thing1!.thing2!.instance_variable_get("@attrs"))
+          end
+
+          should "set id attr to explicit if called last ", called_from do
+            assert_equal({
+              :id => 'thing3'
+            }, subject.thing1!.thing2!(:id => 'thing3').instance_variable_get("@attrs"))
+          end
+
+          should "set id attr to proxy if called last", called_from do
+            assert_equal({
+              :id => 'thing1'
+            }, subject.thing2!(:id => 'thing3').thing1!.instance_variable_get("@attrs"))
+          end
+
+          should "respond to any other method as a class proxy", called_from do
+            assert_respond_to :asdgasdg, subject
+          end
+
+          should "proxy single html class attr", called_from do
+            assert_equal({
+              :class => 'thing'
+            }, subject.thing.instance_variable_get("@attrs"))
+          end
+
+          should "proxy multi html class attrs", called_from do
+            assert_equal({
+              :class => 'list thing awesome'
+            }, subject.list.thing.awesome.instance_variable_get("@attrs"))
+          end
+
+          should "set class attr with explicit if called last ", called_from do
+            assert_equal({
+              :class => 'list'
+            }, subject.thing.awesome(:class => "list").instance_variable_get("@attrs"))
+          end
+
+          should "update class attr with proxy if called last", called_from do
+            assert_equal({
+              :class => 'list is good'
+            }, subject.thing.awesome(:class => "list is").good.instance_variable_get("@attrs"))
+          end
+
+          should "proxy mixed class and id selector attrs", called_from do
+            subject.thing1!.awesome({:class => "list is", :id => "thing2"}).good.thing3!
+
+            assert_equal({
+              :class => 'list is good',
+              :id => "thing3"
+            }, subject.instance_variable_get("@attrs"))
+          end
+
+        end
+      end
+
+    end
+
+  end
+end

data/test/io_test.rb

@@ -0,0 +1,104 @@
+require "assert"
+require "undies/io"
+
+class Undies::IO
+
+  class BasicTests < Assert::Context
+    desc 'render data'
+    before do
+      @io = Undies::IO.new(@out = "")
+    end
+    subject { @io }
+
+    should have_readers :stream, :indent, :newline
+    should have_writer :options
+    should have_accessor :level
+    should have_instance_methods :line_indent, :<<
+
+    should have_readers :node_stack, :current
+    should have_instance_methods :push, :push!, :pop, :empty?
+
+    should "know its stream" do
+      assert_same @out, subject.stream
+    end
+
+    should "default to no pretty printing" do
+      assert_equal 0,  subject.indent
+      assert_equal "", subject.newline
+    end
+
+    should "default to level 0" do
+      assert_equal 0, subject.level
+    end
+
+    should "default with an empty node_stack" do
+      assert_empty subject.node_stack
+      assert_nil subject.current
+    end
+
+    should "write raw data directly to the stream" do
+      subject << "Raw data"
+      assert_equal "Raw data", @out
+    end
+
+  end
+
+
+
+  class PrettyPrintTests < BasicTests
+    desc "when pretty printing"
+    before do
+      subject.options = {:pp => 2, :level => 1}
+    end
+
+    should "know its pp settings" do
+      assert_equal 2,    subject.indent
+      assert_equal 1,    subject.level
+      assert_equal "\n", subject.newline
+    end
+
+    should "pretty print line indents" do
+      assert_equal "  hi", subject.line_indent + "hi"
+
+      subject.level += 1
+      assert_equal "    hello", subject.line_indent + "hello"
+      assert_equal "manual level down", subject.line_indent(-2) + "manual level down"
+
+      subject.level -= 1
+      assert_equal "  implicit level down", subject.line_indent + 'implicit level down'
+    end
+
+  end
+
+
+
+  class NodeStackTests < BasicTests
+
+    should "push to, pop from, and refer to the current thing on the stack" do
+      subject.push("lala")
+      assert_equal "lala", subject.current
+      assert_equal 1, subject.level
+
+      subject.pop
+      assert_nil subject.current
+      assert_equal 0, subject.level
+
+      subject.push!("boohoo")
+      assert_equal "boohoo", subject.current
+      assert_equal 0, subject.level
+    end
+
+    should "be empty if its node stack is empty" do
+      assert_empty subject.node_stack
+      assert_empty subject
+
+      subject.push("lala")
+
+      assert_not_empty subject.node_stack
+      assert_not_empty subject
+    end
+
+
+  end
+
+end

data/test/named_source_test.rb

@@ -1,6 +1,6 @@
 require "assert"
 
-require "undies/named_source"
+require "undies/source"
 
 class Undies::NamedSource
 

data/test/raw_test.rb

@@ -0,0 +1,25 @@
+require 'assert'
+require 'undies/template'
+require 'undies/element'
+
+module Undies
+
+  class RawTests < Assert::Context
+    desc 'the Raw class'
+    before do
+      @rs = Raw.new "ab&<>'\"/yz"
+    end
+    subject { @rs }
+
+    should "be a String" do
+      assert_kind_of ::String, subject
+    end
+
+    should "ignore any gsubbing" do
+      assert_equal subject.to_s, subject.gsub('ab', '__').gsub('yz', '--')
+      assert_equal subject.to_s, Template.escape_html(subject)
+    end
+
+  end
+
+end

data/test/root_node_test.rb

@@ -0,0 +1,108 @@
+require "assert"
+require 'undies/io'
+require 'undies/element_node'
+require 'undies/element'
+require "undies/root_node"
+
+class Undies::RootNode
+
+  class BasicTests < Assert::Context
+    desc 'a root node'
+    before do
+      @io = Undies::IO.new(@out = "", :pp => 1)
+      @rn = Undies::RootNode.new(@io)
+
+      @e  = Undies::Element::Closed.new(:br)
+      @en = Undies::ElementNode.new(@io, @e)
+    end
+    subject { @rn }
+
+    should have_readers :io, :cached
+    should have_instance_methods :attrs, :text, :element_node
+    should have_instance_methods :partial, :flush, :push, :pop
+
+    should "know its IO" do
+      assert_equal @io, subject.io
+    end
+
+    should "have nothing cached by default" do
+      assert_nil subject.cached
+    end
+
+    should "complain if trying to specify attrs" do
+      assert_raises Undies::RootAPIError do
+        subject.attrs({:blah => 'whatever'})
+      end
+    end
+
+    should "cache any raw text given" do
+      subject.text "some raw markup"
+      assert_equal "some raw markup#{@io.newline}", subject.cached
+    end
+
+    should "write out any cached value when new markup is given" do
+      subject.text "some raw markup"
+      assert_empty @out
+
+      subject.text "more raw markup"
+      assert_equal "some raw markup\n", @out
+    end
+
+    should "cache any element node given" do
+      subject.element_node(@en)
+      assert_equal @en, subject.cached
+    end
+
+    should "return the element when given" do
+      assert_equal @en, subject.element_node(@en)
+    end
+
+    should "write out any cached value when a new element is given" do
+      subject.element_node(@en)
+      assert_empty @out
+
+      subject.element_node(@en)
+      assert_equal "<br />#{@io.newline}", @out
+    end
+
+    should "cache any partial markup given" do
+      subject.partial "some partial markup"
+      assert_equal "some partial markup#{@io.newline}", subject.cached
+    end
+
+    should "write out any cached value when new partial markup is given" do
+      subject.partial "some partial markup"
+      assert_empty @out
+
+      subject.partial "more partial markup"
+      assert_equal "some partial markup\n", @out
+    end
+
+    should "write out any cached value when flushed" do
+      subject.flush
+      assert_empty @out
+
+      subject.text "some raw markup"
+      subject.flush
+      assert_equal "some raw markup\n", @out
+    end
+
+    should "only flush if popped" do
+      io_level = @io.level
+      subject.text "some raw markup"
+      subject.pop
+      assert_equal "some raw markup\n", @out
+      assert_equal io_level, @io.level
+    end
+
+    should "push the cached content to the IO handler" do
+      io_level = @io.level
+      subject.text "some raw markup"
+      subject.push
+      assert_equal io_level+1, @io.level
+      assert_equal "some raw markup#{@io.newline}", @io.current
+    end
+
+  end
+
+end

data/test/source_stack_test.rb

@@ -1,6 +1,6 @@
 require "assert"
 
-require "undies/source_stack"
+require "undies/source"
 
 class Undies::SourceStack
 

data/test/template_builder_render_test.rb

@@ -1,7 +1,4 @@
 require "assert"
-require "stringio"
-require 'undies/node_stack'
-
 require "undies/template"
 
 class Undies::Template
@@ -10,17 +7,15 @@ class Undies::Template
     desc 'a template rendered using the builder approach'
     before do
       @src = Undies::Source.new(Proc.new {})
-      @output = Undies::Output.new(@outstream = StringIO.new(@out = ""))
-      @t = Undies::Template.new(@src, {}, @output)
+      @io = Undies::IO.new(@out = "")
+      @t = Undies::Template.new(@src, {}, @io)
     end
     subject { @t }
 
     should "maintain scope throughout the build blocks" do
-      templ = Undies::Template.new(@output)
+      templ = Undies::Template.new(@io)
       templ._div {
-        templ._div {
-          templ.__ self.object_id
-        }
+        templ._div self.object_id
       }
       templ.__flush