RubyGems - undies - Versions diffs - 2.0.0 → 2.1.0 - Mend

undies 2.0.0 → 2.1.0

Files changed (13) hide show

data/Gemfile.lock CHANGED Viewed

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

data/README.rdoc CHANGED Viewed

@@ -1,74 +1,164 @@
 = Undies
-A pure-Ruby DSL for writing HTML or plain text templates.  Named for its gratuitous use of the underscore.
+A pure-Ruby DSL for streaming templated HTML, XML, or plain text.  Named for its gratuitous use of the underscore.
 == Installation
     $ gem install undies
-== Usage
-Empty tag:
-    _br # => "<br />"
-Tag with content:
-    _h1 {
-      _ "Some Header"
-    } # => "<h1>Some Header</h1>"
-Nested tags:
-    _body {
-      _div {
-        _ "Some Content"
-      }
-    } # => "<body><div>Some Content</div></body>"
-Buffer escaped output:
-    _ "this will be escaped & and added to the buffer"
-    # => "this will be escaped &amp; added to the buffer"
-Buffer un-escaped output:
+== DSL
+Undies uses an underscore-based DSL for rendering content.  It can render plain text, html-escaped text, xml, and html.
+=== Plain text
+Escaped (xml / html) text:
+    _ "this will be escaped & streamed"
+    # => "this will be escaped &amp; streamed"
+Raw (un-escaped) text:
     __ "this will <em>not</em> be escaped"
     # => "this will <em>not</em> be escaped"
-Tag with attributes
-    _h1(:class => 'title', :title => "A Header")
-    # => "<h1 class=\"title\" title=\"A Header\" />"
-Tag with id attribute
+=== XML
+Empty node:
+    _thing # => "<thing />"
+Node with content:
+    _thing {
+      _ "Some Content"
+      _ "More Content "
+    } # => "<thing>Some ContentMore Content</thing>"
+Node with attributes:
+    _thing(:one => 1, 'a' => "Aye")
+    # => "<thing one=\"1\" a=\"Aye\" />"
+Nested nodes:
+    _thing {
+      _Something {
+        _ "Some Content"
+      }
+    } # => "<thing><Something>Some Content</Something></thing>"
+Namespaces / Doctype stuff:
+    __ "<?xml version="1.0" encoding="UTF-8"?>"
+    _thing('xmlns:ss="urn:some-cool-namespace"') {
+        send("_ss:Value", {'ss:some_attr' => "some attr value"}) {
+            _ "Some Content"
+        }
+    } # => "<thing xmlns:ss=\"urn:some-cool-namespace\"><ss:Value ss:some_attr=\"some attr value\">Some Content</ss:Value>"
+Comments:
+    __ "<!-- some comment -->"
+    # => "<!-- some comment -->"
+=== HTML
+Same stuff applies:
+    __ "<!DOCTYPE html>"
+    _div(:style => "border-top: 1px") {
+      _h1 { _ "Hello World" }
+      _p  { _ "blah blah"   }
+    } # => "<div style=\"border-top: 1px\"><h1>Hello World</h1><p>blah blah</p></div>"
+id attribute helper:
     _h1.header!
     # => "<h1 id=\"header\" />"
-Tag with class attributes
+    _h1.header!.title!
+    # => "<h1 id=\"title\" />"
+class attributes helper:
     _h1.header.awesome
     # => "<h1 class=\"header awesome\" />"
-== Rendering Templates
+use in combo:
+    _h1.header!.awesome
+    # => "<h1 class=\"awesome\" id=\"header\" />
-* basic render:
-    # render a block of markup
-    Undies::Template.new do
-      _div {
-        _ "Some Content"
-      }
-    end.to_s
+== Streamed Output
+Undies works by streaming content defined by using its DSL to a given output stream.  Any call to Template#_, Template#__, or Tempate#_<node> will stream its output (or you can write helpers you mix in that use these base api methods).  This has a number of advantages:
+* content is written out immediately
+* maintain a relatively low memory profile while rendering
+* can process large templates with linear performance impact
+However, because content is streamed then forgotten as it is being rendered, Undies templates cannot be self-referrential.  No one element may refer to other previously rendered elements.
+== Rendering
+To render using Undies, create a Template instance, providing the template source, data, and output information.
+    source = Undies::Source.new("/path/to/sourcefile")
+    data = { :two_plus_two => 4 }
+    output = Undies::Output.new(@some_io_stream)
+    Undies::Template.new(source, {}, output)
+=== Source
+You specify Undies source using the Undies::Source object.  You can create source either form a block or a file.  Source content (either block or file) will be evaluated in context of the template.
+=== Data
+Undies renders source content in isolated scope (the context of the template).  This means that content has access to only the data it is given or the Undies API itself.  When you define a template for rendering, you provide not only the template source, but any data that source should be rendered with.  Data is given in the form of a Hash.  The string form of the hash keys are exposed as local methods that return their corresponding values.
-* streaming render
+=== Output
-    # render the template and push it to the output stream as it is being constructed
-    # just pass an IO to the template constructor
-    Undies::Template.new(output_io).new do
+As said before, Undies streams to a given output stream.  You specify a Template's output by creating an Undies::Output object.  These objects take an io stream and a hash of options:
+* :pp (pretty-print) : set to a Fixnum to tab-space indent pretty print the output.
+=== Examples
+    # file source, no local data, no pretty printing
+    source = Undies::Source.new("/path/to/source")
+    Undies::Template.new(source, {}, Undies::Output.new(@io))
+    # proc source, simple local data, no pretty printing
+    source = Undies::Source.new(Proc.new do
       _div {
-        _ "Some Content"
+        _ content.to_s
       }
-    end
+    end)
+    Undies::Template.new(source, {:content => "Some Content!!" }, Undies::Output.new(@io))
+    # pretty printing (4 space tab indentation)
+    source = Undies::Source.new("/path/to/source")
+    Undies::Template.new(source, {}, Undies::Output.new(@io, :pp => 4))
+=== Builder approach
+The above examples use the "source rendering" approach.  This works great when you know your source content before render time and create a source object from it (ie rendering a view template).  However, in some cases, you may not know the source until render time and/or want to use a more declarative style to specify render output.  Undies content can be specified programmatically using the "builder rendering" approach.
+To render using this approach, create a Template instance passing it data and output info as above.  However, don't pass in any source info, only pass in any local data if you like, and save off the created template:
+    # choosing not to use any local data in this example
+    template = Undies::Template.new(Undies::Output.new(@io))
+Now just interact with the Undies API directly.
-* render passing local vars in and pretty printing:
+    # notice that it becomes less important to bind any local data to the Template using this approach
+    something = "Some Thing!"
+    template._div.something! {
+      template._ something.to_s
+    }
-    # render a file with markup
-    # make the local vars 'four' and 'name' available the the template markup
-    # pretty print the output with 2-space indentation
-    Undies::Template.new("path/to/file", {
-      :four => 2 + 2,
-      :name => "Awesome"
-    }).to_s(2)
+*Note:* there is one extra caveat to be aware of using this approach.  You need to be sure and flush the template when content processing is complete.  Just pass the template to the Undies::Template#flush method:
-=== Pretty Printing
-If you want to pretty print the output, pass an integer specifying the number of spaces to indent to the `to_s` method.
+    # ensures all content is streamed to the template's output stream
+    # this is only necessary using the "builder approach"
+    Undies::Template.flush(template)
 == License
-Copyright (c) 2011 Kelly Redding
+Copyright (c) 2011-Present Kelly Redding
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/lib/undies/element.rb CHANGED Viewed

@@ -7,15 +7,17 @@ module Undies
     # polluting the public instance methods and to maximize the effectiveness
     # of the Element#method_missing logic
-    def self.html_attrs(attrs="", ns=nil)
-      if attrs.kind_of? ::Hash
-        attrs.empty? ? '' : (attrs.keys.map(&:to_s).sort.map(&:to_sym).inject('') do |html, key|
-          ak = ns ? "#{ns}_#{key}" : key.to_s
-          av = attrs[key]
-          html + (av.kind_of?(::Hash) ? html_attrs(av, ak) : " #{ak}=\"#{av}\"")
-        end)
-      else
-        attrs.to_s
+    def self.hash_attrs(attrs="", ns=nil)
+      return attrs.to_s if !attrs.kind_of?(::Hash)
+      {}.tap do |a|
+        attrs.each { |k, v| a[ns ? "#{ns}_#{k}" : k.to_s] = v }
+      end.sort.inject('') do |html, k_v|
+        html + if k_v.last.kind_of?(::Hash)
+          hash_attrs(k_v.last, k_v.first)
+        else
+          " #{k_v.first}=\"#{k_v.last.gsub('"', '&quot;').gsub('<', '&lt;')}\""
+        end
       end
     end
@@ -103,7 +105,7 @@ module Undies
     end
     def start_tag
-      "<#{@name}#{self.class.html_attrs(@attrs)}" + (@content_blocks.size > 0 ? ">" : " />")
+      "<#{@name}#{self.class.hash_attrs(@attrs)}" + (@content_blocks.size > 0 ? ">" : " />")
     end
     def end_tag

data/lib/undies/node.rb CHANGED Viewed

@@ -11,15 +11,21 @@ module Undies
     end
     def self.flush(output, node)
+      output.pp_use_indent = true if node.force_pp?
       output << self.content(node)
     end
-    def initialize(content)
+    def initialize(content, opts={})
       @start_tag = nil
       @end_tag = nil
+      @force_pp = opts[:force_pp]
       @content = content
     end
+    def force_pp?
+      !!@force_pp
+    end
     def ==(other_node)
       self.class.content(self) == other_node.class.content(other_node) &&
       self.instance_variable_get("@start_tag") == other_node.instance_variable_get("@start_tag") &&

data/lib/undies/output.rb CHANGED Viewed

@@ -1,11 +1,10 @@
-require 'undies/node'
-require 'undies/element'
 require 'undies/node_buffer'
 module Undies
   class Output
     attr_reader :io, :options, :pp, :node_buffer
+    attr_accessor :pp_use_indent
     # the output class wraps an IO stream, gathers pretty printing options,
     # and handles buffering nodes and pretty printing to the stream
@@ -23,7 +22,7 @@ module Undies
       # setup any pretty printing
       @pp = opts[:pp]
-      self.pp_level = 0
+      self.pp_level = opts[:pp_level] || 0
       self.pp_use_indent = true
       @options = opts
@@ -38,22 +37,13 @@ module Undies
       @pp_level  = value
     end
-    def pp_use_indent=(value)
-      @pp_use_indent = value
-    end
     def <<(data)
       @io << (@pp_use_indent ? "#{@pp_indent}#{data}" : data.to_s)
     end
-    def node(data="")
-      self.node_buffer.pull(self)
-      self.node_buffer.push(Node.new(data))
-    end
-    def element(name, attrs={}, &block)
+    def node(obj)
       self.node_buffer.pull(self)
-      self.node_buffer.push(Element.new(name, attrs, &block))
+      self.node_buffer.push(obj)
     end
     def flush

data/lib/undies/template.rb CHANGED Viewed

@@ -1,10 +1,13 @@
 require 'undies/source_stack'
 require 'undies/output'
+require 'undies/node'
+require 'undies/element'
 module Undies
   class Template
-    # have as many methods to the class level as possilbe to keep from
+    # 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
@@ -12,26 +15,37 @@ module Undies
       template.instance_variable_get("@_undies_output")
     end
-    def initialize(source, data, output)
+    def self.flush(template)
+      template.instance_variable_get("@_undies_output").flush
+    end
+    def initialize(*args)
+      output = if 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
-      raise ArgumentError, "please provide a Source object" if !source.kind_of?(Source)
       @_undies_source_stack = SourceStack.new(source)
-      raise ArgumentError, "please provide an Output object" if !output.kind_of?(Output)
-      @_undies_output = output
       # apply data to template scope
-      raise ArgumentError if !data.kind_of?(::Hash)
       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
       # yield to recursivley render the source stack
       self.__yield
       # flush any remaining output to the stream
-      @_undies_output.flush
+      self.class.flush(self)
     end
     # call this to render template source
@@ -56,10 +70,15 @@ module Undies
     def _(data=""); self.__ self.escape_html(data.to_s); end
     # Add a text node with the data un-escaped
-    def __(data=""); @_undies_output.node(data.to_s); end
+    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))
+    end
     # Add an element to the nodes of the current node
-    def element(*args, &block); @_undies_output.element(*args, &block); end
+    def element(*args, &block); @_undies_output.node(Element.new(*args, &block)); end
     alias_method :tag, :element
     # Element proxy methods ('_<element>'') ========================

data/lib/undies/version.rb CHANGED Viewed

@@ -1,3 +1,3 @@
 module Undies
-  VERSION = "2.0.0"
+  VERSION = "2.1.0"
 end

data/test/element_test.rb CHANGED Viewed

@@ -12,7 +12,7 @@ class Undies::Element
     end
     subject { @e }
-    should have_class_methods :html_attrs, :content, :flush
+    should have_class_methods :hash_attrs, :content, :flush
     should have_instance_method :to_str
     should "be a Node" do
@@ -29,22 +29,35 @@ class Undies::Element
   end
-  class HtmlAttrsTest < BasicTests
-    desc "the element class html_attrs util"
+  class HashAttrsTest < BasicTests
+    desc "the element class hash_attrs util"
-    should "convert an empty hash to html attrs" do
-      assert_equal '', Undies::Element.html_attrs({})
+    should "convert an empty hash to element attrs" do
+      assert_equal '', Undies::Element.hash_attrs({})
     end
-    should "convert a basic hash to html attrs" do
-      attrs = Undies::Element.html_attrs(:class => "test", :id => "test_1")
+    should "convert a basic hash to element attrs" do
+      attrs = Undies::Element.hash_attrs(:class => "test", :id => "test_1")
       assert_match /^\s{1}/, attrs
-      assert attrs.include?('class="test"')
-      assert attrs.include?('id="test_1"')
+      assert_includes 'class="test"', attrs
+      assert_includes 'id="test_1"', attrs
+      attrs = Undies::Element.hash_attrs('key' => "string")
+      assert_includes 'key="string"', attrs
+    end
+    should "escape double-quotes in attr values" do
+      attrs = Undies::Element.hash_attrs('escaped' => '"this" is double-quoted')
+      assert_includes 'escaped="&quot;this&quot; is double-quoted"', attrs
+    end
+    should "escape '<' in attr values" do
+      attrs = Undies::Element.hash_attrs('escaped' => 'not < escaped')
+      assert_includes 'escaped="not &lt; escaped"', attrs
     end
-    should "convert a nested hash to html attrs" do
-      attrs = Undies::Element.html_attrs({
+    should "convert a nested hash to element attrs" do
+      attrs = Undies::Element.hash_attrs({
         :class => "testing", :id => "test_2",
         :nested => {:something => 'is_awesome'}
       })
@@ -151,6 +164,14 @@ class Undies::Element
       assert_equal '<br class="big" />', @out
     end
+    should "serialize with attrs that have double-quotes" do
+      src = Undies::Source.new do
+        element(:br, :class => '"this" is double-quoted')
+      end
+      templ = Undies::Template.new(src, {}, @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
         element(:strong, {:class => 'big'}) { __ "Loud Noises!" }

data/test/node_test.rb CHANGED Viewed

@@ -28,6 +28,14 @@ class Undies::Node
       assert_equal "a text node here", out
     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}))
+      assert_equal "\n  should be pp", out
+    end
   end
 end

data/test/output_test.rb CHANGED Viewed

@@ -1,6 +1,9 @@
 require "assert"
 require 'stringio'
+require 'undies/node'
+require 'undies/element'
 require "undies/output"
 class Undies::Output
@@ -14,8 +17,9 @@ class Undies::Output
     subject { @output }
     should have_readers :io, :options, :pp, :node_buffer
+    should have_accessor :pp_use_indent
     should have_instance_methods :options=, :<<, :pp_level
-    should have_instance_methods :node, :element, :flush
+    should have_instance_methods :node, :flush
     should "know its stream" do
       assert_same @io, subject.io
@@ -57,6 +61,10 @@ class Undies::Output
       assert_equal 2, subject.pp
     end
+    should "start pp at level 0 by default" do
+      assert_equal 0, subject.pp_level
+    end
     should "pretty print stream data" do
       subject << "some data"
       assert_equal "\nsome data", @out
@@ -71,43 +79,48 @@ class Undies::Output
     end
     should "pretty print nodes" do
-      subject.node("lala"); subject.flush
+      subject.node(Undies::Node.new("lala")); subject.flush
       assert_equal "\nlala", @out
     end
+    should "pretty print at a given level if directed to" do
+      subject.options = {:pp => 2, :pp_level => 2}
+      subject.node(Undies::Node.new("lala")); subject.flush
+      assert_equal "\n    lala", @out
+    end
     should "pretty print elements with no content" do
-      subject.element("span"); subject.flush
+      subject.node(Undies::Element.new("span")); subject.flush
       assert_equal "\n<span />", @out
     end
-    should "pretty print elements with content" do
-      subject.element("div") {}; subject.flush
-      assert_equal "\n<div></div>", @out
+    should "keep node content on the same line" do
+      subject.node(Undies::Element.new("div") {
+        subject.node Undies::Node.new("hi")
+        subject.node Undies::Node.new("there")
+      })
+      subject.node(Undies::Element.new("div") {
+        subject.node Undies::Node.new("")
+        subject.node Undies::Node.new("hi")
+        subject.node Undies::Node.new("again")
+      })
+      subject.flush
+      assert_equal "\n<div>hithere</div>\n<div>hiagain</div>", @out
     end
   end
   class NodeHandlingTests < BasicTests
-    before do
-      @hey = Undies::Node.new "hey!"
-      src = Undies::Source.new do
-        _div.good.thing!(:type => "something") {
-          __ "action"
-        }
-      end
-      @expected_output = "hey!"
-    end
     should "create and append nodes" do
-      assert_equal @hey, subject.node("hey!")
+      subject.node Undies::Node.new "hey!"
       assert_equal 1, subject.node_buffer.size
     end
     should "create and append elements" do
-      elem = Undies::Element.new(:div)
-      assert_equal elem, subject.element(:div)
+      subject.node Undies::Element.new(:div)
       assert_equal 1, subject.node_buffer.size
     end

data/test/template_test.rb CHANGED Viewed

@@ -8,18 +8,18 @@ class Undies::Template
   class BasicTests < Assert::Context
     desc 'a template'
     before do
-      src = Undies::Source.new(Proc.new {})
+      @src = Undies::Source.new(Proc.new {})
       @outstream = StringIO.new(@out = "")
       @output = Undies::Output.new(@outstream)
-      @t = Undies::Template.new(src, {}, @output)
+      @t = Undies::Template.new(@src, {}, @output)
     end
     subject { @t }
-    should have_class_method :output
+    should have_class_method :output, :flush
     should have_instance_method  :to_s
     should have_instance_methods :element, :tag, :escape_html
-    should have_instance_methods :_, :__
+    should have_instance_methods :_, :__, :___
     should have_instance_methods :__yield, :__partial
     should "provide access to its output object via a class method" do
@@ -55,12 +55,42 @@ class Undies::Template
   end
+  class TemplateCreationTests < BasicTests
+    should "complain if creating a template with no Output obj" do
+      assert_raises ArgumentError do
+        Undies::Template.new(@src, {})
+      end
+    end
+    should "default the data to an empty hash if none provided" do
+      assert_nothing_raised do
+        Undies::Template.new(@src, @output)
+      end
+    end
+    should "default the source to an empty Proc source if none provided" do
+      assert_nothing_raised do
+        Undies::Template.new(@output)
+      end
+      assert_equal "", @out
+    end
+  end
   class NodeTests < BasicTests
     desc "with text data"
     before do
       @data = "stuff & <em>more stuff</em>"
     end
+    should "add the text escaped using the '_' method" do
+      Undies::Template.new(Undies::Source.new do
+        _ data
+      end, {:data => @data}, @output)
+      assert_equal subject.send(:escape_html, @data), @out
+    end
     should "add the text un-escaped using the '__' method" do
       Undies::Template.new(Undies::Source.new do
         __ data
@@ -68,11 +98,17 @@ class Undies::Template
       assert_equal @data, @out
     end
-    should "add the text escaped using the '_' method" do
+    should "add the text un-escaped with force pretty printing using the '___' method" do
+      output = Undies::Output.new(@outstream, :pp => 2)
       Undies::Template.new(Undies::Source.new do
-        _ data
-      end, {:data => @data}, @output)
-      assert_equal subject.send(:escape_html, @data), @out
+        _div {
+          __ "not-pp"
+          ___ "pp"
+          __ "not-pp-but-anyway"
+        }
+      end, {}, output)
+      assert_equal "\n<div>not-pp\n  pp\n  not-pp-but-anyway\n</div>", @out
     end
     should "add empty string nodes using '__' and '_' methods with no args" do
@@ -240,7 +276,7 @@ class Undies::Template
       end
       @expected_output = "<div class=\"good\" id=\"thing\" type=\"something\">action</div>"
-      Undies::Template.new(src, {}, Undies::Output.new(outstream))
+      @template = Undies::Template.new(src, {}, Undies::Output.new(outstream))
     end
     should "should write to the stream as its being constructed" do
@@ -249,5 +285,20 @@ class Undies::Template
   end
+  class FlushTests < StreamTests
+    desc "and adds content post-init"
+    before do
+      @expected_post_output = "<div>Added post-init</div>"
+      @template._div { @template._ "Added post-init" }
+    end
+    should "not stream full content until Undies#flush called on the template" do
+      assert_equal @expected_output, @output
+      Undies::Template.flush(@template)
+      assert_equal @expected_output + @expected_post_output, @output
+    end
+  end
 end

data/undies.gemspec CHANGED Viewed

@@ -9,8 +9,8 @@ Gem::Specification.new do |s|
   s.authors     = ["Kelly Redding"]
   s.email       = ["kelly@kelredd.com"]
   s.homepage    = "http://github.com/kelredd/undies"
-  s.summary     = %q{A pure-Ruby HTML and plain text templating DSL.}
-  s.description = %q{A pure-Ruby HTML and plain text templating DSL.}
+  s.summary     = %q{A pure-Ruby DSL for streaming templated HTML, XML, or plain text. Named for its gratuitous use of the underscore.}
+  s.description = %q{A pure-Ruby DSL for streaming templated HTML, XML, or plain text. Named for its gratuitous use of the underscore.}
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

metadata CHANGED Viewed

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: undies
 version: !ruby/object:Gem::Version
-  hash: 15
+  hash: 11
   prerelease:
   segments:
   - 2
+  - 1
   - 0
-  - 0
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Kelly Redding
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
-date: 2011-12-05 00:00:00 Z
+date: 2012-01-10 00:00:00 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   type: :development
@@ -48,7 +48,7 @@ dependencies:
         version: 0.7.3
   version_requirements: *id002
   name: assert
-description: A pure-Ruby HTML and plain text templating DSL.
+description: A pure-Ruby DSL for streaming templated HTML, XML, or plain text. Named for its gratuitous use of the underscore.
 email:
 - kelly@kelredd.com
 executables: []
@@ -125,7 +125,7 @@ rubyforge_project:
 rubygems_version: 1.8.11
 signing_key:
 specification_version: 3
-summary: A pure-Ruby HTML and plain text templating DSL.
+summary: A pure-Ruby DSL for streaming templated HTML, XML, or plain text. Named for its gratuitous use of the underscore.
 test_files:
 - test/element_test.rb
 - test/helper.rb