undies 2.2.1 → 3.0.0.rc.1

data/lib/undies/template.rb

@@ -1,27 +1,19 @@
-require 'undies/source_stack'
-require 'undies/node_stack'
-require 'undies/output'
-
-require 'undies/node'
-require 'undies/element'
+require 'undies/io'
+require 'undies/source'
+require 'undies/root_node'
+require 'undies/api'
 
 module Undies
   class Template
 
+    include API
+
     # have as many methods on the class level as possible to keep from
     # polluting the public instance methods, the instance scope, and to
     # maximize the effectiveness of the Template#method_missing logic
 
-    def self.source_stack(template)
-      template.instance_variable_get("@_undies_source_stack")
-    end
-
-    def self.node_stack(template)
-      template.instance_variable_get("@_undies_node_stack")
-    end
-
     def self.flush(template)
-      node_stack(template).flush
+      template.__flush
     end
 
     # Ripped from Rack v1.3.0 ======================================
@@ -43,136 +35,30 @@ module Undies
 
     def initialize(*args)
       # setup a node stack with the given output obj
-      output = if args.last.kind_of?(NodeStack) || args.last.kind_of?(Output)
+      @_undies_io = if args.last.kind_of?(Undies::IO)
         args.pop
       else
-        raise ArgumentError, "please provide an Output object"
+        raise ArgumentError, "please provide an IO object"
       end
-      @_undies_node_stack = NodeStack.create(output)
 
-      # apply any given data to template scope
-      data = args.last.kind_of?(::Hash) ? args.pop : {}
-      if (data.keys.map(&:to_s) & self.public_methods.map(&:to_s)).size > 0
-        raise ArgumentError, "data conflicts with template public methods."
+      # apply any given data to template scope as instance variables
+      (args.last.kind_of?(::Hash) ? args.pop : {}).each do |k, v|
+        self.instance_variable_set("@#{k}", v)
       end
-      metaclass = class << self; self; end
-      data.each {|key, value| metaclass.class_eval { define_method(key){value} }}
 
       # setup a source stack with the given source
       source = args.last.kind_of?(Source) ? args.pop : Source.new(Proc.new {})
       @_undies_source_stack = SourceStack.new(source)
 
+      # push a root node onto the IO
+      @_undies_io.push!(RootNode.new(@_undies_io)) if @_undies_io.empty?
+
       # yield to recursivley render the source stack
-      self.__yield
+      __yield
 
       # flush any elements that need to be built
-      self.class.flush(self)
-    end
-
-    # call this to modify element attrs inside a build block.  Once content
-    # or child elements have been added, any '__attr' directives will
-    # be ignored b/c the elements start_tag has already been flushed
-    # to the output
-    def __attrs(attrs_hash={})
-      self.class.node_stack(self).current.tap do |node|
-        if node
-          node.class.merge_attrs(node, attrs_hash)
-          node.class.set_start_tag(node)
-        end
-      end
-    end
-
-    # call this method to manually push the currently cached node onto the
-    # node stack
-    # - implicitly flushes the cache
-    # - changes the context of template method calls to operate on that node
-    def __push
-      ns = self.class.node_stack(self)
-      node, ns.cached_node = ns.cached_node, nil
-      if node
-        # add an empty build block to generate a non-closing start tag
-        # and a closing end tag
-        node.class.add_build(node, Proc.new {})
-        node.class.set_start_tag(node)
-        node.class.set_end_tag(node)
-
-        ns.push(node)
-      end
-    end
-
-    # call this method to manually pop the current scoped node from the node stack
-    # - flushes the cache
-    # - changes the context of template method calls to operate on the parent node
-    def __pop
-      ns = self.class.node_stack(self)
-      ns.clear_cached
-      ns.pop
-    end
-
-    # call this to manually flush a template
-    def __flush
-      self.class.flush(self)
-    end
-
-    # call this to render template source
-    # use this method in layouts to insert a layout's content source
-    def __yield
-      return if self.class.node_stack(self).nil? || (source = self.class.source_stack(self).pop).nil?
-      if source.file?
-        instance_eval(source.data, source.source, 1)
-      else
-        instance_eval(&source.data)
-      end
-    end
-
-    # call this to render partial source embedded in a template
-    # partial source is rendered with its own scope/data but shares
-    # its parent template's output object
-    def __partial(source, data={})
-      if source.kind_of?(Source)
-        Undies::Template.new(source, data, self.class.node_stack(self))
-      else
-        self.__ source.to_s, :partial
-      end
-    end
-
-    # Add a text node (data escaped) to the nodes of the current node
-    def _(data="", mode=:inline)
-      self.__ self.class.escape_html(data.to_s), mode
-    end
-
-    # Add a text node with the data un-escaped
-    def __(data="", mode=:inline)
-      Node.new(data.to_s, mode).tap do |node|
-        self.class.node_stack(self).node(node)
-      end
-    end
-
-    # Add an element to the node stack
-    def element(*args, &build)
-      Element.new(*args, &build).tap do |element|
-        self.class.node_stack(self).node(element)
-      end
-    end
-    alias_method :tag, :element
-
-    # Element proxy methods ('_<element>'') ========================
-    ELEM_METH_REGEX = /^_(.+)$/
-    def method_missing(meth, *args, &block)
-      if meth.to_s =~ ELEM_METH_REGEX
-        element($1, *args, &block)
-      else
-        super
-      end
-    end
-    def respond_to?(*args)
-      if args.first.to_s =~ ELEM_METH_REGEX
-        true
-      else
-        super
-      end
+      __flush
     end
-    # ==============================================================
 
   end
 end

data/lib/undies/version.rb

@@ -1,3 +1,3 @@
 module Undies
-  VERSION = "2.2.1"
+  VERSION = "3.0.0.rc.1"
 end

data/lib/undies.rb

@@ -1,3 +1,4 @@
-require 'undies/template'
-
 module Undies; end
+
+require 'undies/io'
+require 'undies/template'

data/test/element_closed_test.rb

@@ -0,0 +1,69 @@
+require "assert"
+require 'undies/io'
+require "undies/element"
+
+
+module Undies::Element
+
+  class ClosedBasicTests < Assert::Context
+    desc 'a closed element'
+    before do
+      @ec = Undies::Element::Closed.new(:br)
+    end
+    subject { @ec }
+
+    should have_instance_methods :__start_tag, :__content, :__build, :__end_tag
+    should have_instance_methods :to_s
+
+    should "know its name and store it as a string" do
+      assert_equal "br", subject.instance_variable_get("@name")
+    end
+
+    should "have no attrs by default" do
+      assert_empty subject.instance_variable_get("@attrs")
+    end
+
+  end
+
+
+
+  class ClosedCSSProxyTests < ClosedBasicTests
+    extend CSSProxyMacro
+
+    should proxy_css_methods
+  end
+
+
+
+  class ClosedSerializeTests < ClosedBasicTests
+
+    should "serialize with no attrs" do
+      elem = Undies::Element::Closed.new(:br)
+      assert_equal "<br />", elem.to_s
+    end
+
+    should "serialize with attrs" do
+      elem = Undies::Element::Closed.new(:br, :class => 'big')
+      assert_equal "<br class=\"big\" />", elem.to_s
+    end
+
+    should "serialize with attrs that have double-quotes" do
+      elem = Undies::Element::Closed.new(:br, :class => '"this" is double-quoted')
+      assert_equal "<br class=\"&quot;this&quot; is double-quoted\" />", elem.to_s
+    end
+
+    should "serialize element proxy id call" do
+      elem = Undies::Element::Closed.new(:br).thing1!
+      assert_equal "<br id=\"thing1\" />", elem.to_s
+    end
+
+    should "serialize element proxy class call" do
+      # calling a private method as public to test private methods not
+      # polluting public method_missing scope
+      elem = Undies::Element::Closed.new(:br).proxy
+      assert_equal "<br class=\"proxy\" />", elem.to_s
+    end
+
+  end
+
+end

data/test/element_node_test.rb

@@ -0,0 +1,274 @@
+require "assert"
+require 'undies/io'
+require 'undies/element_node'
+require 'undies/element'
+
+
+class Undies::ElementNode
+
+  class BasicTests < Assert::Context
+    desc 'an element node'
+    before do
+      # io test with :pp 1 so we can test newline insertion
+      # io test with level 1 so we can test element start tag writing
+      @io = Undies::IO.new(@out = "", :pp => 1, :level => 1)
+      @e  = Undies::Element.open(:div, "hi")
+      @en = Undies::ElementNode.new(@io, @e)
+    end
+    subject { @en }
+
+    should have_readers :io, :element, :cached
+    should have_instance_methods :attrs, :text, :element_node
+    should have_instance_methods :partial, :flush, :push, :pop, :to_s
+
+    should "know its IO" do
+      assert_equal @io, subject.io
+    end
+
+    should "know its element" do
+      assert_equal @e, subject.element
+    end
+
+    should "have nothing cached by default" do
+      assert_nil subject.cached
+    end
+
+    should "complain if trying to add text in a build" do
+      assert_raises Undies::ElementAPIError do
+        subject.text 'blah'
+      end
+    end
+
+  end
+
+
+
+  class AddContentTests < BasicTests
+    desc "adding content"
+    before do
+      @text1 = "some raw markup"
+      @text2 = "more raw markup"
+      @elem1 = Undies::Element::Open.new(:strong, "blah")
+      @elem2 = Undies::Element::Closed.new(:br).meh
+      @en1   = Undies::ElementNode.new(@io, @elem1)
+      @en2   = Undies::ElementNode.new(@io, @elem2)
+    end
+
+  end
+
+  class AddContentStartTagWrittenTests < AddContentTests
+    desc "(the start tag has already been written)"
+    before do
+      subject.instance_variable_set("@start_tag_written", true)
+    end
+
+  end
+
+  class ElementStartTagWrittenTests < AddContentStartTagWrittenTests
+    desc "using the element_node meth"
+
+    should "cache any element node given" do
+      subject.element_node(@en1)
+      assert_equal @en1, subject.cached
+    end
+
+    should "return the element node" do
+      assert_equal @en1, subject.element_node(@en1)
+    end
+
+    should "write out any cached value when a new element is given" do
+      subject.element_node(@en1)
+      assert_empty @out
+
+      subject.element_node(@en2)
+      assert_equal "#{@io.line_indent}<strong>blah</strong>#{@io.newline}", @out
+    end
+
+    should "write out any cached value when flushed" do
+      subject.flush
+      assert_empty @out
+
+      subject.element_node(@en1)
+      subject.flush
+      assert_equal "#{@io.line_indent}<strong>blah</strong>#{@io.newline}", @out
+    end
+
+  end
+
+  class PartialStartTagWrittenTests < AddContentStartTagWrittenTests
+    desc "using the partial meth"
+
+    should "cache any partial markup given" do
+      subject.partial("partial markup")
+      assert_equal "partial markup", subject.cached
+    end
+
+    should "write out any cached partial values" do
+      subject.partial("partial markup")
+      assert_empty @out
+
+      subject.element_node(@en2)
+      assert_equal "partial markup", @out
+    end
+
+    should "write out any cached value when flushed" do
+      subject.flush
+      assert_empty @out
+
+      subject.partial("partial markup")
+      subject.flush
+      assert_equal "partial markup", @out
+    end
+
+  end
+
+
+
+  class AddContentStartTagNotWrittenTests < AddContentTests
+    desc "(the start tag has not been written)"
+    before do
+      subject.instance_variable_set("@start_tag_written", false)
+    end
+
+  end
+
+  class ElementStartTagNotWrittenTests < AddContentStartTagNotWrittenTests
+    desc "using the element_node meth"
+
+    should "cache any element_node given" do
+      subject.element_node(@en1)
+      assert_equal @en1, subject.cached
+    end
+
+    should "return the element node" do
+      assert_equal @en1, subject.element_node(@en1)
+    end
+
+    should "write out the start tag with IO#newline when an element is given" do
+      subject.element_node(@en1)
+      assert_equal "<div>#{@io.newline}", @out
+    end
+
+    should "write out any cached content and cache new markup when given" do
+      subject.element_node @en1
+      subject.element_node @en2
+      assert_equal "<div>#{@io.newline}#{@io.line_indent}<strong>blah</strong>#{@io.newline}", @out
+      assert_equal @en2, subject.cached
+    end
+
+    should "write out the end tag with IO#newline indented when popped" do
+      subject.element_node(@en1)
+      subject.pop
+      assert_equal "<div>#{@io.newline} <strong>blah</strong>#{@io.newline}</div>#{@io.newline}", @out
+    end
+
+  end
+
+  class PartialStartTagNotWrittenTests < AddContentStartTagNotWrittenTests
+    desc "using the partial meth"
+
+    should "cache any partial markup given" do
+      subject.partial("partial markup")
+      assert_equal "partial markup", subject.cached
+    end
+
+    should "write out the start tag with IO#newline when a partial is given" do
+      subject.partial("partial markup")
+      assert_equal "<div>#{@io.newline}", @out
+    end
+
+    should "write out the end tag with IO#newline indented when a partial is given" do
+      subject.partial("  partial markup\n")
+      subject.pop
+      assert_equal "<div>#{@io.newline}  partial markup\n</div>#{@io.newline}", @out
+    end
+
+  end
+
+  class AttrsTests < AddContentStartTagNotWrittenTests
+    desc "using the attrs meth"
+
+    should "modify the parent element's tag attributes" do
+      subject.attrs(:test => 'value')
+      subject.element_node(@en1)
+
+      assert_equal "<div test=\"value\">#{@io.newline}", @out
+    end
+
+    should "not effect the start tag once child elements have been written" do
+      subject.attrs(:test => 'value')
+      subject.element_node(@en1)
+      subject.attrs(:another => 'val')
+
+      assert_equal "<div test=\"value\">#{@io.newline}", @out
+    end
+
+  end
+
+
+
+  class SerializeTests < BasicTests
+
+    should "serialize nested elements with pp and only honor the last build block" do
+      io = Undies::IO.new(@out = "", :pp => 1, :level => 0)
+
+      e1a  = Undies::Element::Open.new :span, 'Content!'
+      en1a = Undies::ElementNode.new(io, e1a)
+
+      e1b  = Undies::Element::Open.new :span, 'More content'
+      en1b = Undies::ElementNode.new(io, e1b)
+
+      e1c  = Undies::Element::Open.new :div
+      en1c = Undies::ElementNode.new(io, e1c)
+
+      e2a  = Undies::Element::Open.new :p, 'a'
+      en2a = Undies::ElementNode.new(io, e2a)
+
+      e2b  = Undies::Element::Open.new :p, 'b'
+      en2b = Undies::ElementNode.new(io, e2b)
+
+      e_root  = Undies::Element::Open.new :div
+      en_root = Undies::ElementNode.new(io, e_root)
+      e_root.test do
+        en_root.attrs :class => 'root'
+        en_root.element_node(en1a)
+        en_root.element_node(en1b)
+        en_root.element_node(en1c)
+      end
+
+      # any build trumps any content provided in the args
+      e1b.test {
+        en1b.element_node(en2a)
+      }
+
+      # the last build specified is the only one used
+      e1c.
+        proxy {
+          # this will be ignored
+          en1c.element_node(en1a)
+        }.
+        start_tag.
+        you! {
+          # this will be the build for e1c
+          # only builds on the last proxy call
+          en1c.element_node(en2b)
+        }
+
+
+      en_root.to_s
+
+      assert_equal "<div class=\"root\">
+ <span>Content!</span>
+ <span class=\"test\">
+  <p>a</p>
+ </span>
+ <div class=\"proxy start_tag\" id=\"you\">
+  <p>b</p>
+ </div>
+</div>
+", @out
+    end
+
+  end
+
+end

data/test/element_open_test.rb

@@ -0,0 +1,101 @@
+require "assert"
+require "undies/element"
+
+
+module Undies::Element
+
+  class OpenBasicTests < Assert::Context
+    desc 'an open element'
+    before do
+      @e = Undies::Element::Open.new(:div)
+    end
+    subject { @e }
+
+    should have_instance_methods :__start_tag, :__content, :__build, :__end_tag
+    should have_instance_methods :to_s
+
+    should "know its name and store it as a string" do
+      assert_equal "div", subject.instance_variable_get("@name")
+    end
+
+    should "have no attrs by default" do
+      assert_empty subject.instance_variable_get("@attrs")
+    end
+
+    should "have no content by default" do
+      assert_empty subject.instance_variable_get("@content")
+    end
+
+    should "have no build by default" do
+      assert_nil subject.instance_variable_get("@build")
+    end
+
+  end
+
+
+
+  class OpenCSSProxyTests < OpenBasicTests
+    extend CSSProxyMacro
+
+    should proxy_css_methods
+  end
+
+
+
+  class OpenSerializeTests < OpenBasicTests
+
+    should "serialize with no attrs, content, or build" do
+      elem = Undies::Element::Open.new(:div)
+      assert_equal "<div></div>", elem.to_s
+    end
+
+    should "serialize with attrs" do
+      elem = Undies::Element::Open.new(:div, :class => 'big')
+      assert_equal "<div class=\"big\"></div>", elem.to_s
+    end
+
+    should "serialize with escaped attrs content" do
+      elem = Undies::Element::Open.new(:div, :class => '"this" is double-quoted')
+      assert_equal "<div class=\"&quot;this&quot; is double-quoted\"></div>", elem.to_s
+    end
+
+    should "serialize with a single piece of content" do
+      elem = Undies::Element::Open.new(:div, "hi")
+      assert_equal "<div>hi</div>", elem.to_s
+    end
+
+    should "serialize with multiple pieces of content joined" do
+      elem = Undies::Element::Open.new(:div, "hi", ' there', ' you')
+      assert_equal "<div>hi there you</div>", elem.to_s
+    end
+
+    should "serialize with escaped content" do
+      elem = Undies::Element::Open.new(:div, "stuff & <em>more stuff</em>")
+      assert_equal "<div>stuff &amp; &lt;em&gt;more stuff&lt;&#x2F;em&gt;</div>", elem.to_s
+    end
+
+    should "serialize with raw content" do
+      elem = Undies::Element::Open.new(:div, Undies::Raw.new("stuff & <em>more stuff</em>"))
+      assert_equal "<div>stuff & <em>more stuff</em></div>", elem.to_s
+    end
+
+    should "serialize element proxy id call" do
+      elem = Undies::Element::Open.new(:div, 'stuff').thing1!
+      assert_equal "<div id=\"thing1\">stuff</div>", elem.to_s
+    end
+
+    should "serialize element proxy id call with content" do
+      elem = Undies::Element::Open.new(:div).thing1! 'proxy stuff'
+      assert_equal "<div id=\"thing1\">proxy stuff</div>", elem.to_s
+    end
+
+    should "serialize element proxy class call" do
+      # calling a private method as public to test private methods not
+      # polluting public method_missing scope
+      elem = Undies::Element::Open.new(:div, 'stuff').proxy
+      assert_equal "<div class=\"proxy\">stuff</div>", elem.to_s
+    end
+
+  end
+
+end