Class REXML::Text < REXML::Child

# File lib/rexml/text.rb, line 129
def Text.check string, pattern, doctype

  # illegal anywhere
  if string !~ VALID_XML_CHARS
    if String.method_defined? :encode
      string.chars.each do |c|
        case c.ord
        when *VALID_CHAR
        else
          raise "Illegal character #{c.inspect} in raw string \"#{string}\""
        end
      end
    else
      string.scan(/[\x00-\x7F]|[\x80-\xBF][\xC0-\xF0]*|[\xC0-\xF0]/n) do |c|
        case c.unpack('U')
        when *VALID_CHAR
        else
          raise "Illegal character #{c.inspect} in raw string \"#{string}\""
        end
      end
    end
  end

  # context sensitive
  string.scan(pattern) do
    if $1[-1] != ?;
      raise "Illegal character '#{$1}' in raw string \"#{string}\""
    elsif $1[0] == ?&
      if $5 and $5[0] == ?#
        case ($5[1] == ?x ? $5[2..-1].to_i(16) : $5[1..-1].to_i)
        when *VALID_CHAR
        else
          raise "Illegal character '#{$1}' in raw string \"#{string}\""
        end
      # FIXME: below can't work but this needs API change.
      # elsif @parent and $3 and !SUBSTITUTES.include?($1)
      #   if !doctype or !doctype.entities.has_key?($3)
      #     raise "Undeclared entity '#{$1}' in raw string \"#{string}\""
      #   end
      end
    end
  end
end

# File lib/rexml/text.rb, line 396
def Text.expand(ref, doctype, filter)
  if ref[1] == ?#
    if ref[2] == ?x
      [ref[3...-1].to_i(16)].pack('U*')
    else
      [ref[2...-1].to_i].pack('U*')
    end
  elsif ref == '&'
    '&'
  elsif filter and filter.include?( ref[1...-1] )
    ref
  elsif doctype
    doctype.entity( ref[1...-1] ) or ref
  else
    entity_value = DocType::DEFAULT_ENTITIES[ ref[1...-1] ]
    entity_value ? entity_value.value : ref
  end
end

# File lib/rexml/text.rb, line 93
def initialize(arg, respect_whitespace=false, parent=nil, raw=nil,
  entity_filter=nil, illegal=NEEDS_A_SECOND_CHECK )

  @raw = false
  @parent = nil

  if parent
    super( parent )
    @raw = parent.raw
  end

  @raw = raw unless raw.nil?
  @entity_filter = entity_filter
  @normalized = @unnormalized = nil

  if arg.kind_of? String
    @string = arg.dup
    @string.squeeze!(" \n\t") unless respect_whitespace
  elsif arg.kind_of? Text
    @string = arg.to_s
    @raw = arg.raw
  elsif
    raise "Illegal argument of type #{arg.type} for Text constructor (#{arg})"
  end

  @string.gsub!( /\r\n?/, "\n" )

  Text.check(@string, illegal, doctype) if @raw
end

# File lib/rexml/text.rb, line 361
def Text::normalize( input, doctype=nil, entity_filter=nil )
  copy = input.to_s
  # Doing it like this rather than in a loop improves the speed
  #copy = copy.gsub( EREFERENCE, '&' )
  copy = copy.gsub( "&", "&" )
  if doctype
    # Replace all ampersands that aren't part of an entity
    doctype.entities.each_value do |entity|
      copy = copy.gsub( entity.value,
        "&#{entity.name};" ) if entity.value and
          not( entity_filter and entity_filter.include?(entity) )
    end
  else
    # Replace all ampersands that aren't part of an entity
    DocType::DEFAULT_ENTITIES.each_value do |entity|
      copy = copy.gsub(entity.value, "&#{entity.name};" )
    end
  end
  copy
end

# File lib/rexml/text.rb, line 335
def Text::read_with_substitution( input, illegal=nil )
  copy = input.clone

  if copy =~ illegal
    raise ParseException.new( "malformed text: Illegal character #$& in \"#{copy}\"" )
  end if illegal

  copy.gsub!( /\r\n?/, "\n" )
  if copy.include? ?&
    copy.gsub!( SETUTITSBUS[0], SLAICEPS[0] )
    copy.gsub!( SETUTITSBUS[1], SLAICEPS[1] )
    copy.gsub!( SETUTITSBUS[2], SLAICEPS[2] )
    copy.gsub!( SETUTITSBUS[3], SLAICEPS[3] )
    copy.gsub!( SETUTITSBUS[4], SLAICEPS[4] )
    copy.gsub!( /&#0*((?:\d+)|(?:x[a-f0-9]+));/ ) {
      m=$1
      #m='0' if m==''
      m = "0#{m}" if m[0] == ?x
      [Integer(m)].pack('U*')
    }
  end
  copy
end

# File lib/rexml/text.rb, line 383
def Text::unnormalize( string, doctype=nil, filter=nil, illegal=nil )
  sum = 0
  string.gsub( /\r\n?/, "\n" ).gsub( REFERENCE ) {
    s = Text.expand($&, doctype, filter)
    if sum + s.bytesize > REXML.entity_expansion_text_limit
      raise "entity expansion has grown too large"
    else
      sum += s.bytesize
    end
    s
  }
end

# File lib/rexml/text.rb, line 189
def <<( to_append )
  @string << to_append.gsub( /\r\n?/, "\n" )
end

# File lib/rexml/text.rb, line 196
def <=>( other )
  to_s() <=> other.to_s
end

# File lib/rexml/text.rb, line 182
def clone
  return Text.new(self)
end

# File lib/rexml/text.rb, line 200
def doctype
  if @parent
    doc = @parent.document
    doc.doctype if doc
  end
end

# File lib/rexml/text.rb, line 177
def empty?
  @string.size==0
end

# File lib/rexml/text.rb, line 275
def indent_text(string, level=1, style="\t", indentfirstline=true)
  return string if level < 0
  new_string = ''
  string.each_line { |line|
    indent_string = style * level
    new_line = (indent_string + line).sub(/[\s]+$/,'')
    new_string << new_line
  }
  new_string.strip! unless indentfirstline
  return new_string
end

# File lib/rexml/text.rb, line 228
def inspect
  @string.inspect
end

# File lib/rexml/text.rb, line 173
def node_type
  :text
end

# File lib/rexml/text.rb, line 123
def parent= parent
  super(parent)
  Text.check(@string, NEEDS_A_SECOND_CHECK, doctype) if @raw and @parent
end

# File lib/rexml/text.rb, line 221
def to_s
  return @string if @raw
  return @normalized if @normalized

  @normalized = Text::normalize( @string, doctype, @entity_filter )
end

# File lib/rexml/text.rb, line 245
def value
  return @unnormalized if @unnormalized
  @unnormalized = Text::unnormalize( @string, doctype )
end

# File lib/rexml/text.rb, line 257
def value=( val )
  @string = val.gsub( /\r\n?/, "\n" )
  @unnormalized = nil
  @normalized = nil
  @raw = false
end

# File lib/rexml/text.rb, line 264
def wrap(string, width, addnewline=false)
  # Recursively wrap string at width.
  return string if string.length <= width
  place = string.rindex(' ', width) # Position in string with last ' ' before cutoff
  if addnewline then
    return "\n" + string[0,place] + "\n" + wrap(string[place+1..-1], width)
  else
    return string[0,place] + "\n" + wrap(string[place+1..-1], width)
  end
end

# File lib/rexml/text.rb, line 290
def write( writer, indent=-1, transitive=false, ie_hack=false )
  Kernel.warn("#{self.class.name}.write is deprecated.  See REXML::Formatters")
  formatter = if indent > -1
      REXML::Formatters::Pretty.new( indent )
    else
      REXML::Formatters::Default.new
    end
  formatter.write( self, writer )
end

# File lib/rexml/text.rb, line 322
def write_with_substitution out, input
  copy = input.clone
  # Doing it like this rather than in a loop improves the speed
  copy.gsub!( SPECIALS[0], SUBSTITUTES[0] )
  copy.gsub!( SPECIALS[1], SUBSTITUTES[1] )
  copy.gsub!( SPECIALS[2], SUBSTITUTES[2] )
  copy.gsub!( SPECIALS[3], SUBSTITUTES[3] )
  copy.gsub!( SPECIALS[4], SUBSTITUTES[4] )
  copy.gsub!( SPECIALS[5], SUBSTITUTES[5] )
  out << copy
end

# File lib/rexml/text.rb, line 302
def xpath
  path = @parent.xpath
  path += "/text()"
  return path
end