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

erector 0.5.1 → 0.6.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (34) hide show

data/README.txt +6 -5
data/VERSION.yml +5 -0
data/bin/{erect → erector} +0 -0
data/lib/erector.rb +3 -1
data/lib/erector/erect.rb +1 -1
data/lib/erector/erected.rb +1 -1
data/lib/erector/rails.rb +2 -1
data/lib/erector/rails/extensions/action_controller.rb +25 -7
data/lib/erector/rails/extensions/rails_widget.rb +38 -0
data/lib/erector/rails/extensions/{widget.rb → rails_widget/helpers.rb} +2 -9
data/lib/erector/rails/rails_version.rb +6 -0
data/lib/erector/rails/template_handlers/action_view_template_handler.rb +43 -11
data/lib/erector/version.rb +4 -2
data/lib/erector/widget.rb +221 -74
data/lib/erector/widgets/table.rb +34 -8
data/spec/erector/indentation_spec.rb +39 -24
data/spec/erector/widget_spec.rb +197 -64
data/spec/erector/widgets/table_spec.rb +3 -3
data/spec/spec.opts +1 -0
data/spec/spec_helper.rb +2 -4
data/spec/spec_suite.rb +6 -12
metadata +24 -70
data/lib/erector/rails/extensions/action_controller/1.2.5/action_controller.rb +0 -17
data/lib/erector/rails/extensions/action_controller/2.2.0/action_controller.rb +0 -26
data/lib/erector/rails/extensions/widget/1.2.5/widget.rb +0 -18
data/lib/erector/rails/extensions/widget/2.2.0/widget.rb +0 -23
data/lib/erector/rails/supported_rails_versions.rb +0 -13
data/lib/erector/rails/template_handlers/1.2.5/action_view_template_handler.rb +0 -32
data/lib/erector/rails/template_handlers/2.0.0/action_view_template_handler.rb +0 -36
data/lib/erector/rails/template_handlers/2.1.0/action_view_template_handler.rb +0 -31
data/lib/erector/rails/template_handlers/2.2.0/action_view_template_handler.rb +0 -46
data/spec/erect/erect_spec.rb +0 -145
data/spec/erect/erected_spec.rb +0 -80
data/spec/erect/rhtml_parser_spec.rb +0 -318

data/README.txt CHANGED Viewed

@@ -1,7 +1,8 @@
 = Erector
 * http://erector.rubyforge.org
-* mailto:erector-devel@rubyforge.org
+* mailto:erector@googlegroups.com
+* http://www.pivotaltracker.com/projects/482
 == DESCRIPTION
@@ -17,20 +18,20 @@ project site at http://erector.rubyforge.org for more documentation.
     require 'erector'
     class Hello < Erector::Widget
-      def render
+      def content
         html do
           head do
             title "Hello"
           end
           body do
             text "Hello, "
-            b "world!", :class => 'big'
+            b "#{target}!", :class => 'big'
           end
         end
       end
     end
-    Hello.new.to_s
+    Hello.new(:target => 'world').to_s
     => "<html><head><title>Hello</title></head><body>Hello, <b class=\"big\">world!</b></body></html>"
 == REQUIREMENTS
@@ -58,7 +59,7 @@ When installing this way, erector is automatically available to your Rails code
 (The MIT License)
-Copyright (c) 2007-8 Pivotal Labs
+Copyright (c) 2007-2009 Pivotal Labs
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/VERSION.yml ADDED Viewed

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

data/bin/{erect → erector} RENAMED Viewed

File without changes

data/lib/erector.rb CHANGED Viewed

@@ -1,7 +1,9 @@
 require "rubygems"
 dir = File.dirname(__FILE__)
 require 'cgi'
-require "activesupport"
+require 'yaml'
+require "active_support/inflector"
+require "active_support/inflections"
 require "#{dir}/erector/extensions/object"
 require "#{dir}/erector/raw_string"
 require "#{dir}/erector/widget"

data/lib/erector/erect.rb CHANGED Viewed

@@ -11,7 +11,7 @@ module Erector
       @output_dir = nil
       opts = OptionParser.new do |opts|
-        opts.banner = "Usage: erect [options] [file|dir]*"
+        opts.banner = "Usage: erector [options] [file|dir]*"
         opts.separator "Converts from html/rhtml files to erector widgets, or from erector widgets to html files"
         opts.separator ""

data/lib/erector/erected.rb CHANGED Viewed

@@ -37,7 +37,7 @@ module Erector
       else
         File.open(filename, "w") do |f|
           f.puts("class #{classname} < Erector::Widget")
-          f.puts("  def render")
+          f.puts("  def content")
           f.puts(parsed.set_indent(2).convert)
           f.puts("  end")
           f.puts("end")

data/lib/erector/rails.rb CHANGED Viewed

@@ -1,6 +1,7 @@
 dir = File.dirname(__FILE__)
 require "action_controller"
-require "#{dir}/rails/extensions/widget"
+require "#{dir}/rails/rails_version"
+require "#{dir}/rails/extensions/rails_widget"
 require "#{dir}/rails/extensions/action_controller"
 require "#{dir}/rails/extensions/action_view"
 require "#{dir}/rails/template_handlers/action_view_template_handler"

data/lib/erector/rails/extensions/action_controller.rb CHANGED Viewed

@@ -1,8 +1,26 @@
-dir = File.dirname(__FILE__)
-if (
-  ActionController::Base.instance_methods + ActionController::Base.private_instance_methods).
-  include?("add_variables_to_assigns")
-  require File.expand_path("#{dir}/action_controller/1.2.5/action_controller")
-else
-  require File.expand_path("#{dir}/action_controller/2.2.0/action_controller")
+ActionController::Base.class_eval do
+  def render_widget(widget_class, assigns=nil)
+    @__widget_class = widget_class
+    if assigns
+      @__widget_assigns = assigns
+    else
+      @__widget_assigns = {}
+      variables = instance_variable_names
+      variables -= protected_instance_variables
+      variables.each do |name|
+        @__widget_assigns[name.sub('@', "")] = instance_variable_get(name)
+      end
+    end
+    response.template.send(:_evaluate_assigns_and_ivars)
+    render :inline => "<% @__widget_class.new(@__widget_assigns).to_s(:output => output_buffer, :helpers => self) %>"
+  end
+  def render_with_erector_widget(*options, &block)
+    if options.first.is_a?(Hash) && widget = options.first.delete(:widget)
+      render_widget widget, @assigns, &block
+    else
+      render_without_erector_widget *options, &block
+    end
+  end
+  alias_method_chain :render, :erector_widget
 end

data/lib/erector/rails/extensions/rails_widget.rb ADDED Viewed

@@ -0,0 +1,38 @@
+module Erector
+  class RailsWidget < Widget
+    def output
+      process_output_buffer || @output
+    end
+    def capture_with_helpers(&block)
+      helpers ? helpers.capture(&block) : capture_without_helpers(&block)
+    end
+    alias_method_chain :capture, :helpers
+    # This is here to force #helpers.capture to return the output
+    def __in_erb_template; end
+    private
+    def process_output_buffer
+      if helpers.respond_to?(:output_buffer)
+        buffer = helpers.output_buffer
+        buffer.is_a?(String) ? buffer : handle_rjs_buffer
+      else
+        nil
+      end
+    end
+    def handle_rjs_buffer
+      returning buffer = helpers.output_buffer.dup.to_s do
+        helpers.output_buffer.clear
+        helpers.with_output_buffer(buffer) do
+          buffer << helpers.output_buffer.to_s
+        end
+      end
+    end
+  end
+end
+require "#{File.dirname(__FILE__)}/rails_widget/helpers"

data/lib/erector/rails/extensions/{widget.rb → rails_widget/helpers.rb} RENAMED Viewed

@@ -1,5 +1,5 @@
 module Erector
-  Widget.class_eval do
+  class RailsWidget < Widget
     include ActionController::UrlWriter
     # helpers returning raw text
@@ -105,13 +105,6 @@ module Erector
     def pluralize(*args)
       helpers.pluralize(*args)
-    end
+    end
   end
 end
-dir = File.dirname(__FILE__)
-if ActionView::Base.instance_methods.include?("output_buffer")
-  require "#{dir}/widget/2.2.0/widget"
-else
-  require "#{dir}/widget/1.2.5/widget"
-end

data/lib/erector/rails/rails_version.rb ADDED Viewed

@@ -0,0 +1,6 @@
+module Erector
+  module Rails
+    RAILS_VERSION = "2.3.2"
+    RAILS_VERSION_TAG = "v2.3.2"
+  end
+end

data/lib/erector/rails/template_handlers/action_view_template_handler.rb CHANGED Viewed

@@ -1,14 +1,46 @@
-dir = File.dirname(__FILE__)
-if ActionView.const_defined?(:TemplateHandlers)
-  if ::ActionView::TemplateHandlers::const_defined?(:Compilable)
-    if ActionView.const_defined?(:TemplateHandlers) && ::ActionView::TemplateHandlers::ERB.respond_to?(:erb_trim_mode)
-      require File.expand_path("#{dir}/2.2.0/action_view_template_handler")
-    else
-      require File.expand_path("#{dir}/2.1.0/action_view_template_handler")
+module ActionView #:nodoc:
+  module TemplateHandlers #:nodoc:
+    class Erector < TemplateHandler
+      include Compilable
+      def self.line_offset
+        2
+      end
+      ActionView::Template.instance_eval do
+        register_template_handler :rb, ActionView::TemplateHandlers::Erector
+      end
+      def compile(template)
+        relative_path_parts = template.path.split('/')
+        is_partial = relative_path_parts.last =~ /^_/
+        require_dependency File.expand_path(template.filename)
+        widget_class_parts = relative_path_parts.inject(['Views']) do |class_parts, node|
+          class_parts << node.gsub(/^_/, "").gsub(/(\.html)?\.rb$/, '').camelize
+          class_parts
+        end
+        widget_class_name = widget_class_parts.join("::")
+        render_method = is_partial ? 'render_partial' : 'content'
+        erb_template = <<-ERB
+        <%
+          assigns = instance_variables.inject({}) do |hash, name|
+            hash[name.sub('@', "")] = instance_variable_get(name)
+            hash
+          end
+          widget = #{widget_class_name}.new(assigns)
+          widget.to_s(:output => output_buffer, :helpers => self, :content_method_name => :#{render_method})
+        %>
+        ERB
+        ::ERB.new(
+          erb_template,
+          nil,
+          ::ActionView::TemplateHandlers::ERB.erb_trim_mode,
+          "@output_buffer"
+        ).src
+      end
     end
-  else
-    require File.expand_path("#{dir}/2.0.0/action_view_template_handler")
   end
-else
-  require File.expand_path("#{dir}/1.2.5/action_view_template_handler")
 end

data/lib/erector/version.rb CHANGED Viewed

@@ -1,8 +1,10 @@
-  ##
+##
 # Erector view framework
 module Erector
   if !Erector.const_defined?(:VERSION)
-    VERSION = "0.5.1"
+    dir = File.dirname(__FILE__)
+    version = YAML.load_file(File.expand_path("#{dir}/../../VERSION.yml"))
+    VERSION = "#{version[:major]}.#{version[:minor]}.#{version[:patch]}"
   end
 end

data/lib/erector/widget.rb CHANGED Viewed

@@ -3,17 +3,27 @@ module Erector
   # A Widget is the center of the Erector universe.
   #
   # To create a widget, extend Erector::Widget and implement
-  # the +render+ method. Inside this method you may call any of the tag methods like +span+ or +p+ to emit HTML/XML
+  # 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
-  # +render+ method is called.
+  # +content+ method is called.
   #
   # 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.
+  #
+  # 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 render method, instantiate the child widget and call
-  # its +render_to+ method, passing in +self+ (or self.output if you prefer). This assures that the same output
-  # is used, which gives better performance than using +capture+ or +to_s+.
+  # 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
@@ -64,14 +74,72 @@ module Erector
           raise ArgumentError, "You must provide either an instance or a block"
         end
       end
       protected
       def after_initialize_parts
         @after_initialize_parts ||= []
       end
     end
-    cattr_accessor :prettyprint_default
+    # 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).
+    #
+    # 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
+    #   FancyForm.new(:title => 'Login')
+    # will succeed, as will
+    #   FancyForm.new(:title => 'Login', :show_cancel => true)
+    # but
+    #   FancyForm.new(:name => 'Login')
+    # will fail.
+    #
+    def self.needs(*args)
+      args.each do |arg|
+        (@needs ||= []) << (arg.nil? ? nil : (arg.is_a? Hash) ? arg : arg.to_sym)
+      end
+    end
+    protected
+    def self.get_needs
+      @needs ||= []
+      parent = self.ancestors[1]
+      if parent.respond_to? :get_needs
+        parent.get_needs + @needs
+      else
+        @needs
+      end
+    end
+    public
+    @@prettyprint_default = false
+    def prettyprint_default
+      @@prettyprint_default
+    end
+    def self.prettyprint_default=(enabled)
+      @@prettyprint_default = enabled
+    end
     NON_NEWLINEY = {'i' => true, 'b' => true, 'small' => true,
       'img' => true, 'span' => true, 'a' => true,
@@ -80,95 +148,163 @@ module Erector
     SPACES_PER_INDENT = 2
-    attr_reader :helpers, :assigns, :block, :parent, :output
-    attr_accessor :enable_prettyprint
+    attr_reader :helpers, :assigns, :block, :parent, :output, :prettyprint, :indentation
-    def initialize(helpers=nil, assigns={}, output = "", &block)
+    def initialize(assigns={}, &block)
+      unless assigns.is_a? Hash
+        raise "Erector's API has changed. Now you should pass only an options hash into Widget.new; the rest come in via to_s, or by using #widget."
+      end
+      if (respond_to? :render) &&
+        !self.method(:render).to_s.include?("(RailsWidget)")
+        raise "Erector's API has changed. You should rename #{self.class}#render to #content."
+      end
       @assigns = assigns
       assign_locals(assigns)
-      @helpers = helpers
       @parent = block ? eval("self", block.binding) : nil
-      @output = output
       @block = block
-      @at_start_of_line = true
-      @indent = 0
-      @enable_prettyprint = prettyprint_default
       self.class.after_initialize self
     end
 #-- methods for other classes to call, left public for ease of testing and documentation
 #++
+    protected
+    def context(output, prettyprint = false, indentation = 0, helpers = nil)
+      #TODO: pass in options hash, maybe, instead of parameters
+      original_output = @output
+      original_indendation = @indentation
+      original_helpers = @helpers
+      original_prettyprint = @prettyprint
+      @output = output
+      @at_start_of_line = true
+      raise "indentation must be a number, not #{indentation.inspect}" unless indentation.is_a? Fixnum
+      @indentation = indentation
+      @helpers = helpers
+      @prettyprint = prettyprint
+      yield
+    ensure
+      @output = original_output
+      @indentation = original_indendation
+      @helpers = original_helpers
+      @prettyprint = original_prettyprint
+    end
+    public
     def assign_locals(local_assigns)
-      local_assigns.each do |name, value|
-        instance_variable_set("@#{name}", value)
+      needed = self.class.get_needs.map{|need| need.is_a?(Hash) ? need.keys : need}.flatten
+      assigned = []
+      local_assigns.each do |name, value|
+        unless needed.empty? || needed.include?(name)
+          raise "Unknown parameter '#{name}'. #{self.class.name} only accepts #{needed.join(', ')}"
+        end
+        assign_local(name, value)
+        assigned << name
+      end
+      # set variables with default values
+      self.class.get_needs.select{|var| var.is_a? Hash}.each do |hash|
+        hash.each_pair do |name, value|
+          unless assigned.include?(name)
+            assign_local(name, value)
+            assigned << name
+          end
+        end
+      end
+      missing = needed - assigned
+      unless missing.empty? || missing == [nil]
+        raise "Missing parameter#{missing.size == 1 ? '' : 's'}: #{missing.join(', ')}"
+      end
+    end
+    def assign_local(name, value)
+      instance_variable_set("@#{name}", value)
+      if any_are_needed?
         metaclass.module_eval do
           attr_reader name
         end
       end
     end
-    # Set whether Erector should add newlines and indentation in to_s.
-    # This 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).
-    # This flag should be set prior to any rendering being done
-    # (for example, calls to to_s or to_pretty).
-    def enable_prettyprint(enable)
-      self.enable_prettyprint = enable
-      self
+    def any_are_needed?
+      !self.class.get_needs.empty?
     end
     # Render (like to_s) but adding newlines and indentation.
+    # This is a convenience method; you may just want to call to_s(:prettyprint => true)
+    # so you can pass in other rendering options as well.
     def to_pretty
-      enable_prettyprint(true).to_s
+      to_s(:prettyprint => true)
     end
-    # Entry point for rendering a widget (and all its children). This method creates a new output string,
-    # calls this widget's #render 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.
     #
-    # If it's called again later
-    # then it returns the earlier rendered string, which may lead to higher performance, but may have confusing
-    # effects if some underlying state has changed. In general we recommend you create a new instance of every
-    # widget for each render, unless you know what you're doing.
-    def to_s(render_method_name=:render, &blk)
-      # The @__to_s variable is used as a cache.
-      # If it's useful we should add a test for it.  -ac
-      return @__to_s if @__to_s
-      send(render_method_name, &blk)
-      @__to_s = output.to_s
+    # 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).
+    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
+      options = {
+        :output => "",
+        :prettyprint => prettyprint_default,
+        :indentation => 0,
+        :helpers => nil,
+        :content_method_name => :content,
+      }.merge(options)
+      context(options[:output], options[:prettyprint], options[:indentation], options[:helpers]) do
+        send(options[:content_method_name], &blk)
+        output.to_s
+      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.
-    def render
+    def content
       if @block
         instance_eval(&@block)
       end
     end
-    # To call one widget from another, inside the parent widget's render method, instantiate the child widget and call
-    # its +render_to+ method, passing in +self+ (or self.output if you prefer). This assures that the same output string
+    # 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+.
-    def render_to(output_or_widget)
-      if output_or_widget.is_a?(Widget)
-        @parent = output_or_widget
-        @output = @parent.output
-      else
-        @output = output_or_widget
+    # You can also use the +widget+ method.
+    def write_via(parent)
+      @parent = parent
+      context(parent.output, parent.prettyprint, parent.indentation, parent.helpers) do
+        content
       end
-      render
     end
-    # Convenience method for on-the-fly widgets. This is a way of making
-    # a sub-widget which still has access to the methods of the parent class.
-    # This is an experimental erector feature which may disappear in future
-    # versions of erector (see #widget in widget_spec in the Erector tests).
-    def widget(widget_class, assigns={}, &block)
-      child = widget_class.new(helpers, assigns, output, &block)
-      child.render
+    # 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.
+    def widget(target, assigns={}, &block)
+      child = if target.is_a? Class
+        target.new(assigns, &block)
+      else
+        unless assigns.empty?
+          raise "Unexpected second parameter. Did you mean to pass in variables when you instantiated the #{target.class.to_s}?"
+        end
+        target
+      end
+      child.write_via(self)
     end
     # (Should we make this hidden?)
@@ -220,7 +356,7 @@ module Erector
     # Emits an open tag, comprising '<', tag name, optional attributes, and '>'
     def open_tag(tag_name, attributes={})
       indent_for_open_tag(tag_name)
-      @indent += SPACES_PER_INDENT
+      @indentation += SPACES_PER_INDENT
       output.concat "<#{tag_name}#{format_attributes(attributes)}>"
       @at_start_of_line = false
@@ -232,7 +368,11 @@ module Erector
     # 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)
-      output.concat(value.html_escape)
+      if value.is_a? Widget
+        widget value
+      else
+        output.concat(value.html_escape)
+      end
       @at_start_of_line = false
       nil
     end
@@ -272,20 +412,19 @@ module Erector
     # Emits a close tag, consisting of '<', tag name, and '>'
     def close_tag(tag_name)
-      @indent -= SPACES_PER_INDENT
+      @indentation -= SPACES_PER_INDENT
       indent()
       output.concat("</#{tag_name}>")
       if newliney(tag_name)
-        output.concat "\n"
-        @at_start_of_line = true
+        _newline
       end
     end
     # Emits the result of joining the elements in array with the separator.
     # The array elements and separator can be Erector::Widget objects,
-    # which are rendered, or strings, which are quoted and output.
+    # which are rendered, or strings, which are html-escaped and output.
     def join(array, separator)
       first = true
       array.each do |widget_or_text|
@@ -304,7 +443,7 @@ module Erector
     # 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 #render_to instead.
+    # and use +content+ or +write_via+ instead.
     def capture(&block)
       begin
         original_output = output
@@ -375,10 +514,11 @@ module Erector
       rawtext "\n"
     end
-    # Convenience method to emit a css file link, which looks like this: <link href="erector.css" rel="stylesheet" type="text/css" />
+    # 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.
     #
-    # If you want to emit raw CSS inline, use the #script method instead.
+    # 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
@@ -389,7 +529,7 @@ module Erector
     end
     def newliney(tag_name)
-      if @enable_prettyprint
+      if @prettyprint
         !NON_NEWLINEY.include?(tag_name)
       else
         false
@@ -427,6 +567,9 @@ protected
       end
       attributes ||= {}
       open_tag tag_name, attributes
+      if block && value
+        raise ArgumentError, "You can't pass both a block and a value to #{tag_name} -- please choose one."
+      end
       if block
         instance_eval(&block)
       else
@@ -441,23 +584,27 @@ protected
       output.concat "<#{tag_name}#{format_attributes(attributes)} />"
       if newliney(tag_name)
-        output.concat "\n"
-        @at_start_of_line = true
+        _newline
       end
     end
+    def _newline
+      return unless @prettyprint
+      output.concat "\n"
+      @at_start_of_line = true
+    end
     def indent_for_open_tag(tag_name)
+      return unless @prettyprint
       if !@at_start_of_line && newliney(tag_name)
-        output.concat "\n"
-        @at_start_of_line = true
+        _newline
       end
       indent()
     end
     def indent()
       if @at_start_of_line
-        output.concat " " * @indent
+        output.concat " " * @indentation
       end
     end