undies 2.2.0 → 2.2.1

data/lib/undies/template.rb

@@ -1,9 +1,10 @@
 require 'undies/source_stack'
+require 'undies/node_stack'
 require 'undies/output'
+
 require 'undies/node'
 require 'undies/element'
 
-
 module Undies
   class Template
 
@@ -11,12 +12,16 @@ module Undies
     # polluting the public instance methods, the instance scope, and to
     # maximize the effectiveness of the Template#method_missing logic
 
-    def self.output(template)
-      template.instance_variable_get("@_undies_output")
+    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)
-      template.instance_variable_get("@_undies_output").flush
+      node_stack(template).flush
     end
 
     # Ripped from Rack v1.3.0 ======================================
@@ -37,38 +42,82 @@ module Undies
     # end Rip from Rack v1.3.0 =====================================
 
     def initialize(*args)
-      output = if args.last.kind_of?(Output)
+      # setup a node stack with the given output obj
+      output = if args.last.kind_of?(NodeStack) || args.last.kind_of?(Output)
         args.pop
       else
         raise ArgumentError, "please provide an Output object"
       end
-      data = args.last.kind_of?(::Hash) ? args.pop : {}
-      source = args.last.kind_of?(Source) ? args.pop : Source.new(Proc.new {})
-
-      # setup the source stack and output objects
-      @_undies_source_stack = SourceStack.new(source)
+      @_undies_node_stack = NodeStack.create(output)
 
-      # apply data to template scope
+      # 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."
       end
       metaclass = class << self; self; end
       data.each {|key, value| metaclass.class_eval { define_method(key){value} }}
 
-      # save off the output obj for streaming
-      @_undies_output = output
+      # 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)
 
       # yield to recursivley render the source stack
       self.__yield
 
-      # flush any remaining output to the stream
+      # 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 @_undies_source_stack.nil? || (source = @_undies_source_stack.pop).nil?
+      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
@@ -79,23 +128,32 @@ module Undies
     # 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)
-      Undies::Template.new(source, data, @_undies_output)
+    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=""); self.__ self.class.escape_html(data.to_s); end
+    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=""); @_undies_output.node(Node.new(data.to_s)); end
-
-    # Add a text node with the data un-escaped, forcing pp output
-    def ___(data="")
-      @_undies_output.node(Node.new(data.to_s, :force_pp => true))
+    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 nodes of the current node
-    def element(*args, &block); @_undies_output.node(Element.new(*args, &block)); 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>'') ========================

data/lib/undies/version.rb

@@ -1,3 +1,3 @@
 module Undies
-  VERSION = "2.2.0"
+  VERSION = "2.2.1"
 end

data/test/element_test.rb

@@ -1,8 +1,12 @@
 require "assert"
 
-require "undies/element"
+require 'undies/node'
+require "undies/output"
 require "undies/template"
 
+require "undies/element"
+
+
 class Undies::Element
 
   class BasicTests < Assert::Context
@@ -12,19 +16,37 @@ class Undies::Element
     end
     subject { @e }
 
-    should have_class_methods :hash_attrs, :content, :flush
-    should have_instance_method :to_str
+    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
 
-    should "store it's name as a string" do
+    should "store its name as a string" do
       assert_equal "div", subject.instance_variable_get("@name")
     end
 
+    should "know its name" do
+      assert_equal "div", subject.class.node_name(subject)
+    end
+
+    should "know its start/end tags" do
+      assert_equal "<div />", subject.class.start_tag(subject)
+      assert_empty subject.class.end_tag(subject)
+    end
+
     should "have no content itself" do
-      assert_nil subject.class.content(subject)
+      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)
     end
 
   end
@@ -73,6 +95,7 @@ class Undies::Element
     end
   end
 
+
   class CSSProxyTests < BasicTests
 
     should "respond to any method ending in '!' as an id proxy" do
@@ -82,68 +105,62 @@ class Undies::Element
     should "proxy id attr with methods ending in '!'" do
       assert_equal({
         :id => 'thing1'
-      }, subject.thing1!.instance_variable_get("@attrs"))
+      }, subject.class.attrs(subject.thing1!))
     end
 
     should "proxy id attr with last method call ending in '!'" do
       assert_equal({
         :id => 'thing2'
-      }, subject.thing1!.thing2!.instance_variable_get("@attrs"))
+      }, subject.class.attrs(subject.thing1!.thing2!))
     end
 
     should "set id attr to explicit if called last " do
       assert_equal({
         :id => 'thing3'
-      }, subject.thing1!.thing2!(:id => 'thing3').instance_variable_get("@attrs"))
+      }, subject.class.attrs(subject.thing1!.thing2!(:id => 'thing3')))
     end
 
     should "set id attr to proxy if called last" do
       assert_equal({
         :id => 'thing1'
-      }, subject.thing2!(:id => 'thing3').thing1!.instance_variable_get("@attrs"))
+      }, subject.class.attrs(subject.thing2!(:id => 'thing3').thing1!))
     end
 
     should "respond to any other method as a class proxy" do
-      assert subject.respond_to?(:asdgasdg)
+      assert_respond_to :asdgasdg, subject
     end
 
     should "proxy single html class attr" do
       assert_equal({
         :class => 'thing'
-      }, subject.thing.instance_variable_get("@attrs"))
+      }, subject.class.attrs(subject.thing))
     end
 
     should "proxy multi html class attrs" do
       assert_equal({
         :class => 'list thing awesome'
-      }, subject.list.thing.awesome.instance_variable_get("@attrs"))
+      }, subject.class.attrs(subject.list.thing.awesome))
     end
 
     should "set class attr with explicit if called last " do
       assert_equal({
         :class => 'list'
-      }, subject.thing.awesome(:class => "list").instance_variable_get("@attrs"))
+      }, 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.thing.awesome(:class => "list is").good.instance_variable_get("@attrs"))
+      }, 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.thing1!.awesome({
-        :class => "list is",
-        :id => "thing2"
-      }).good.thing3!.instance_variable_get("@attrs"))
-    end
-
-    should "not proxy if private methods are called" do
-      assert_equal "<div />", subject.send(:start_tag)
-      assert_equal nil, subject.send(:end_tag)
+      }, subject.class.attrs(subject))
     end
 
   end
@@ -154,58 +171,58 @@ class Undies::Element
     end
 
     should "serialize with no child elements" do
-      src = Undies::Source.new do
+      Undies::Template.new(Undies::Source.new do
         element(:br)
-      end
-      templ = Undies::Template.new(src, {}, @output)
+      end, {}, @output)
+
       assert_equal "<br />", @out
     end
 
     should "serialize with attrs" do
-      src = Undies::Source.new do
+      Undies::Template.new(Undies::Source.new do
         element(:br, :class => 'big')
-      end
-      templ = Undies::Template.new(src, {}, @output)
+      end, {}, @output)
+
       assert_equal '<br class="big" />', @out
     end
 
     should "serialize with attrs that have double-quotes" do
-      src = Undies::Source.new do
+      Undies::Template.new(Undies::Source.new do
         element(:br, :class => '"this" is double-quoted')
-      end
-      templ = Undies::Template.new(src, {}, @output)
+      end, {}, @output)
+
       assert_equal '<br class="&quot;this&quot; is double-quoted" />', @out
     end
 
     should "serialize with attrs and content" do
-      src = Undies::Source.new do
+      Undies::Template.new(Undies::Source.new do
         element(:strong, {:class => 'big'}) { __ "Loud Noises!" }
-      end
-      templ = Undies::Template.new(src, {}, @output)
+      end, {}, @output)
+
       assert_equal '<strong class="big">Loud Noises!</strong>', @out
     end
 
     should "serialize element proxy id call" do
-      src = Undies::Source.new do
+      Undies::Template.new(Undies::Source.new do
         element(:div).thing1! { _ "stuff" }
-      end
-      templ = Undies::Template.new(src, {}, @output)
+      end, {}, @output)
+
       assert_equal "<div id=\"thing1\">stuff</div>", @out
     end
 
     should "serialize element proxy class call" do
-      src = Undies::Source.new do
+      Undies::Template.new(Undies::Source.new do
         element(:div).thing { _ "stuff" }
-      end
-      templ = Undies::Template.new(src, {}, @output)
+      end, {}, @output)
+
       assert_equal "<div class=\"thing\">stuff</div>", @out
     end
 
     should "serialize content from separate content blocks" do
-      src = Undies::Source.new do
+      Undies::Template.new(Undies::Source.new do
         element(:div){ _ "stuff" }.thing1!{ _ " and more stuff" }
-      end
-      templ = Undies::Template.new(src, {}, @output)
+      end, {}, @output)
+
       assert_equal "<div id=\"thing1\">stuff and more stuff</div>", @out
     end
 
@@ -216,14 +233,18 @@ class Undies::Element
           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
+      assert_equal "<div>
+    <span>Content!</span>Raw
     <span>More content</span>
+    <div class=\"hi there\" id=\"you\">first buildsecond build</div>
 </div>", @out
     end
 

data/test/fixtures/write_thing.rb

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

data/test/node_stack_test.rb

@@ -0,0 +1,109 @@
+require 'assert'
+
+require 'undies/node'
+require 'undies/element'
+require 'test/fixtures/write_thing'
+
+require 'undies/node_stack'
+
+module Undies
+
+  class NodeStackTests < Assert::Context
+    desc "a NodeStack"
+    before do
+      @hello = Node.new "hello"
+      @something = Node.new "something else"
+      @hi  = Node.new("hi")
+      @br  = Element.new :br
+      @div = Element.new(:div) {}
+
+      @outstream = StringIO.new(@out = "")
+      @stream_test_output = Output.new(@outstream)
+      @ns = NodeStack.new @stream_test_output
+    end
+    subject { @ns }
+
+    should have_class_method :create
+    should have_readers :stack, :cached_node, :output
+    should have_instance_methods :current, :size, :level, :empty?, :first, :last
+    should have_instance_methods :push, :pop, :node, :flush
+    should have_instance_methods :clear_cached
+
+    should "be empty by default" do
+      assert_empty subject
+    end
+
+    should "have an empty cache by default" do
+      assert_nil subject.cached_node
+    end
+
+  end
+
+
+  class StackTests < NodeStackTests
+
+    should "push nodes onto the stack" do
+      assert_nothing_raised do
+        subject.push(@hello)
+        subject.push(@something)
+      end
+
+      assert_equal 2, subject.size
+    end
+
+    should "know its level (should be one less than the array's size)" do
+      assert_equal 0, subject.level
+      subject.push(@hello)
+      assert_equal 1, subject.level
+    end
+
+    should "fetch the last item in the array with the current method" do
+      subject.push(@hello)
+      subject.push(@something)
+
+      assert_same @something, subject.current
+    end
+
+    should "remove the last item in the array with the pop method" do
+      subject.push(@hello)
+      subject.push(@something)
+
+      assert_equal 2, subject.size
+
+      node = subject.pop
+      assert_same @something, node
+      assert_equal 1, subject.size
+    end
+
+  end
+
+
+  class CacheTests < NodeStackTests
+
+    should "add nodes to its cache using the #node method" do
+      subject.node(@hi)
+      assert_equal @hi, subject.cached_node
+    end
+
+    should "push the current cached node onto the stack when caching a new node" do
+      subject.node(@br)
+      assert_equal @br, subject.cached_node
+      assert_equal 0, subject.size
+
+      subject.node(@div)
+      assert_equal @div, subject.cached_node
+    end
+
+    should "call the node's builds when flushed from cache" do
+      build = "build"
+      subject.node(Element.new(:div) { build += " called" })
+      subject.flush
+
+      assert_equal "build called", build
+    end
+
+  end
+
+
+
+end

data/test/node_test.rb

@@ -1,39 +1,89 @@
 require "assert"
 
+require "undies/output"
 require "undies/node"
-require "undies/node_buffer"
 
 class Undies::Node
 
   class BasicTests < Assert::Context
     desc 'a node'
-    before { @n = Undies::Node.new("a text node here") }
+    before do
+      @output = Undies::Output.new(StringIO.new(@out = ""))
+      @n = Undies::Node.new("a text node here")
+    end
     subject { @n }
 
-    should have_class_methods :content, :flush
+    should have_class_methods :start_tag, :end_tag, :set_start_tag, :set_end_tag
+    should have_class_methods :builds,   :add_build
+    should have_class_methods :children, :set_children
+    should have_class_methods :attrs,    :merge_attrs
+    should have_class_methods :node_name, :content, :mode, :prefix
+
+    should "have no start/end tags" do
+      assert_empty subject.class.start_tag(subject)
+      assert_empty subject.class.end_tag(subject)
+    end
 
-    should "know it's content" do
+    should "have content" do
       assert_equal "a text node here", subject.class.content(subject)
     end
 
-    should "know it's start/end tags" do
-      assert_nil subject.instance_variable_get("@start_tag")
-      assert_nil subject.instance_variable_get("@end_tag")
+    should "have no builds" do
+      assert_empty subject.class.builds(subject)
+    end
+
+    should "be :inline mode by default" do
+      assert_equal :inline, subject.class.mode(subject)
+    end
+
+    should "have no prefix if :inline mode" do
+      assert_empty subject.class.prefix(subject, 'start_tag', 2, 2)
+      assert_empty subject.class.prefix(subject, 'end_tag', 1, 2)
+    end
+
+    should "have a pp prefix if not :inline mode" do
+      node = Undies::Node.new("a non inline node", :partial)
+      assert_equal "\n    ", node.class.prefix(node, 'start_tag', 2, 2)
+      assert_equal "\n  ",   node.class.prefix(node, 'end_tag', 2, 2)
+      assert_equal "\n  ",   node.class.prefix(node, 'start_tag', 1, 2)
+      assert_equal "\n",     node.class.prefix(node, 'end_tag', 1, 2)
+      assert_equal "",       node.class.prefix(node, 'start_tag', 0, 2)
+      assert_equal "\n",     node.class.prefix(node, 'end_tag', 0, 2)
     end
 
-    should "output its content when flushed" do
-      output = Undies::Output.new(StringIO.new(out = ""))
-      subject.class.flush(output, subject)
+    should "have no children by default" do
+      assert_equal false, subject.class.children(subject)
+    end
+
+    should "have no attrs by default" do
+      assert_empty subject.class.attrs(subject)
+    end
+
+    should "have no name by default" do
+      assert_empty subject.class.node_name(subject)
+    end
+
+    should "add a build if given a block" do
+      subject.class.add_build(subject, Proc.new {})
+      assert_equal [Proc.new {}], subject.class.builds(subject)
+
+      subject.class.add_build(subject, Proc.new {})
+      assert_equal [Proc.new {}, Proc.new {}], subject.class.builds(subject)
+    end
 
-      assert_equal "a text node here", out
+    should "set children if given a value" do
+      subject.class.set_children(subject, true)
+      assert_equal true, subject.class.children(subject)
     end
 
-    should "force pp when flushed if directed" do
-      output = Undies::Output.new(StringIO.new(out = ""), :pp => 2, :pp_level => 1)
-      output.pp_use_indent = false
-      Undies::Node.flush(output, Undies::Node.new("should be pp", {:force_pp => true}))
+    should "merge attrs if given an attrs hash" do
+      attrs_hash = {:same => 'value', :new => 'a new value'}
+      subject.class.merge_attrs(subject, attrs_hash)
+      assert_equal attrs_hash, subject.class.attrs(subject)
 
-      assert_equal "\n  should be pp", out
+      attrs_hash = {:same => 'new same', :new => 'a new value'}
+      subject.class.merge_attrs(subject, attrs_hash)
+      assert_equal attrs_hash, subject.class.attrs(subject)
     end
 
   end