RubyGems - pivotal-erector - Versions diffs - 0.5.1 → 0.6.0 - Mend

pivotal-erector 0.5.1 → 0.6.0

Files changed (32) hide show

data/README.txt +5 -5
data/VERSION.yml +2 -2
data/bin/{erect → erector} +0 -0
data/lib/erector/erect.rb +1 -1
data/lib/erector/erected.rb +1 -1
data/lib/erector/rails/extensions/action_controller.rb +25 -7
data/lib/erector/rails/extensions/{widget.rb → rails_widget/helpers.rb} +2 -9
data/lib/erector/rails/extensions/{widget/2.2.0/widget.rb → rails_widget.rb} +4 -2
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/rails.rb +2 -1
data/lib/erector/version.rb +1 -1
data/lib/erector/widget.rb +213 -73
data/lib/erector/widgets/table.rb +3 -3
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 +1 -4
data/spec/spec_suite.rb +6 -12
metadata +18 -30
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/supported_rails_versions.rb +0 -14
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,7 @@
 = Erector
 * http://erector.rubyforge.org
-* mailto:erector-devel@rubyforge.org
+* mailto:erector@googlegroups.com
 * http://www.pivotaltracker.com/projects/482
 == DESCRIPTION
@@ -18,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
@@ -59,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 CHANGED Viewed

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

data/bin/{erect → erector} RENAMED Viewed

File without changes

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/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/{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/extensions/{widget/2.2.0/widget.rb → rails_widget.rb} RENAMED Viewed

@@ -1,5 +1,5 @@
 module Erector
-  Widget.class_eval do
+  class RailsWidget < Widget
     def output
       process_output_buffer || @output
     end
@@ -7,7 +7,7 @@ module Erector
     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
@@ -34,3 +34,5 @@ module Erector
     end
   end
 end
+require "#{File.dirname(__FILE__)}/rails_widget/helpers"

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/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/version.rb CHANGED Viewed

@@ -4,7 +4,7 @@ module Erector
   if !Erector.const_defined?(:VERSION)
     dir = File.dirname(__FILE__)
     version = YAML.load_file(File.expand_path("#{dir}/../../VERSION.yml"))
-    VERSION = "#{version['major']}.#{version['minor']}.#{version['patch']}"
+    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,13 +74,64 @@ 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
+    # 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
@@ -87,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.
+    #
+    # 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.
     #
-    # 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
+    # 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?)
@@ -227,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
@@ -239,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
@@ -279,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|
@@ -311,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
@@ -382,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
@@ -396,7 +529,7 @@ module Erector
     end
     def newliney(tag_name)
-      if @enable_prettyprint
+      if @prettyprint
         !NON_NEWLINEY.include?(tag_name)
       else
         false
@@ -434,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
@@ -448,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