undies 0.0.1 → 1.0.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    undies (0.0.1)
+    undies (1.0.0)
 
 GEM
   remote: http://rubygems.org/

data/lib/undies/{tag.rb → element.rb}

@@ -1,17 +1,30 @@
-require 'undies/buffer'
+require 'undies/node'
+require 'undies/node_list'
 
 module Undies
-  class Tag < Buffer
+  class Element < Node
 
-    attr_reader :attrs
+    attr_reader :name, :attrs
+    attr_accessor :nodes
 
-    def initialize(name=nil, attrs={}, &block)
-      super
-      @name = name
+    def initialize(stack, name, attrs={}, &block)
+      super(@nodes = NodeList.new)
+      @stack = stack
+      @name = name.to_s
       @attrs = attrs
+      @content_writes = 0
       self.content = block
     end
 
+    def start_tag
+      "<#{@name}#{html_attrs(@attrs)}" + (@content_writes > 0 ? ">" : " />")
+    end
+
+    def end_tag
+      @content_writes > 0 ? "</#{@name}>" : nil
+    end
+
+    # CSS proxy methods ============================================
     ID_METH_REGEX = /^([^_].+)!$/
     CLASS_METH_REGEX = /^([^_].+)$/
 
@@ -32,17 +45,22 @@ module Undies
         super
       end
     end
+    # ==============================================================
 
-    def to_s(pp_level=0, pp_indent=nil)
-      out = ""
-      if @content
-        out << pretty_print("<#{@name}#{html_attrs(@attrs)}>", pp_level, pp_indent)
-        out << super(pp_level+1, pp_indent)
-        out << pretty_print("</#{@name}>", pp_level, pp_indent)
-      else
-        out << pretty_print("<#{@name}#{html_attrs(@attrs)} />", pp_level, pp_indent)
-      end
-      out
+    def ==(other)
+      other.name == self.name &&
+      other.attrs == self.attrs &&
+      other.nodes == self.nodes
+    end
+
+    def to_str(*args)
+      "Undies::Element:#{self.object_id} " +
+      "@name=#{@name.inspect}, @attrs=#{@attrs.inspect}, @nodes=#{@nodes.inspect}"
+    end
+    alias_method :inspect, :to_str
+
+    def to_ary(*args)
+      @nodes
     end
 
     protected
@@ -78,8 +96,10 @@ module Undies
 
     def content=(block)
       if block
-        @content = block
-        instance_eval(&@content)
+        @content_writes += 1
+        @stack.push(self)
+        block.call
+        @stack.pop
       end
     end
 

data/lib/undies/node.rb

@@ -0,0 +1,38 @@
+module Undies
+  class Node
+
+    attr_reader :content
+
+    def initialize(content)
+      @content = content
+    end
+
+    def start_tag
+      nil
+    end
+
+    def end_tag
+      nil
+    end
+
+    def to_s(pp_level=0, pp_indent=nil)
+      [ self.start_tag,
+        self.content,
+        self.end_tag
+      ].compact.collect do |item|
+        pretty_print(item, pp_level, pp_indent)
+      end.join
+    end
+
+    private
+
+    def pretty_print(data, level, indent)
+      if data.kind_of? NodeList
+        data.to_s(level+1, indent)
+      else
+        indent ? "#{' '*level*indent}#{data}\n" : data
+      end
+    end
+
+  end
+end

data/lib/undies/node_list.rb

@@ -0,0 +1,28 @@
+require "undies/node"
+
+module Undies
+  class NodeList < ::Array
+
+    def initialize(*args)
+      #always initialize empty
+      super()
+    end
+
+    def append(node)
+      self << node
+      node
+    end
+
+    def <<(item)
+      unless item.kind_of?(Node)
+        raise ArgumentError, 'you can only append nodes to a NodeList'
+      end
+      super
+    end
+
+    def to_s(pp_level=0, pp_indent=nil)
+      self.collect{|n| n.to_s(pp_level, pp_indent)}.join
+    end
+
+  end
+end

data/lib/undies/partial.rb

@@ -0,0 +1,20 @@
+require 'undies/partial_data'
+require 'undies/template'
+
+module Undies
+  class Partial < Template
+
+    def initialize(path, object=nil, locals={})
+      data = PartialData.new(path)
+      data.object, data.values = object_locals(object, locals)
+      super(path, data)
+    end
+
+    private
+
+    def object_locals(o, l)
+      o && o.kind_of?(::Hash) ? [nil, o] : [o, l || {}]
+    end
+
+  end
+end

data/lib/undies/partial_data.rb

@@ -0,0 +1,32 @@
+module Undies
+  class PartialData < ::Hash
+
+    attr_reader :path, :name
+
+    def initialize(path)
+      self.path = path
+      super()
+    end
+
+    def path=(value)
+      raise ArgumentError, "partial path required" if value.nil?
+      @path = value
+      @name = File.basename(@path.to_s).split(".").first.gsub(/^[^A-Za-z]+/, '')
+    end
+
+    def values=(value)
+      raise ArgumentError if !value.kind_of?(::Hash)
+      if value.has_key?(@name.to_sym)
+        value[@name] = value.delete(@name.to_sym)
+      end
+      self.merge!(value)
+    end
+
+    def object=(value)
+      if value
+        self[@name] = value
+      end
+    end
+
+  end
+end

data/lib/undies/source.rb

@@ -1,24 +1,26 @@
 module Undies
   class Source
 
-    attr_reader :file, :block, :data
+    attr_reader :source, :data
 
-    def initialize(file=nil, block=nil)
-      raise ArgumentError, "file or block required" if (file || block).nil?
+    def initialize(source=nil)
+      raise ArgumentError, "file or block required" if source.nil?
 
-      @file = file
-      @block = block
+      @source = source
+      if self.file? && !File.exists?(@source.to_s)
+        raise ArgumentError, "no template file '#{@source}'"
+      end
 
-      # load template data and prepare (uses binread to avoid encoding issues)
-      @data = @block || if File.respond_to?(:binread)
-        File.binread(@file)
+      # load source data and prepare (uses binread to avoid encoding issues)
+      @data = if self.file?
+        File.send(File.respond_to?(:binread) ? :binread : :read, @source.to_s)
       else
-        File.read(@file)
+        @source
       end
     end
 
     def file?
-      !!self.file
+      !@source.kind_of?(::Proc)
     end
 
   end

data/lib/undies/template.rb

@@ -1,22 +1,114 @@
 require 'undies/source'
-require 'undies/buffer'
-require 'undies/tag'
+require 'undies/node'
+require 'undies/element'
 
 module Undies
-  class Template < Buffer
+  class Template
 
-    def initialize(file=nil, &block)
-      super
-      if (@source = Source.new(file, block)).file?
-        instance_eval(@source.data, @source.file, 1)
+    attr_accessor :nodes
+
+    def initialize(*args, &block)
+      @nodes = NodeList.new
+      @stack = [self]
+      self.data, @source = data_source(args, block)
+
+      if (@source).file?
+        instance_eval(@source.data, @source.source, 1)
       else
         instance_eval(&@source.data)
       end
     end
 
     def to_s(pp_indent=nil)
-      super(0, pp_indent)
+      @nodes.collect{|n| n.to_s(0, pp_indent)}.join
+    end
+
+    # Add a text node (data escaped) to the nodes of the current node
+    def _(data)
+      @stack.last.nodes.append(Node.new(escape_html(data.to_s)))
+    end
+
+    # Add a text node with the data un-escaped
+    def __(data)
+      @stack.last.nodes.append(Node.new(data.to_s))
+    end
+
+    # Add an element to the nodes of the current node
+    def element(name, attrs={}, &block)
+      @stack.last.nodes.append(Element.new(@stack, name, attrs, &block))
+    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
     end
+    # ==============================================================
+
+    protected
+
+    def data=(data)
+      raise ArgumentError if !data.kind_of?(::Hash)
+      data.each do |key, value|
+        metaclass do
+          define_method(key) { value }
+        end
+      end
+    end
+
+    def source
+      @source
+    end
+
+    def stack
+      @stack
+    end
+
+    private
+
+    def data_source(args, block)
+      [ args.last.kind_of?(::Hash) ? args.pop : {},
+        Source.new(block || args.first.to_s)
+      ]
+    end
+
+    def metaclass(&block)
+      metaclass = class << self; self; end
+      metaclass.class_eval(&block)
+    end
+
+    # Ripped from Rack v1.3.0 ======================================
+    # => ripped b/c I don't want a dependency on Rack for just this
+    ESCAPE_HTML = {
+      "&" => "&amp;",
+      "<" => "&lt;",
+      ">" => "&gt;",
+      "'" => "&#x27;",
+      '"' => "&quot;",
+      "/" => "&#x2F;"
+    }
+    ESCAPE_HTML_PATTERN = Regexp.union(*ESCAPE_HTML.keys)
+
+    # Escape ampersands, brackets and quotes to their HTML/XML entities.
+    def escape_html(string)
+      string.to_s.gsub(ESCAPE_HTML_PATTERN){|c| ESCAPE_HTML[c] }
+    end
+    # end Rip from Rack v1.3.0 =====================================
+
 
   end
 end

data/lib/undies/version.rb

@@ -1,3 +1,3 @@
 module Undies
-  VERSION = "0.0.1"
+  VERSION = "1.0.0"
 end

data/test/{tag_test.rb → element_test.rb}

@@ -1,16 +1,47 @@
 require "test/helper"
-require "undies/tag"
+require "undies/element"
 
-class Undies::Tag
+class Undies::Element
 
 
 
   class BasicTest < Test::Unit::TestCase
     include TestBelt
 
-    context 'a tag'
-    subject { Undies::Tag.new(:div) }
-    should have_instance_methods :to_s, :attrs
+    context 'an element'
+    subject { Undies::Element.new([], :div) }
+    should have_readers :name, :attrs
+    should have_accessor :nodes
+
+    should "be a Node" do
+      assert_kind_of Undies::Node, subject
+    end
+
+    should "store it's name as a string" do
+      assert_equal "div", subject.name
+    end
+
+    should "have a NodeList as its nodes" do
+      assert_kind_of Undies::NodeList, subject.nodes
+    end
+
+    should "have its nodes be its content" do
+      assert_equal subject.nodes.object_id, subject.content.object_id
+    end
+
+  end
+
+
+
+  class EmptyTest < Test::Unit::TestCase
+    include TestBelt
+    context 'an empty element'
+    subject { Undies::Element.new([], :br) }
+
+    should "have no nodes" do
+      assert_equal([], subject.nodes)
+    end
+
   end
 
 
@@ -44,27 +75,28 @@ class Undies::Tag
 
 
   class SerializeTest < BasicTest
-    context "when serialized"
-
-    should "buffer an empty html tag with no attrs" do
-      tag = Undies::Tag.new(:br)
-      assert_equal "<br />", tag.to_s
+    should "serialize with no child elements" do
+      element = Undies::Element.new([], :br)
+      assert_equal "<br />", element.to_s
     end
 
-    should "buffer an html tag with attrs" do
-      tag = Undies::Tag.new(:br, {:class => 'big'})
-      assert_equal '<br class="big" />', tag.to_s
+    should "serialize with attrs" do
+      element = Undies::Element.new([], :br, {:class => 'big'})
+      assert_equal '<br class="big" />', element.to_s
     end
 
-    should "buffer an html tag with attrs and content" do
-      tag = Undies::Tag.new(:strong, {:class => 'big'}) { __ "Loud Noises!" }
-      assert_equal '<strong class="big">Loud Noises!</strong>', tag.to_s
+    should "serialize with attrs and content" do
+      templ = Undies::Template.new do
+        element(:strong, {:class => 'big'}) { __ "Loud Noises!" }
+      end
+      assert_equal '<strong class="big">Loud Noises!</strong>', templ.to_s
     end
   end
 
 
 
   class CSSProxyTest < BasicTest
+
     should "respond to any method ending in '!' as an id proxy" do
       assert subject.respond_to?(:asdgasdg!)
     end
@@ -75,11 +107,11 @@ class Undies::Tag
       }, subject.thing1!.attrs)
     end
 
-    should "nest tags from proxy id call" do
-      assert_equal(
-        "<div id=\"thing1\">stuff</div>",
-        subject.thing1! { _ 'stuff' }.to_s
-      )
+    should "nest elements from proxy id call" do
+      templ = Undies::Template.new do
+        element(:div).thing1! { _ "stuff" }
+      end
+      assert_equal "<div id=\"thing1\">stuff</div>", templ.to_s
     end
 
     should "proxy id attr with last method call ending in '!'" do
@@ -110,11 +142,11 @@ class Undies::Tag
       }, subject.thing.attrs)
     end
 
-    should "nest tags from proxy class call" do
-      assert_equal(
-        "<div class=\"thing\">stuff</div>",
-        subject.thing { _ 'stuff' }.to_s
-      )
+    should "nest elements from proxy class call" do
+      templ = Undies::Template.new do
+        element(:div).thing { _ "stuff" }
+      end
+      assert_equal "<div class=\"thing\">stuff</div>", templ.to_s
     end
 
     should "proxy multi html class attrs" do

data/test/node_list_test.rb

@@ -0,0 +1,48 @@
+require "test/helper"
+require "undies/node_list"
+require "undies/node"
+
+class Undies::NodeList
+
+  class BasicTest < Test::Unit::TestCase
+    include TestBelt
+
+    context 'a node list'
+    subject { Undies::NodeList.new }
+    should have_instance_method :append
+
+    should "be an Array" do
+      assert_kind_of ::Array, subject
+    end
+
+    should "always init empty" do
+      assert_equal 0, subject.size
+      assert_equal 0, Undies::NodeList.new([1,2,3]).size
+    end
+
+    should "complain if you try to append something other than a node" do
+      assert_raises ArgumentError do
+        subject.append('hey!')
+      end
+      assert_raises ArgumentError do
+        subject << 'hey!'
+      end
+      assert_nothing_raised do
+        subject.append(Undies::Node.new('hey!'))
+        subject << Undies::Node.new('hey!')
+      end
+    end
+
+    should "append nodes with the 'append' method" do
+      subject.append(Undies::Node.new "hey!")
+      assert_equal 1, subject.size
+    end
+
+    should "return the node when appending" do
+      node = Undies::Node.new "hey!"
+      assert_equal node.object_id, subject.append(node).object_id
+    end
+
+  end
+
+end

data/test/node_test.rb

@@ -0,0 +1,24 @@
+require "test/helper"
+require "undies/node"
+
+class Undies::Node
+
+  class BasicTest < Test::Unit::TestCase
+    include TestBelt
+
+    context 'a node'
+    subject { Undies::Node.new("a text node here") }
+    should have_instance_method :to_s, :start_tag, :end_tag
+    should have_reader :content
+
+    should "know it's content" do
+      assert_equal "a text node here", subject.content.to_s
+    end
+
+    should "know how to serialize itself" do
+      assert_equal "a text node here", subject.to_s
+    end
+
+  end
+
+end

data/test/partial_data_test.rb

@@ -0,0 +1,100 @@
+require "test/helper"
+require "undies/partial_data"
+
+class Undies::PartialData
+
+  class BasicTest < Test::Unit::TestCase
+    include TestBelt
+
+    context 'partial data'
+    subject { Undies::PartialData.new 'test/templates/index.html.rb' }
+    should have_readers :path, :name
+
+    should "be a kind of Hash" do
+      assert subject.kind_of?(::Hash)
+    end
+
+    should "complain if now path given" do
+      assert_raises ArgumentError do
+        Undies::PartialData.new
+      end
+    end
+
+  end
+
+  class NameTest < BasicTest
+
+    should "know its name given a file" do
+      data = Undies::PartialData.new('test/templates/current.html.rb')
+      assert_equal 'current', data.name
+    end
+
+    should "know its name given a file name with a leading char" do
+      data = Undies::PartialData.new('test/templates/_partial.html.rb')
+      assert_equal 'partial', data.name
+    end
+
+    should "know its name given a file name with multiple leading chars" do
+      data = Undies::PartialData.new('test/templates/__partial.html.rb')
+      assert_equal 'partial', data.name
+    end
+
+  end
+
+  class ValuesTest < BasicTest
+    before do
+      @path = 'test/templates/index.html.rb'
+    end
+    subject { Undies::PartialData.new(@path) }
+
+    should "not have any values by default" do
+      assert_equal({}, subject)
+    end
+
+    should "know its values" do
+      subject.values = {:name => 'A Name'}
+      assert_equal({:name => "A Name"}, subject)
+    end
+
+    should "complain when values not given as a hash" do
+      assert_raises ArgumentError do
+        subject.values = "some data"
+      end
+    end
+
+    should "force its object value to a string key" do
+      assert !subject.has_key?(:index)
+      assert !subject.has_key?('index')
+      subject.object = "thing"
+      assert !subject.has_key?(:index)
+      assert subject.has_key?('index')
+    end
+
+    should "force its name value to a string key" do
+      assert !subject.has_key?(:index)
+      assert !subject.has_key?('index')
+      subject.values = {:index => 'thing'}
+      assert !subject.has_key?(:index)
+      assert subject.has_key?('index')
+    end
+
+    should "set its values to its object" do
+      subject.object = "thing"
+      assert_equal({'index' => "thing"}, subject)
+    end
+
+    should "merge its object into the values" do
+      subject.object = "thing"
+      subject.values = {:color => "#FFF"}
+      assert_equal({'index' => "thing", :color => "#FFF"}, subject)
+    end
+
+    should "overwrite its object with the values if needed" do
+      subject.object = "thing"
+      subject.values = {'index' => "#FFF"}
+      assert_equal({'index' => "#FFF"}, subject)
+    end
+
+  end
+
+end

data/test/partial_test.rb

@@ -0,0 +1,41 @@
+require "test/helper"
+require "undies/partial"
+
+class Undies::Partial
+
+  class BasicTest < Test::Unit::TestCase
+    include TestBelt
+
+    context 'partial'
+    subject { Undies::Partial.new 'test/templates/index.html.rb' }
+
+    should "be a kind of Template" do
+      assert subject.kind_of?(Undies::Template)
+    end
+
+    should "complain if no path given" do
+      assert_raises ArgumentError do
+        Undies::Partial.new
+      end
+    end
+
+  end
+
+  class LocalsTest < BasicTest
+    before do
+      @path = 'test/templates/index.html.rb'
+    end
+
+    should "know its data" do
+      partial = Undies::Partial.new(@path, :name => 'A Name')
+      assert_equal("A Name", partial.name)
+    end
+
+    should "know its object" do
+      partial = Undies::Partial.new(@path, "thing")
+      assert_equal("thing", partial.index)
+    end
+
+  end
+
+end

data/test/source_test.rb

@@ -7,36 +7,45 @@ class Undies::Source
     include TestBelt
 
     context 'a source'
-    subject { Undies::Source.new(nil, Proc.new {}) }
+    subject { Undies::Source.new(Proc.new {}) }
+    should have_readers :source, :data
     should have_instance_method :file?
-    should have_readers :file, :block, :data
 
-    should "need a file or block to initialize" do
+    should "complain if no file or block given" do
       assert_raises ArgumentError do
         Undies::Source.new
       end
     end
+
+    should "complain if no block given and file does not exist" do
+      assert_raises ArgumentError do
+        Undies::Template.new "noexist.html.rb"
+      end
+    end
+
   end
 
   class BlockTest < BasicTest
     context 'from a block'
-    subject { Undies::Source.new(nil, Proc.new {}) }
+    subject { Undies::Source.new(Proc.new {}) }
 
     should "not be a file source" do
       assert !subject.file?
     end
+
   end
 
   class FileTest < BasicTest
     context 'from a file'
     subject do
-      file = 'test/test_template.html.rb'
+      file = 'test/templates/test.html.rb'
       Undies::Source.new(File.expand_path(file))
     end
 
     should "be a file source" do
       assert subject.file?
     end
+
   end
 
 end

data/test/template_test.rb

@@ -6,12 +6,136 @@ class Undies::Template
   class BasicTest < Test::Unit::TestCase
     include TestBelt
 
-    context 'template'
+    context 'a template'
     subject { Undies::Template.new {} }
-    should have_instance_methods :to_s
+    should have_instance_method :to_s
+    should have_instance_methods :_, :__, :element, :tag
+    should have_accessor :nodes
+
+    should "have a NodeList as its nodes" do
+      assert_kind_of Undies::NodeList, subject.nodes
+    end
+
   end
 
+
+
+  class NodeTest < BasicTest
+    context "with text data"
+    before do
+      @data = "stuff & <em>more stuff</em>"
+    end
+
+    should "return a text node using the '__' and '_' methods" do
+      assert_kind_of Undies::Node, subject.__(@data)
+      assert_kind_of Undies::Node, subject._(@data)
+    end
+
+    should "also add the node using the '__' and '_' methods" do
+      subject.__(@data)
+      assert_equal 1, subject.nodes.size
+      subject._(@data)
+      assert_equal 2, subject.nodes.size
+    end
+
+    should "add the text un-escaped using the '__' method" do
+      assert_equal @data, subject.__(@data).to_s
+    end
+
+    should "add the text escaped using the '_' method" do
+      assert_equal subject.send(:escape_html, @data), subject._(@data).to_s
+    end
+
+  end
+
+
+
+  class ElementTest < BasicTest
+    context "using the 'element' helper"
+
+    should "return an Element object" do
+      assert_equal Undies::Element.new([], :br), subject.element(:br)
+    end
+
+    should "alias it with 'tag'" do
+      assert_equal subject.element(:br), subject.tag(:br)
+    end
+
+    should "add a new Element object" do
+      subject.element(:br)
+      assert_equal 1, subject.nodes.size
+      assert_equal Undies::Element.new([], :br), subject.nodes.first
+    end
+
+    should "respond to underscore-prefix methods" do
+      assert subject.respond_to?(:_div)
+    end
+
+    should "respond to underscore-prefix methods as element methods" do
+      assert_equal subject._div, subject.element(:div)
+    end
+
+    should "not respond to element methods without an underscore-prefix" do
+      assert !subject.respond_to?(:div)
+      assert_raises NoMethodError do
+        subject.div
+      end
+    end
+
+  end
+
+
+
+  class DataTest < BasicTest
+
+    should "only accept the data if it is a Hash" do
+      assert_raises NoMethodError do
+        (Undies::Template.new("some_data") {}).some
+      end
+      assert_raises NoMethodError do
+        (Undies::Template.new('test/templates/test.html.rb', "some_data")).some
+      end
+      assert_respond_to(
+        (Undies::Template.new(:some => "data") {}),
+        :some
+      )
+      assert_respond_to(
+        Undies::Template.new('test/templates/test.html.rb', :some => "data"),
+        :some
+      )
+    end
+
+    should "respond to each data key with its value" do
+      templ = Undies::Template.new(:some => "data") {}
+      assert_equal "data", templ.some
+    end
+
+  end
+
+
+
   class DefinitionTest < BasicTest
+
+    should "maintain the template's scope throughout content blocks" do
+      templ = Undies::Template.new do
+        _div {
+          _div {
+            __ self.object_id
+          }
+        }
+      end
+      assert_equal "<div><div>#{templ.object_id}</div></div>", templ.to_s
+    end
+
+    should "be able to access its data in the template definition" do
+      templ = Undies::Template.new(:name => "awesome") do
+        _div {
+          _div { _ name }
+        }
+      end
+      assert_equal "<div><div>awesome</div></div>", templ.to_s
+    end
+
     should "generate markup given a block" do
       assert_equal(
         "<html><head></head><body><div class=\"loud element\" id=\"header\">YEA!!</div></body></html>",
@@ -29,7 +153,7 @@ class Undies::Template
     end
 
     should "generate markup given a file" do
-      file = 'test/test_template.html.rb'
+      file = 'test/templates/test.html.rb'
       assert_equal(
         "<html><head></head><body><div class=\"file\">FILE!!</div></body></html>",
         Undies::Template.new(File.expand_path(file)).to_s
@@ -37,7 +161,7 @@ class Undies::Template
     end
 
     should "generate pretty printed markup" do
-      file = 'test/test_template.html.rb'
+      file = 'test/templates/test.html.rb'
       assert_equal(
         %{<html>
   <head>

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: undies
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 23
   prerelease: 
   segments: 
+  - 1
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors: 
 - Kelly D. Redding
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-22 00:00:00 Z
+date: 2011-07-25 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   requirement: &id001 !ruby/object:Gem::Requirement 
@@ -64,18 +64,25 @@ files:
 - README.rdoc
 - Rakefile
 - lib/undies.rb
-- lib/undies/buffer.rb
+- lib/undies/element.rb
+- lib/undies/node.rb
+- lib/undies/node_list.rb
+- lib/undies/partial.rb
+- lib/undies/partial_data.rb
 - lib/undies/source.rb
-- lib/undies/tag.rb
 - lib/undies/template.rb
 - lib/undies/version.rb
-- test/buffer_test.rb
+- test/element_test.rb
 - test/env.rb
 - test/helper.rb
+- test/node_list_test.rb
+- test/node_test.rb
+- test/partial_data_test.rb
+- test/partial_test.rb
 - test/source_test.rb
-- test/tag_test.rb
 - test/template_test.rb
-- test/test_template.html.rb
+- test/templates/index.html.rb
+- test/templates/test.html.rb
 - undies.gemspec
 homepage: http://github.com/kelredd/undies
 licenses: []
@@ -111,10 +118,14 @@ signing_key:
 specification_version: 3
 summary: A pure-Ruby HTML templating DSL.
 test_files: 
-- test/buffer_test.rb
+- test/element_test.rb
 - test/env.rb
 - test/helper.rb
+- test/node_list_test.rb
+- test/node_test.rb
+- test/partial_data_test.rb
+- test/partial_test.rb
 - test/source_test.rb
-- test/tag_test.rb
 - test/template_test.rb
-- test/test_template.html.rb
+- test/templates/index.html.rb
+- test/templates/test.html.rb

data/lib/undies/buffer.rb

@@ -1,81 +0,0 @@
-module Undies
-  class Buffer < ::Array
-
-    def initialize(*args)
-      super()
-    end
-
-    # Add data and don't escape it
-    def __(data="")
-      append_item(data)
-    end
-    # Add data and escape it
-    def _(data="")
-      append_item(escape_html(data))
-    end
-
-    TAG_METH_REGEX = /^_(.+)$/
-
-    def method_missing(meth, *args, &block)
-      if meth.to_s =~ TAG_METH_REGEX
-        tag($1, *args, &block)
-      else
-        super
-      end
-    end
-
-    def respond_to?(*args)
-      if args.first.to_s =~ TAG_METH_REGEX
-        true
-      else
-        super
-      end
-    end
-
-    def tag(name, attrs={}, &block)
-      append_item(new_tag=Tag.new(name, attrs, &block))
-      new_tag
-    end
-
-    def to_s(pp_level=0, pp_indent=nil)
-      self.collect do |i|
-        begin
-          i.to_s(pp_level, pp_indent)
-        rescue ArgumentError => err
-          pretty_print(i.to_s, pp_level, pp_indent)
-        end
-      end.join
-    end
-
-    protected
-
-    def pretty_print(data, level, indent)
-      indent ? "#{' '*level*indent}#{data}\n" : data
-    end
-
-    private
-
-    def append_item(data)
-      self << data
-    end
-
-    # Ripped from Rack v1.3.0 ======================================
-    # => ripped b/c I don't want a dependency on Rack for just this
-    ESCAPE_HTML = {
-      "&" => "&amp;",
-      "<" => "&lt;",
-      ">" => "&gt;",
-      "'" => "&#x27;",
-      '"' => "&quot;",
-      "/" => "&#x2F;"
-    }
-    ESCAPE_HTML_PATTERN = Regexp.union(*ESCAPE_HTML.keys)
-
-    # Escape ampersands, brackets and quotes to their HTML/XML entities.
-    def escape_html(string)
-      string.to_s.gsub(ESCAPE_HTML_PATTERN){|c| ESCAPE_HTML[c] }
-    end
-    # end Rip from Rack v1.3.0 =====================================
-
-  end
-end

data/test/buffer_test.rb

@@ -1,79 +0,0 @@
-require "test/helper"
-require "undies/buffer"
-require "undies/tag"
-
-class Undies::Buffer
-
-
-
-
-  class BasicTest < Test::Unit::TestCase
-    include TestBelt
-
-    context 'a buffer'
-    subject { Undies::Buffer.new }
-    should have_instance_methods :to_s, :_, :__, :tag
-
-    should "be a kind of ::Array" do
-      assert subject.kind_of?(::Array)
-    end
-
-  end
-
-
-
-  class DataTest < BasicTest
-    context "with data"
-    before do
-      @data = "stuff & <em>more stuff</em>"
-    end
-
-    should "add it un-escaped using the '__' method" do
-      subject.__ @data
-      assert_equal "stuff & <em>more stuff</em>", subject.to_s
-    end
-
-    should "add it escaped using the '_' method" do
-      subject._ @data
-      assert_equal "stuff &amp; &lt;em&gt;more stuff&lt;&#x2F;em&gt;", subject.to_s
-    end
-
-  end
-
-
-
-  class TagTest < BasicTest
-    context "when using the tag method"
-
-    should "return a new Tag object" do
-      assert_equal Undies::Tag.new(:br), subject.tag(:br)
-    end
-
-    should "add a new Tag object" do
-      subject.tag(:br)
-      assert_equal Undies::Tag.new(:br), subject.first
-    end
-
-    should "respond to any underscore prefix method" do
-      assert subject.respond_to?(:_div)
-    end
-
-    should "not respond to tag methods without an underscore prefix" do
-      assert !subject.respond_to?(:div)
-      assert_raises NoMethodError do
-        subject.div
-      end
-    end
-
-    should "interpret underscore prefix methods as a tag" do
-      assert_equal subject._div, subject.tag(:div)
-    end
-
-  end
-
-
-
-  # TODO: pretty printing
-
-
-end