builder 2.1.2 → 3.0.0

data/lib/blankslate.rb

@@ -36,13 +36,9 @@ class BlankSlate
     # Redefine a previously hidden method so that it may be called on a blank
     # slate object.
     def reveal(name)
-      bound_method = nil
-      unbound_method = find_hidden_method(name)
-      fail "Don't know how to reveal method '#{name}'" unless unbound_method
-      define_method(name) do |*args|
-        bound_method ||= unbound_method.bind(self)
-        bound_method.call(*args)
-      end
+      hidden_method = find_hidden_method(name)
+      fail "Don't know how to reveal method '#{name}'" unless hidden_method
+      define_method(name, hidden_method)
     end
   end
   

data/lib/builder/blankslate.rb

@@ -8,13 +8,16 @@
 # above copyright notice is included.
 #++
 
-require 'blankslate'
-
 ######################################################################
 # BlankSlate has been promoted to a top level name and is now
 # available as a standalone gem.  We make the name available in the
 # Builder namespace for compatibility.
 #
 module Builder
-  BlankSlate = ::BlankSlate
+  if Object::const_defined?(:BasicObject)
+    BlankSlate = ::BasicObject
+  else
+    require 'blankslate'
+    BlankSlate = ::BlankSlate
+  end
 end

data/lib/builder/xchar.rb

@@ -10,14 +10,14 @@
 
 module Builder
   def self.check_for_name_collision(klass, method_name, defined_constant=nil)
-    if klass.instance_methods.include?(method_name)
+    if klass.method_defined?(method_name.to_s)
       fail RuntimeError,
 	"Name Collision: Method '#{method_name}' is already defined in #{klass}"
     end
   end
 end
 
-if ! defined?(Builder::XChar)
+if ! defined?(Builder::XChar) and ! String.method_defined?(:encode)
   Builder.check_for_name_collision(String, "to_xs")
   Builder.check_for_name_collision(Fixnum, "xchr")
 end
@@ -78,38 +78,120 @@ module Builder
       (0xE000..0xFFFD),
       (0x10000..0x10FFFF)
     ]
+
+    # http://www.fileformat.info/info/unicode/char/fffd/index.htm
+    REPLACEMENT_CHAR =
+      if String.method_defined?(:encode)
+        "\uFFFD"
+      elsif $KCODE == 'UTF8'
+        "\xEF\xBF\xBD"
+      else
+        '*'
+      end
   end
 
 end
 
 
-######################################################################
-# Enhance the Fixnum class with a XML escaped character conversion.
-#
-class Fixnum
-  XChar = Builder::XChar if ! defined?(XChar)
-
-  # XML escaped version of chr
-  def xchr
-    n = XChar::CP1252[self] || self
-    case n when *XChar::VALID
-      XChar::PREDEFINED[n] or (n<128 ? n.chr : "&##{n};")
-    else
-      '*'
+if String.method_defined?(:encode)
+  module Builder
+    module XChar # :nodoc:
+      CP1252_DIFFERENCES, UNICODE_EQUIVALENT = Builder::XChar::CP1252.each.
+        inject([[],[]]) {|(domain,range),(key,value)|
+          [domain << key,range << value]
+        }.map {|seq| seq.pack('U*').force_encoding('utf-8')}
+  
+      XML_PREDEFINED = Regexp.new('[' +
+        Builder::XChar::PREDEFINED.keys.pack('U*').force_encoding('utf-8') +
+      ']')
+  
+      INVALID_XML_CHAR = Regexp.new('[^'+
+        Builder::XChar::VALID.map { |item|
+          case item
+          when Fixnum
+            [item].pack('U').force_encoding('utf-8')
+          when Range
+            [item.first, '-'.ord, item.last].pack('UUU').force_encoding('utf-8')
+          end
+        }.join +
+      ']')
+  
+      ENCODING_BINARY = Encoding.find('BINARY')
+      ENCODING_UTF8   = Encoding.find('UTF-8')
+      ENCODING_ISO1   = Encoding.find('ISO-8859-1')
+
+      # convert a string to valid UTF-8, compensating for a number of
+      # common errors.
+      def XChar.unicode(string)
+        if string.encoding == ENCODING_BINARY
+          if string.ascii_only?
+            string
+          else
+            string = string.clone.force_encoding(ENCODING_UTF8)
+            if string.valid_encoding?
+              string
+            else
+              string.encode(ENCODING_UTF8, ENCODING_ISO1)
+            end
+          end
+
+        elsif string.encoding == ENCODING_UTF8
+          if string.valid_encoding?
+            string
+          else
+            string.encode(ENCODING_UTF8, ENCODING_ISO1)
+          end
+
+        else
+          string.encode(ENCODING_UTF8)
+        end
+      end
+
+      # encode a string per XML rules
+      def XChar.encode(string)
+        unicode(string).
+          tr(CP1252_DIFFERENCES, UNICODE_EQUIVALENT).
+          gsub(INVALID_XML_CHAR, REPLACEMENT_CHAR).
+          gsub(XML_PREDEFINED) {|c| PREDEFINED[c.ord]}
+      end
     end
   end
-end
 
+else
 
-######################################################################
-# Enhance the String class with a XML escaped character version of
-# to_s.
-#
-class String
-  # XML escaped version of to_s
-  def to_xs
-    unpack('U*').map {|n| n.xchr}.join # ASCII, UTF-8
-  rescue
-    unpack('C*').map {|n| n.xchr}.join # ISO-8859-1, WIN-1252
+  ######################################################################
+  # Enhance the Fixnum class with a XML escaped character conversion.
+  #
+  class Fixnum
+    XChar = Builder::XChar if ! defined?(XChar)
+  
+    # XML escaped version of chr. When <tt>escape</tt> is set to false
+    # the CP1252 fix is still applied but utf-8 characters are not
+    # converted to character entities.
+    def xchr(escape=true)
+      n = XChar::CP1252[self] || self
+      case n when *XChar::VALID
+        XChar::PREDEFINED[n] or 
+          (n<128 ? n.chr : (escape ? "&##{n};" : [n].pack('U*')))
+      else
+        Builder::XChar::REPLACEMENT_CHAR
+      end
+    end
+  end
+  
+
+  ######################################################################
+  # Enhance the String class with a XML escaped character version of
+  # to_s.
+  #
+  class String
+    # XML escaped version of to_s. When <tt>escape</tt> is set to false
+    # the CP1252 fix is still applied but utf-8 characters are not
+    # converted to character entities.
+    def to_xs(escape=true)
+      unpack('U*').map {|n| n.xchr(escape)}.join # ASCII, UTF-8
+    rescue
+      unpack('C*').map {|n| n.xchr}.join # ISO-8859-1, WIN-1252
+    end
   end
 end

data/lib/builder/xmlbase.rb

@@ -13,19 +13,22 @@ module Builder
 
     # Create an XML markup builder.
     #
-    # out::     Object receiving the markup.  +out+ must respond to
-    #           <tt><<</tt>.
-    # indent::  Number of spaces used for indentation (0 implies no
-    #           indentation and no line breaks).
-    # initial:: Level of initial indentation.
-    #
-    def initialize(indent=0, initial=0)
+    # out::      Object receiving the markup.  +out+ must respond to
+    #            <tt><<</tt>.
+    # indent::   Number of spaces used for indentation (0 implies no
+    #            indentation and no line breaks).
+    # initial::  Level of initial indentation.
+    # encoding:: When <tt>encoding</tt> and $KCODE are set to 'utf-8'
+    #            characters aren't converted to character entities in
+    #            the output stream.
+    def initialize(indent=0, initial=0, encoding='utf-8')
       @indent = indent
       @level  = initial
+      @encoding = encoding.downcase
     end
     
     # Create a tag named +sym+.  Other than the first argument which
-    # is the tag name, the arguements are the same as the tags
+    # is the tag name, the arguments are the same as the tags
     # implemented via <tt>method_missing</tt>.
     def tag!(sym, *args, &block)
       method_missing(sym.to_sym, *args, &block)
@@ -37,10 +40,10 @@ module Builder
     def method_missing(sym, *args, &block)
       text = nil
       attrs = nil
-      sym = "#{sym}:#{args.shift}" if args.first.kind_of?(Symbol)
+      sym = "#{sym}:#{args.shift}" if args.first.kind_of?(::Symbol)
       args.each do |arg|
         case arg
-        when Hash
+        when ::Hash
           attrs ||= {}
           attrs.merge!(arg)
         else
@@ -50,15 +53,19 @@ module Builder
       end
       if block
         unless text.nil?
-          raise ArgumentError, "XmlMarkup cannot mix a text argument with a block"
+          ::Kernel::raise ::ArgumentError,
+            "XmlMarkup cannot mix a text argument with a block"
         end
         _indent
         _start_tag(sym, attrs)
         _newline
-        _nested_structures(block)
-        _indent
-        _end_tag(sym)
-        _newline
+        begin
+          _nested_structures(block)
+        ensure
+          _indent
+          _end_tag(sym)
+          _newline
+        end
       elsif text.nil?
         _indent
         _start_tag(sym, attrs, true)
@@ -74,7 +81,7 @@ module Builder
     end
 
     # Append text to the output target.  Escape any markup.  May be
-    # used within the markup brakets as:
+    # used within the markup brackets as:
     #
     #   builder.p { |b| b.br; b.text! "HI" }   #=>  <p><br/>HI</p>
     def text!(text)
@@ -82,7 +89,7 @@ module Builder
     end
     
     # Append text to the output target without escaping any markup.
-    # May be used within the markup brakets as:
+    # May be used within the markup brackets as:
     #
     #   builder.p { |x| x << "<br/>HI" }   #=>  <p><br/>HI</p>
     #
@@ -111,8 +118,22 @@ module Builder
     private
     
     require 'builder/xchar'
-    def _escape(text)
-      text.to_xs
+    if ::String.method_defined?(:encode)
+      def _escape(text)
+        result = XChar.encode(text)
+        begin
+          result.encode(@encoding)
+        rescue
+          # if the encoding can't be supported, use numeric character references
+          result.
+            gsub(/[^\u0000-\u007F]/) {|c| "&##{c.ord};"}.
+            force_encoding('ascii')
+        end
+      end
+    else
+      def _escape(text)
+        text.to_xs((@encoding != 'utf-8' or $KCODE != 'UTF8'))
+      end
     end
 
     def _escape_quote(text)

data/lib/builder/xmlmarkup.rb

@@ -23,14 +23,14 @@ module Builder
   # Examples will demonstrate this easier than words.  In the
   # following, +xm+ is an +XmlMarkup+ object.
   #
-  #   xm.em("emphasized")             # => <em>emphasized</em>
-  #   xm.em { xmm.b("emp & bold") }   # => <em><b>emph &amp; bold</b></em>
+  #   xm.em("emphasized")            # => <em>emphasized</em>
+  #   xm.em { xm.b("emp & bold") }   # => <em><b>emph &amp; bold</b></em>
   #   xm.a("A Link", "href"=>"http://onestepback.org")
-  #                                   # => <a href="http://onestepback.org">A Link</a>
-  #   xm.div { br }                    # => <div><br/></div>
+  #                                  # => <a href="http://onestepback.org">A Link</a>
+  #   xm.div { xm.br }               # => <div><br/></div>
   #   xm.target("name"=>"compile", "option"=>"fast")
-  #                                   # => <target option="fast" name="compile"\>
-  #                                   # NOTE: order of attributes is not specified.
+  #                                  # => <target option="fast" name="compile"\>
+  #                                  # NOTE: order of attributes is not specified.
   #
   #   xm.instruct!                   # <?xml version="1.0" encoding="UTF-8"?>
   #   xm.html {                      # <html>
@@ -163,8 +163,9 @@ module Builder
     # option hash.
     #
     # :target=><em>target_object</em>::
-    #    Object receiving the markup.  +out+ must respond to the
-    #    <tt><<</tt> operator.  The default is a plain string target.
+    #    Object receiving the markup.  +target_object+ must respond to
+    #    the <tt><<(<em>a_string</em>)</tt> operator and return
+    #    itself.  The default target is a plain string target.
     #    
     # :indent=><em>indentation</em>::
     #    Number of spaces used for indentation.  The default is no
@@ -174,7 +175,7 @@ module Builder
     #    Amount of initial indentation (specified in levels, not
     #    spaces).
     #    
-    # :escape_attrs=><b>OBSOLETE</em>::
+    # :escape_attrs=><em>OBSOLETE</em>::
     #    The :escape_attrs option is no longer supported by builder
     #    (and will be quietly ignored).  String attribute values are
     #    now automatically escaped.  If you need unescaped attribute
@@ -195,7 +196,7 @@ module Builder
     end
 
     def comment!(comment_text)
-      _ensure_no_block block_given?
+      _ensure_no_block ::Kernel::block_given?
       _special("<!-- ", " -->", comment_text, nil)
     end
 
@@ -210,13 +211,13 @@ module Builder
       @target << "<!#{inst}"
       args.each do |arg|
         case arg
-        when String
+        when ::String
           @target << %{ "#{arg}"} # " WART
-        when Symbol
+        when ::Symbol
           @target << " #{arg}"
         end
       end
-      if block_given?
+      if ::Kernel::block_given?
         @target << " ["
         _newline
         _nested_structures(block)
@@ -235,18 +236,22 @@ module Builder
     #    xml.instruct! :aaa, :bbb=>"ccc"
     #        #=> <?aaa bbb="ccc"?>
     #
+    # Note: If the encoding is setup to "UTF-8" and the value of
+    # $KCODE is "UTF8", then builder will emit UTF-8 encoded strings
+    # rather than the entity encoding normally used.
     def instruct!(directive_tag=:xml, attrs={})
-      _ensure_no_block block_given?
+      _ensure_no_block ::Kernel::block_given?
       if directive_tag == :xml
         a = { :version=>"1.0", :encoding=>"UTF-8" }
         attrs = a.merge attrs
+	@encoding = attrs[:encoding].downcase
       end
       _special(
-      "<?#{directive_tag}",
-      "?>",
-      nil,
-      attrs,
-      [:version, :encoding, :standalone])
+        "<?#{directive_tag}",
+        "?>",
+        nil,
+        attrs,
+        [:version, :encoding, :standalone])
     end
 
     # Insert a CDATA section into the XML markup.
@@ -257,7 +262,7 @@ module Builder
     #        #=> <![CDATA[text to be included in cdata]]>
     #
     def cdata!(text)
-      _ensure_no_block block_given?
+      _ensure_no_block ::Kernel::block_given?
       _special("<![CDATA[", "]]>", text, nil)
     end
     
@@ -309,7 +314,7 @@ module Builder
 
     def _attr_value(value)
       case value
-      when Symbol
+      when ::Symbol
         value.to_s
       else
         _escape_quote(value.to_s)
@@ -318,8 +323,9 @@ module Builder
 
     def _ensure_no_block(got_block)
       if got_block
-        fail IllegalBlockError,
-        "Blocks are not allowed on XML instructions"
+        ::Kernel::raise IllegalBlockError.new(
+          "Blocks are not allowed on XML instructions"
+        )
       end
     end
 

data/test/performance.rb

@@ -1,5 +1,15 @@
 #!/usr/bin/env ruby
 
+#--
+# Portions copyright 2004 by Jim Weirich (jim@weirichhouse.org).
+# Portions copyright 2005 by Sam Ruby (rubys@intertwingly.net).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
 require 'builder/xmlmarkup'
 require 'benchmark'