RubyGems - erector - Versions diffs - 0.6.3 → 0.6.4 - Mend

erector 0.6.3 → 0.6.4

Files changed (16) hide show

data/README.txt +10 -5
data/VERSION.yml +1 -1
data/bin/erector +3 -1
data/lib/erector.rb +1 -0
data/lib/erector/erect.rb +4 -2
data/lib/erector/erected.rb +14 -4
data/lib/erector/mixin.rb +7 -0
data/lib/erector/rhtml.treetop +48 -11
data/lib/erector/widget.rb +146 -113
data/spec/erect/erect_rails_spec.rb +62 -0
data/spec/erect/erect_spec.rb +165 -0
data/spec/erect/erected_spec.rb +93 -0
data/spec/erect/rhtml_parser_spec.rb +351 -0
data/spec/erector/mixin_spec.rb +54 -0
data/spec/erector/widget_spec.rb +38 -0
metadata +8 -2

data/README.txt CHANGED Viewed

@@ -25,20 +25,25 @@ project site at http://erector.rubyforge.org for more documentation.
           end
           body do
             text "Hello, "
-            b "#{target}!", :class => 'big'
+            b target, :class => 'big'
+            text "!"
           end
         end
       end
     end
     Hello.new(:target => 'world').to_s
-    => "<html><head><title>Hello</title></head><body>Hello, <b class=\"big\">world!</b></body></html>"
+    => "<html><head><title>Hello</title></head><body>Hello, <b class=\"big\">world</b>!</body></html>"
+    include Erector::Mixin
+    erector { div "love", :class => "big" }
+    => "<div class=\"big\">love</div>"
 == REQUIREMENTS
-The gem depends on rake and treetop, although this is just for using the "erect" tool,
-so deployed applications won't need these. Currently it also requires rails, although
-we plan to separate the rails-dependent code so you can use Erector cleanly in a non-Rails app.
+The gem depends on rake and treetop, although this is just for using the command-line tool,
+so deployed applications won't need these. The Rails-dependent code is now separated so
+you can use Erector cleanly in a non-Rails app.
 == INSTALL

data/VERSION.yml CHANGED Viewed

@@ -1,5 +1,5 @@
 ---
 :major: 0
 :minor: 6
-:patch: 3
+:patch: 4

data/bin/erector CHANGED Viewed

@@ -4,4 +4,6 @@ $LOAD_PATH.unshift("#{dir}/../lib")
 require "erector"
 require "erector/erect"
-Erector::Erect.new(ARGV).run
+unless Erector::Erect.new(ARGV).run
+  exit 1
+end

data/lib/erector.rb CHANGED Viewed

@@ -10,6 +10,7 @@ require "#{dir}/erector/widget"
 require "#{dir}/erector/unicode"
 require "#{dir}/erector/widgets"
 require "#{dir}/erector/version"
+require "#{dir}/erector/mixin"
 if Object.const_defined?(:RAILS_ROOT)
   require "#{dir}/erector/rails"
 end

data/lib/erector/erect.rb CHANGED Viewed

@@ -78,7 +78,9 @@ module Erector
     end
     def run
+      @success = true
       self.send(mode)
+      @success
     end
     def to_erector
@@ -91,7 +93,7 @@ module Erector
         rescue => e
           puts e
           puts e.backtrace.join("\n\t")
-          puts
+          @success = false
         end
       end
     end
@@ -103,7 +105,6 @@ module Erector
         begin
           #todo: fail if file isn't a .rb file
           require file
-          #todo: understand modulized widgets (e.g. class Foo::Bar::Baz < Erector::Widget in baz.rb)
           filename = file.split('/').last.gsub(/\.rb$/, '')
           widget_name = camelize(filename)
           widget_class = constantize(widget_name)
@@ -124,6 +125,7 @@ module Erector
         rescue => e
           puts e
           puts e.backtrace.join("\n\t")
+          @success = false
         end
       end
     end

data/lib/erector/erected.rb CHANGED Viewed

@@ -6,6 +6,7 @@ Treetop.load("#{dir}/rhtml.treetop")
 module Erector
   class Erected
     def initialize(in_file)
       @in_file = in_file
     end
@@ -14,14 +15,23 @@ module Erector
       dir + basename + ".rb"
     end
-    def classname
+    def classnames
       base = classize(basename)
       parent = File.dirname(@in_file)
       grandparent = File.dirname(parent)
       if File.basename(grandparent) == "views"
-        base = "Views::" + classize(File.basename(parent)) + "::" + base
+        ["Views::" + classize(File.basename(parent)) + "::" + base, "Erector::RailsWidget"]
+      else
+        [base, "Erector::Widget"]
       end
-      base
+    end
+    def classname
+      classnames[0]
+    end
+    def parent_class
+      classnames[1]
     end
     def text
@@ -36,7 +46,7 @@ module Erector
           parser.failure_reason
       else
         File.open(filename, "w") do |f|
-          f.puts("class #{classname} < Erector::Widget")
+          f.puts("class #{classname} < #{parent_class}")
           f.puts("  def content")
           f.puts(parsed.set_indent(2).convert)
           f.puts("  end")

data/lib/erector/mixin.rb ADDED Viewed

@@ -0,0 +1,7 @@
+module Erector
+  module Mixin
+    def erector(options = {}, &block)
+      Erector::Widget.new(&block).to_s(options)
+    end
+  end
+end

data/lib/erector/rhtml.treetop CHANGED Viewed

@@ -13,7 +13,35 @@ grammar Rhtml
   end
   rule node
-    hprintlet / printlet / scriptlet / doctype / self_closing_tag / imgtag / closetag / opentag / text
+    yield_with_name / yield / hprintlet / printlet / scriptlet / doctype / directive / self_closing_tag / imgtag / closetag / opentag / text
+  end
+  # Argh. For some reason I can't get this to work, so I split it into two rules
+  # rule yield
+  #   '<%=' space 'yield' space (':' varname space)? '%>' <Erector::Indenting> {
+  #     def convert
+  #       var = "@content_for_" + varname.nil? ? "layout" : varname.text_value
+  #       line "rawtext #{var} # Note: you must define #{var} elsewhere"
+  #     end
+  #   }
+  # end
+  rule yield_with_name
+    '<%=' space 'yield' space ':' varname space '%>' <Erector::Indenting> {
+      def convert
+        var = "@content_for_" + varname.text_value
+        line "rawtext #{var} # Note: you must define #{var} elsewhere"
+      end
+    }
+  end
+  rule yield
+    '<%=' space 'yield' space '%>' <Erector::Indenting> {
+      def convert
+        var = "@content_for_layout"
+        line "rawtext #{var} # Note: you must define #{var} elsewhere"
+      end
+    }
   end
   rule scriptlet
@@ -53,10 +81,6 @@ grammar Rhtml
         code = text_value.strip
         # matches a word, followed by either a word, a string, or a symbol
         result = code.gsub(/^(\w+) ([\w:"'].*)$/, '\1(\2)')
-        # Convert yield, for layouts
-        #result.gsub!(/^yield$/, '@content')
         result
       end
     }
@@ -69,15 +93,27 @@ grammar Rhtml
 			end
 		}
 	end
+	rule directive
+	  '<!' [^>]* '>' <Erector::Indenting> {
+			def convert
+				line "rawtext '#{text_value}'"
+			end
+		}
+	end
   rule tagname
     [A-Za-z0-9_:-]+
   end
+  rule varname
+    [A-Za-z0-9_]+
+  end
   rule self_closing_tag
     '<' tag_name:tagname attrs:attributes? space '/>' <Erector::Indenting> {
       def convert
-        line "#{tag_name.text_value}#{attrs.blank? ? "" : attrs.convert}"
+        line "#{tag_name.text_value}#{attrs.empty? ? "" : attrs.convert}"
       end
     }
   end
@@ -85,7 +121,7 @@ grammar Rhtml
   rule opentag
    '<' tag_name:tagname attrs:attributes? space '>' <Erector::Indenting> {
       def convert
-        line_in "#{tag_name.text_value}#{attrs.blank? ? "" : attrs.convert} do"
+        line_in "#{tag_name.text_value}#{attrs.empty? ? "" : attrs.convert} do"
       end
     }
   end
@@ -93,7 +129,7 @@ grammar Rhtml
   rule imgtag
    '<' tag_name:'img' attrs:attributes? space '>' <Erector::Indenting> {
       def convert
-        line "#{tag_name.text_value}#{attrs.blank? ? "" : attrs.convert}"
+        line "#{tag_name.text_value}#{attrs.empty? ? "" : attrs.convert}"
       end
     }
   end
@@ -110,10 +146,11 @@ grammar Rhtml
     (([<>] !(tagname / [/%!])) / [^<>])+ <Erector::Indenting> {
       def convert
         stripped = text_value.strip
-        if stripped.blank?
+        if stripped.empty?
           ""
         else
-          line "text '#{text_value.strip.html_unescape}'"
+          line "text '#{stripped.html_unescape.gsub(/\'/, "\\\\'")
+          }'"
         end
       end
     }
@@ -123,7 +160,7 @@ grammar Rhtml
 		first:attribute rest:attributes* {
 			def convert
 				" " + first.convert +
-					if rest.blank?
+					if rest.empty?
 						""
 					else
 					  ",#{rest.elements.first.convert}"  # this is hacky -- is there a better way?

data/lib/erector/widget.rb CHANGED Viewed

@@ -2,45 +2,49 @@ module Erector
   # A Widget is the center of the Erector universe.
   #
-  # To create a widget, extend Erector::Widget and implement
-  # the +content+ method. Inside this method you may call any of the tag methods like +span+ or +p+ to emit HTML/XML
-  # tags.
-  #
-  # You can also define a widget on the fly by passing a block to +new+. This block will get executed when the widget's
-  # +content+ method is called.
+  # To create a widget, extend Erector::Widget and implement the +content+
+  # method. Inside this method you may call any of the tag methods like +span+
+  # or +p+ to emit HTML/XML tags.
+  #
+  # You can also define a widget on the fly by passing a block to +new+. This
+  # block will get executed when the widget's +content+ method is called.
   #
-  # To render a widget from the outside, instantiate it and call its +to_s+ method.
+  # To render a widget from the outside, instantiate it and call its +to_s+
+  # method.
   #
-  # A widget's +new+ method optionally accepts an options hash. Entries in this hash are converted to instance
-  # variables, and +attr_reader+ accessors are defined for each.
+  # A widget's +new+ method optionally accepts an options hash. Entries in
+  # this hash are converted to instance variables, and +attr_reader+ accessors
+  # are defined for each.
   #
-  # TODO: You can add runtime input checking via the +needs+ macro. If any of the variables named via
-  # +needs+ are absent, an exception is thrown. Optional variables are specified with +wants+. If a variable appears
-  # in the options hash that is in neither the +needs+ nor +wants+ lists, then that too provokes an exception.
-  # This mechanism is meant to ameliorate development-time confusion about exactly what parameters are supported
-  # by a given widget, avoiding confusing runtime NilClass errors.
-  #
-  # To call one widget from another, inside the parent widget's +content+ method, instantiate the child widget and call
-  # the +widget+ method. This assures that the same output stream
-  # is used, which gives better performance than using +capture+ or +to_s+. It also preserves the indentation and
-  # helpers of the enclosing class.
-  #
-  # In this documentation we've tried to keep the distinction clear between methods that *emit* text and those that
-  # *return* text. "Emit" means that it writes to the output stream; "return" means that it returns a string
-  # like a normal method and leaves it up to the caller to emit that string if it wants.
+  # You can add runtime input checking via the +needs+ macro. See #needs.
+  # This mechanism is meant to ameliorate development-time confusion about
+  # exactly what parameters are supported by a given widget, avoiding
+  # confusing runtime NilClass errors.
+  #
+  # To call one widget from another, inside the parent widget's +content+
+  # method, instantiate the child widget and call the +widget+ method. This
+  # assures that the same output stream is used, which gives better
+  # performance than using +capture+ or +to_s+. It also preserves the
+  # indentation and helpers of the enclosing class.
+  #
+  # In this documentation we've tried to keep the distinction clear between
+  # methods that *emit* text and those that *return* text. "Emit" means that
+  # it writes to the output stream; "return" means that it returns a string
+  # like a normal method and leaves it up to the caller to emit that string if
+  # it wants.
   class Widget
     class << self
       def all_tags
         Erector::Widget.full_tags + Erector::Widget.empty_tags
       end
-      # tags which are always self-closing
+      # Tags which are always self-closing. Click "[Source]" to see the full list.
       def empty_tags
         ['area', 'base', 'br', 'col', 'frame',
         'hr', 'img', 'input', 'link', 'meta']
       end
-      # tags which can contain other stuff
+      # Tags which can contain other stuff. Click "[Source]" to see the full list.
       def full_tags
         [
           'a', 'abbr', 'acronym', 'address',
@@ -81,36 +85,37 @@ module Erector
       end
     end
-    # Class method by which widget classes can declare that they need certain parameters.
-    # If needed parameters are not passed in to #new, then an exception will be thrown
-    # (with a hopefully useful message about which parameters are missing). This is intended
-    # to catch silly bugs like passing in a parameter called 'name' to a widget that expects
-    # a parameter called 'title'. Every variable declared in 'needs' will get an attr_reader
-    # accessor declared for it.
+    # Class method by which widget classes can declare that they need certain
+    # parameters. If needed parameters are not passed in to #new, then an
+    # exception will be thrown (with a hopefully useful message about which
+    # parameters are missing). This is intended to catch silly bugs like
+    # passing in a parameter called 'name' to a widget that expects a
+    # parameter called 'title'. Every variable declared in 'needs' will get an
+    # attr_reader accessor declared for it.
     #
-    # You can also declare default values for parameters using hash syntax. You can put #needs
-    # declarations on multiple lines or on the same line; the only caveat is that if there are
-    # default values, they all have to be at the end of the line (so they go into the magic
-    # hash parameter).
+    # You can also declare default values for parameters using hash syntax.
+    # You can put #needs declarations on multiple lines or on the same line;
+    # the only caveat is that if there are default values, they all have to be
+    # at the end of the line (so they go into the magic hash parameter).
     #
-    # If a widget has no #needs declaration then it will accept any combination of parameters
-    # (and make accessors for them) just like normal. In that case there will be no 'attr_reader's
-    # declared.
-    # If a widget wants to declare that it
-    # takes no parameters, use the special incantation "needs nil" (and don't declare any other
-    # needs, or kittens will cry).
+    # If a widget has no #needs declaration then it will accept any
+    # combination of parameters (and make accessors for them) just like
+    # normal. In that case there will be no 'attr_reader's declared. If a
+    # widget wants to declare that it takes no parameters, use the special
+    # incantation "needs nil" (and don't declare any other needs, or kittens
+    # will cry).
     #
     # Usage:
     #    class FancyForm < Erector::Widget
     #      needs :title, :show_okay => true, :show_cancel => false
     #      ...
     #    end
-    #
-    # That means that
+    #
+    # That means that
     #   FancyForm.new(:title => 'Login')
-    # will succeed, as will
+    # will succeed, as will
     #   FancyForm.new(:title => 'Login', :show_cancel => true)
-    # but
+    # but
     #   FancyForm.new(:name => 'Login')
     # will fail.
     #
@@ -237,25 +242,38 @@ module Erector
       to_s(:prettyprint => true)
     end
-    # Entry point for rendering a widget (and all its children). This method creates a new output string (if necessary),
-    # calls this widget's #content method and returns the string.
+    # Entry point for rendering a widget (and all its children). This method
+    # creates a new output string (if necessary), calls this widget's #content
+    # method and returns the string.
     #
     # Options:
     # output:: the string to output to. Default: a new empty string
-    # prettyprint:: whether Erector should add newlines and indentation. Default: the value of prettyprint_default (which is false by default).
-    # indentation:: the amount of spaces to indent. Ignored unless prettyprint is true.
-    # helpers:: a helpers object containing utility methods. Usually this is a Rails view object.
-    # content_method_name:: in case you want to call a method other than #content, pass its name in here.
-    #
-    # Note: Prettyprinting is an experimental feature and is subject to change
-    # (either in terms of how it is enabled, or in terms of
-    # what decisions Erector makes about where to add whitespace).
+    # prettyprint:: whether Erector should add newlines and indentation.
+    #               Default: the value of prettyprint_default (which is false
+    #               by default).
+    # indentation:: the amount of spaces to indent. Ignored unless prettyprint
+    #               is true.
+    # helpers:: a helpers object containing utility methods. Usually this is a
+    #           Rails view object.
+    # content_method_name:: in case you want to call a method other than
+    #                       #content, pass its name in here.
     def to_s(options = {}, &blk)
       raise "Erector::Widget#to_s now takes an options hash, not a symbol. Try calling \"to_s(:content_method_name=> :#{options})\"" if options.is_a? Symbol
+      _render(options, &blk).to_s
+    end
+    # Entry point for rendering a widget (and all its children). Same as #to_s
+    # only it returns an array, for theoretical performance improvements when using a
+    # Rack server (like Sinatra or Rails Metal).
+    #
+    # # Options: see #to_s
+    def to_a(options = {}, &blk)
+      _render(options, &blk).to_a
+    end
+    def _render(options = {}, &blk)
       options = {
-        :output => "",
+        :output => "",  # "" is apparently faster than [] in a long-running process
         :prettyprint => prettyprint_default,
         :indentation => 0,
         :helpers => nil,
@@ -263,24 +281,29 @@ module Erector
       }.merge(options)
       context(options[:output], options[:prettyprint], options[:indentation], options[:helpers]) do
         send(options[:content_method_name], &blk)
-        output.to_s
+        output
       end
     end
     alias_method :inspect, :to_s
-    # Template method which must be overridden by all widget subclasses. Inside this method you call the magic
-    # #element methods which emit HTML and text to the output string.
+    # Template method which must be overridden by all widget subclasses.
+    # Inside this method you call the magic #element methods which emit HTML
+    # and text to the output string. If you call "super" (or don't override
+    # +content+) then your widget will render any block that was passed into
+    # its constructor (in the current instance context so it can get access
+    # to parent widget methods via method_missing).
     def content
       if @block
         instance_eval(&@block)
       end
     end
-    # To call one widget from another, inside the parent widget's +content+ method, instantiate the child widget and call
-    # its +write_via+ method, passing in +self+. This assures that the same output string
-    # is used, which gives better performance than using +capture+ or +to_s+.
-    # You can also use the +widget+ method.
+    # To call one widget from another, inside the parent widget's +content+
+    # method, instantiate the child widget and call its +write_via+ method,
+    # passing in +self+. This assures that the same output string is used,
+    # which gives better performance than using +capture+ or +to_s+. You can
+    # also use the +widget+ method.
     def write_via(parent)
       @parent = parent
       context(parent.output, parent.prettyprint, parent.indentation, parent.helpers) do
@@ -288,13 +311,14 @@ module Erector
       end
     end
-    # Emits a (nested) widget onto the current widget's output stream. Accepts either
-    # a class or an instance. If the first argument is a class, then the second argument
-    # is a hash used to populate its instance variables. If the first argument is an
-    # instance then the hash must be unspecified (or empty).
+    # Emits a (nested) widget onto the current widget's output stream. Accepts
+    # either a class or an instance. If the first argument is a class, then
+    # the second argument is a hash used to populate its instance variables.
+    # If the first argument is an instance then the hash must be unspecified
+    # (or empty).
     #
-    # The sub-widget will have access to the methods of the parent class, via some method_missing
-    # magic and a "parent" pointer.
+    # The sub-widget will have access to the methods of the parent class, via
+    # some method_missing magic and a "parent" pointer.
     def widget(target, assigns={}, &block)
       child = if target.is_a? Class
         target.new(assigns, &block)
@@ -315,40 +339,46 @@ module Erector
 #-- methods for subclasses to call
 #++
-    # Internal method used to emit an HTML/XML element, including an open tag, attributes (optional, via the default hash),
-    # contents (also optional), and close tag.
+    # Internal method used to emit an HTML/XML element, including an open tag,
+    # attributes (optional, via the default hash), contents (also optional),
+    # and close tag.
     #
-    # Using the arcane powers of Ruby, there are magic methods that call +element+ for all the standard
-    # HTML tags, like +a+, +body+, +p+, and so forth. Look at the source of #full_tags for the full list.
-    # Unfortunately, this big mojo confuses rdoc, so we can't see each method in this rdoc page, but trust
-    # us, they're there.
+    # Using the arcane powers of Ruby, there are magic methods that call
+    # +element+ for all the standard HTML tags, like +a+, +body+, +p+, and so
+    # forth. Look at the source of #full_tags for the full list.
+    # Unfortunately, this big mojo confuses rdoc, so we can't see each method
+    # in this rdoc page, but trust us, they're there.
     #
-    # When calling one of these magic methods, put attributes in the default hash. If there is a string parameter,
-    # then it is used as the contents. If there is a block, then it is executed (yielded), and the string parameter is ignored.
-    # The block will usually be in the scope of the child widget, which means it has access to all the
-    # methods of Widget, which will eventually end up appending text to the +output+ string. See how
-    # elegant it is? Not confusing at all if you don't think about it.
+    # When calling one of these magic methods, put attributes in the default
+    # hash. If there is a string parameter, then it is used as the contents.
+    # If there is a block, then it is executed (yielded), and the string
+    # parameter is ignored. The block will usually be in the scope of the
+    # child widget, which means it has access to all the methods of Widget,
+    # which will eventually end up appending text to the +output+ string. See
+    # how elegant it is? Not confusing at all if you don't think about it.
     #
     def element(*args, &block)
       __element__(*args, &block)
     end
-    # Internal method used to emit a self-closing HTML/XML element, including a tag name and optional attributes
-    # (passed in via the default hash).
-    #
-    # Using the arcane powers of Ruby, there are magic methods that call +empty_element+ for all the standard
-    # HTML tags, like +img+, +br+, and so forth. Look at the source of #empty_tags for the full list.
-    # Unfortunately, this big mojo confuses rdoc, so we can't see each method in this rdoc page, but trust
-    # us, they're there.
+    # Internal method used to emit a self-closing HTML/XML element, including
+    # a tag name and optional attributes (passed in via the default hash).
+    #
+    # Using the arcane powers of Ruby, there are magic methods that call
+    # +empty_element+ for all the standard HTML tags, like +img+, +br+, and so
+    # forth. Look at the source of #empty_tags for the full list.
+    # Unfortunately, this big mojo confuses rdoc, so we can't see each method
+    # in this rdoc page, but trust us, they're there.
     #
     def empty_element(*args, &block)
       __empty_element__(*args, &block)
     end
-    # Returns an HTML-escaped version of its parameter. Leaves the output string untouched. Note that
-    # the #text method automatically HTML-escapes its parameter, so be careful *not* to do something like
-    # text(h("2<4")) since that will double-escape the less-than sign (you'll get "2&amp;lt;4" instead of
-    # "2&lt;4").
+    # Returns an HTML-escaped version of its parameter. Leaves the output
+    # string untouched. Note that the #text method automatically HTML-escapes
+    # its parameter, so be careful *not* to do something like text(h("2<4"))
+    # since that will double-escape the less-than sign (you'll get
+    # "2&amp;lt;4" instead of "2&lt;4").
     def h(content)
       content.html_escape
     end
@@ -358,20 +388,20 @@ module Erector
       indent_for_open_tag(tag_name)
       @indentation += SPACES_PER_INDENT
-      output.concat "<#{tag_name}#{format_attributes(attributes)}>"
+      output << "<#{tag_name}#{format_attributes(attributes)}>"
       @at_start_of_line = false
     end
-    # Emits text.  If a string is passed in, it will be HTML-escaped.
-    # If a widget or the result of calling methods such as raw
-    # is passed in, the HTML will not be HTML-escaped again.
-    # If another kind of object is passed in, the result of calling
-    # its to_s method will be treated as a string would be.
+    # Emits text.  If a string is passed in, it will be HTML-escaped. If a
+    # widget or the result of calling methods such as raw is passed in, the
+    # HTML will not be HTML-escaped again. If another kind of object is passed
+    # in, the result of calling its to_s method will be treated as a string
+    # would be.
     def text(value)
       if value.is_a? Widget
         widget value
       else
-        output.concat(value.html_escape)
+        output <<(value.html_escape)
       end
       @at_start_of_line = false
       nil
@@ -410,12 +440,12 @@ module Erector
       end
     end
-    # Emits a close tag, consisting of '<', tag name, and '>'
+    # Emits a close tag, consisting of '<', '/', tag name, and '>'
     def close_tag(tag_name)
       @indentation -= SPACES_PER_INDENT
       indent()
-      output.concat("</#{tag_name}>")
+      output <<("</#{tag_name}>")
       if newliney(tag_name)
         _newline
@@ -438,12 +468,13 @@ module Erector
     # Emits an XML instruction, which looks like this: <?xml version=\"1.0\" encoding=\"UTF-8\"?>
     def instruct(attributes={:version => "1.0", :encoding => "UTF-8"})
-      output.concat "<?xml#{format_sorted(sort_for_xml_declaration(attributes))}?>"
+      output << "<?xml#{format_sorted(sort_for_xml_declaration(attributes))}?>"
     end
-    # Creates a whole new output string, executes the block, then converts the output string to a string and
-    # emits it as raw text. If at all possible you should avoid this method since it hurts performance,
-    # and use +content+ or +write_via+ instead.
+    # Creates a whole new output string, executes the block, then converts the
+    # output string to a string and emits it as raw text. If at all possible
+    # you should avoid this method since it hurts performance, and use
+    # +widget+ or +write_via+ instead.
     def capture(&block)
       begin
         original_output = output
@@ -475,7 +506,8 @@ module Erector
       )
     end
-    # Emits a javascript block inside a +script+ tag, wrapped in CDATA doohickeys like all the cool JS kids do.
+    # Emits a javascript block inside a +script+ tag, wrapped in CDATA
+    # doohickeys like all the cool JS kids do.
     def javascript(*args, &block)
       if args.length > 2
         raise ArgumentError, "Cannot accept more than two arguments"
@@ -514,16 +546,17 @@ module Erector
       rawtext "\n"
     end
-    # Convenience method to emit a css file link, which looks like this:
+    # Convenience method to emit a css file link, which looks like this:
     # <link href="erector.css" rel="stylesheet" type="text/css" />
-    # The parameter is the full contents of the href attribute, including any ".css" extension.
+    # The parameter is the full contents of the href attribute, including any ".css" extension.
     #
     # If you want to emit raw CSS inline, use the #style method instead.
     def css(href)
       link :rel => 'stylesheet', :type => 'text/css', :href => href
     end
-    # Convenience method to emit an anchor tag whose href and text are the same, e.g. <a href="http://example.com">http://example.com</a>
+    # Convenience method to emit an anchor tag whose href and text are the same,
+    # e.g. <a href="http://example.com">http://example.com</a>
     def url(href)
       a href, :href => href
     end
@@ -581,7 +614,7 @@ protected
     def __empty_element__(tag_name, attributes={})
       indent_for_open_tag(tag_name)
-      output.concat "<#{tag_name}#{format_attributes(attributes)} />"
+      output << "<#{tag_name}#{format_attributes(attributes)} />"
       if newliney(tag_name)
         _newline
@@ -590,7 +623,7 @@ protected
     def _newline
       return unless @prettyprint
-      output.concat "\n"
+      output << "\n"
       @at_start_of_line = true
     end
@@ -604,7 +637,7 @@ protected
     def indent()
       if @at_start_of_line
-        output.concat " " * @indentation
+        output << " " * [@indentation, 0].max
       end
     end