Class: REXML::Formatters::Pretty (Ruby 2.2.3)
Description: Class : REXML::Formatters::Pretty - Ruby 2.2.3

- Home
- Core 2.2.3
- Std-lib 2.2.3
- Downloads

Support for the Ruby 2.2 series has ended. See here for reference.

### Home Classes Methods

### In Files

- rexml/formatters/pretty.rb

### Parent

REXML::Formatters::Default

### Methods

- ::new
- #write_cdata
- #write_comment
- #write_document
- #write_element
- #write_text

### Class/Module Index

Quicksearch

- Array
- Fixnum
- Float
- Object
- REXML
- REXML::AttlistDecl
- REXML::Attribute
- REXML::Attributes
- REXML::CData
- REXML::Child
- REXML::Comment
- REXML::DTD
- REXML::DTD::AttlistDecl
- REXML::DTD::ElementDecl
- REXML::DTD::EntityDecl
- REXML::DTD::NotationDecl
- REXML::DTD::Parser
- REXML::Declaration
- REXML::DocType
- REXML::Document
- REXML::Element
- REXML::ElementDecl
- REXML::Elements
- REXML::Encoding
- REXML::Entity
- REXML::EntityConst
- REXML::ExternalEntity
- REXML::Formatters
- REXML::Formatters::Default
- REXML::Formatters::Pretty
- REXML::Formatters::Transitive
- REXML::Functions
- REXML::IOSource
- REXML::Instruction
- REXML::Light
- REXML::Light::Node
- REXML::Namespace
- REXML::Node
- REXML::NotationDecl
- REXML::Output
- REXML::Parent
- REXML::ParseException
- REXML::Parsers
- REXML::Parsers::BaseParser
- REXML::Parsers::LightParser
- REXML::Parsers::PullEvent
- REXML::Parsers::PullParser
- REXML::Parsers::SAX2Parser
- REXML::Parsers::StreamParser
- REXML::Parsers::TreeParser
- REXML::Parsers::UltraLightParser
- REXML::Parsers::XPathParser
- REXML::QuickPath
- REXML::SAX2Listener
- REXML::Security
- REXML::Source
- REXML::SourceFactory
- REXML::StreamListener
- REXML::SyncEnumerator
- REXML::Text
- REXML::UndefinedNamespaceException
- REXML::Validation
- REXML::Validation::Choice
- REXML::Validation::Event
- REXML::Validation::Interleave
- REXML::Validation::OneOrMore
- REXML::Validation::Optional
- REXML::Validation::Ref
- REXML::Validation::RelaxNG
- REXML::Validation::Sequence
- REXML::Validation::State
- REXML::Validation::ValidationException
- REXML::Validation::Validator
- REXML::Validation::ZeroOrMore
- REXML::XMLDecl
- REXML::XMLTokens
- REXML::XPath
- REXML::XPathParser
- Symbol

No matching classes.

# REXML::Formatters::Pretty

Pretty-prints an XML document. This destroys whitespace in text nodes and will insert carriage returns and indentations.

TODO: Add an option to print attributes on new lines

### Attributes

compact[RW]

If compact is set to true, then the formatter will attempt to use as little space as possible

width[RW]

The width of a page. Used for formatting text

### Public Class Methods

new( indentation=2, ie_hack=false ) click to toggle source

Create a new pretty printer.

output

  An object implementing '<<(String)', to which the output will be written.

indentation

  An integer greater than 0. The indentation of each level will be this number of spaces. If this is < 1, the behavior of this object is undefined. Defaults to 2.

ie_hack

  If true, the printer will insert whitespace before closing empty tags, thereby allowing Internet Explorer's XML parser to function. Defaults to false.

                   # File rexml/formatters/pretty.rb, line 29
    def initialize( indentation=2, ie_hack=false )
      @indentation = indentation
      @level = 0
      @ie_hack = ie_hack
      @width = 80
      @compact = false
    end

### Protected Instance Methods

write_cdata( node, output) click to toggle source

                   # File rexml/formatters/pretty.rb, line 101
    def write_cdata( node, output)
      output << ' ' * @level
      super
    end

write_comment( node, output) click to toggle source

                   # File rexml/formatters/pretty.rb, line 96
    def write_comment( node, output)
      output << ' ' * @level
      super
    end

write_document( node, output ) click to toggle source

                   # File rexml/formatters/pretty.rb, line 106
    def write_document( node, output )
      # Ok, this is a bit odd.  All XML documents have an XML declaration,
      # but it may not write itself if the user didn't specifically add it,
      # either through the API or in the input document.  If it doesn't write
      # itself, then we don't need a carriage return... which makes this
      # logic more complex.
      node.children.each { |child|
        next if child == node.children[-1] and child.instance_of?(Text)
        unless child == node.children[0] or child.instance_of?(Text) or
          (child == node.children[1] and !node.children[0].writethis)
          output << "\n"
        end
        write( child, output )
      }
    end

write_element(node, output) click to toggle source

                   # File rexml/formatters/pretty.rb, line 38
    def write_element(node, output)
      output << ' '*@level
      output << "<#{node.expanded_name}"

      node.attributes.each_attribute do |attr|
        output << " "
        attr.write( output )
      end unless node.attributes.empty?

      if node.children.empty?
        if @ie_hack
          output << " "
        end
        output << "/"
      else
        output << ">"
        # If compact and all children are text, and if the formatted output
        # is less than the specified width, then try to print everything on
        # one line
        skip = false
        if compact
          if node.children.inject(true) {|s,c| s & c.kind_of?(Text)}
            string = ""
            old_level = @level
            @level = 0
            node.children.each { |child| write( child, string ) }
            @level = old_level
            if string.length < @width
              output << string
              skip = true
            end
          end
        end
        unless skip
          output << "\n"
          @level += @indentation
          node.children.each { |child|
            next if child.kind_of?(Text) and child.to_s.strip.length == 0
            write( child, output )
            output << "\n"
          }
          @level -= @indentation
          output << ' '*@level
        end
        output << "</#{node.expanded_name}"
      end
      output << ">"
    end

write_text( node, output ) click to toggle source

                   # File rexml/formatters/pretty.rb, line 87
    def write_text( node, output )
      s = node.to_s()
      s.gsub!(/\s/,' ')
      s.squeeze!(" ")
      s = wrap(s, @width - @level)
      s = indent_text(s, @level, " ", true)
      output << (' '*@level + s)
    end