Another big XML commit.

and using as a testbed for default arguments.

Author: paulp

src/library/scala/xml/Comment.scala

@@ -16,29 +16,17 @@ package scala.xml
  * @author Burak Emir
  * @param text the text contained in this node, may not contain "--"
  */
-case class Comment(commentText: String) extends SpecialNode {
-
-  final override def collectNamespacesAndDontTransform = false
-
-  if (commentText.indexOf("--") != -1)
-    throw new IllegalArgumentException("text containts \"--\"")
-
-  /** structural equality */
-  override def equals(x: Any): Boolean = x match {
-    case Comment(x) => x.equals(commentText)
-    case _ => false
-  }
-
-  /** the constant "#REM" */
+case class Comment(commentText: String) extends SpecialNode
+{
   def label = "#REM"
-
-  /** hashcode for this Comment */
-  override def hashCode() = commentText.hashCode()
-
   override def text = ""
+  final override def collectNamespacesAndDontTransform = false
+
+  if (commentText contains "--")
+    throw new IllegalArgumentException("text contains \"--\"")
 
   /** Appends &quot;<!-- text -->&quot; to this string buffer.
    */
   override def buildString(sb: StringBuilder) =
-    sb.append("<!--").append(commentText).append("-->")
+    sb append ("<!--" + commentText + "-->")
 }

src/library/scala/xml/MetaData.scala

@@ -12,6 +12,7 @@
 package scala.xml
 
 import Utility.sbToString
+import annotation.tailrec
 
 /**
  * Copyright 2008 Google Inc. All Rights Reserved.
@@ -25,11 +26,10 @@ object MetaData {
    * the attributes in new_tail, but does not guarantee to preserve the relative order of attribs.
    * Duplicates can be removed with normalize.
    */
+  @tailrec
   def concatenate(attribs: MetaData, new_tail: MetaData): MetaData =
-    if (attribs eq Null)
-      new_tail
-    else
-      concatenate(attribs.next, attribs.copy(new_tail)) // tail-recursive
+    if (attribs eq Null) new_tail
+    else concatenate(attribs.next, attribs.copy(new_tail))
 
   /**
    * returns normalized MetaData, with all duplicates removed and namespace prefixes resolved to
@@ -81,29 +81,17 @@ object MetaData {
  * @author Burak Emir <[email protected]>
  */
 @serializable
-abstract class MetaData extends Iterable[MetaData] {
-
-  /** updates this MetaData with the MetaData given as argument. All attributes that occur in updates
-   *  are part of the resulting MetaData. If an unprefixed attribute occurs in both this instance and
-   *  updates, only the one in updates is part of the result (avoiding duplicates). However, for
-   *  prefixed attributes no duplicate-detection is attempted, the method
-   *  append(updates: MetaData, scope:NamespaceBinding) should be used instead.
-   *
-   *  @param updates MetaData with new attributes and updated attributes
-   *  @return a new MetaData instance that contains the combined attributes of this and updates
-   */
-  def append(updates: MetaData): MetaData =
-    MetaData.update(this, TopScope, updates)
-
-  /** updates this MetaData with the MetaData given as argument. All attributes that occur in updates
+abstract class MetaData extends Iterable[MetaData]
+{
+  /** Updates this MetaData with the MetaData given as argument. All attributes that occur in updates
    *  are part of the resulting MetaData. If an attribute occurs in both this instance and
    *  updates, only the one in updates is part of the result (avoiding duplicates). For prefixed
-   *  attributes, namespaces are resolved using the given scope.
+   *  attributes, namespaces are resolved using the given scope, which defaults to TopScope.
    *
    *  @param updates MetaData with new and updated attributes
    *  @return a new MetaData instance that contains old, new and updated attributes
    */
-  def append(updates: MetaData, scope: NamespaceBinding): MetaData =
+  def append(updates: MetaData, scope: NamespaceBinding = TopScope): MetaData =
     MetaData.update(this, scope, updates)
 
   /**
@@ -160,16 +148,13 @@ abstract class MetaData extends Iterable[MetaData] {
   def isPrefixed: Boolean
 
   /** deep equals method */
-  override def equals(that: Any) =
-    that match {
-      case m: MetaData =>
-        var res = (this.length == m.length) && (this.hashCode() == m.hashCode())
-        val it = this.iterator
-        while (res && it.hasNext) { res = it.next.containedIn1(m) }
-        res
-      case _ =>
-        false
-    }
+  override def equals(that: Any) = that match {
+    case m: MetaData  =>
+      (this.length == m.length) &&
+      (this.hashCode == m.hashCode) &&
+      (this forall (_ containedIn1 m))
+    case _            => false
+  }
 
   /** returns an iterator on attributes */
   def iterator: Iterator[MetaData] = new Iterator[MetaData] {
@@ -238,8 +223,8 @@ abstract class MetaData extends Iterable[MetaData] {
 
   def toString1(): String = sbToString(toString1)
 
-  //appends string representations of single attribute to StringBuilder
-  def toString1(sb:StringBuilder): Unit
+  // appends string representations of single attribute to StringBuilder
+  def toString1(sb: StringBuilder): Unit
 
   override def toString(): String = sbToString(buildString)
 
@@ -259,7 +244,7 @@ abstract class MetaData extends Iterable[MetaData] {
    *  @param key ...
    *  @return    ...
    */
-  def remove(key:String): MetaData
+  def remove(key: String): MetaData
 
   /**
    *  @param namespace ...

src/library/scala/xml/Node.scala

@@ -174,8 +174,8 @@ abstract class Node extends NodeSeq {
    * @param stripComment if true, strips comment nodes from result
    * @return ...
    */
-  def buildString(stripComment: Boolean): String =
-    Utility.toXML(this, stripComment)
+  def buildString(stripComments: Boolean): String =
+    Utility.toXML(this, stripComments = stripComments).toString
 
   /**
    * Same as <code>toString(false)</code>.

src/library/scala/xml/NodeBuffer.scala

@@ -39,23 +39,12 @@ class NodeBuffer extends scala.collection.mutable.ArrayBuffer[Node] {
    */
   def &+(o: Any): NodeBuffer = {
     o match {
-      case null | _:Unit | Text("")=>
-	// ignore
-
-      case it:Iterator[_] =>
-        while (it.hasNext)
-          this &+ it.next
-
-      case n:Node =>
-        super.+=(n)
-
-      case ns:Iterable[_] =>
-        this &+ ns.iterator
-
-      case d =>
-        super.+=(new Atom(d))
+      case null | _: Unit | Text("")  => // ignore
+      case it: Iterator[_]            => it foreach (this &+ _)
+      case n: Node                    => super.+=(n)
+      case ns: Iterable[_]            => this &+ ns.iterator
+      case d                          => super.+=(new Atom(d))
     }
     this
   }
-
 }

src/library/scala/xml/NodeSeq.scala

@@ -21,7 +21,7 @@ import collection.mutable.ListBuffer
  *  @version 1.0
  */
 object NodeSeq {
-  final val Empty = new NodeSeq { def theSeq = Nil }
+  final val Empty = fromSeq(Nil)
   def fromSeq(s: Seq[Node]): NodeSeq = new NodeSeq {
     def theSeq = s
   }
@@ -46,16 +46,16 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No
   def theSeq: Seq[Node]
   def length = theSeq.length
   override def iterator = theSeq.iterator
-  def apply(i: Int): Node = theSeq.apply(i)
 
+  def apply(i: Int): Node = theSeq(i)
   def apply(f: Node => Boolean): NodeSeq = filter(f)
 
   /** structural equality */
   override def equals(x: Any): Boolean = x match {
     case z:Node      => (length == 1) && z == apply(0)
     case z:Seq[_]    => sameElements(z)
     case z:String    => text == z
-    case _           => false;
+    case _           => false
   }
 
   /** Projection function. Similar to XPath, use <code>this \ "foo"</code>
@@ -128,29 +128,6 @@ abstract class NodeSeq extends immutable.Sequence[Node] with SequenceTemplate[No
     }
   }
 
-  override def toString(): String = theSeq.iterator.foldLeft ("") {
-    (s: String, x: Node) => s + x.toString()
-  }
-/*
-  def map(f: Node => NodeSeq): NodeSeq = flatMap(f)
-
-  def flatMap(f: Node => NodeSeq): NodeSeq = {
-    val y = toList flatMap { x => f(x).toList }
-    y
-  }
-
-  override def filter(f: Node => Boolean): NodeSeq = {
-    val x = toList filter f
-    x
-  }
-*/
-
-  def text: String = {
-    val sb = new StringBuilder()
-    val it = this.iterator
-    while (it.hasNext) {
-      sb.append(it.next.text)
-    }
-    sb.toString()
-  }
+  override def toString(): String = theSeq.mkString
+  def text: String                = this map (_.text) mkString
 }

src/library/scala/xml/Null.scala

@@ -14,7 +14,7 @@ package scala.xml
 case object Null extends MetaData {
 
   /** appends given MetaData items to this MetaData list */
-  override def append(m: MetaData): MetaData = m
+  override def append(m: MetaData, scope: NamespaceBinding = TopScope): MetaData = m
 
   override def containedIn1(m: MetaData): Boolean = false
 

src/library/scala/xml/PCData.scala

@@ -23,9 +23,6 @@ case class PCData(_data: String) extends Atom[String](_data) {
    *  @param  sb ...
    *  @return ...
    */
-  override def buildString(sb: StringBuilder) = {
-    sb.append("<![CDATA[")
-    sb.append(data)
-    sb.append("]]>")
-  }
+  override def buildString(sb: StringBuilder) =
+    sb append "<![CDATA[%s]]>".format(data)
 }

src/library/scala/xml/Parsing.scala

@@ -29,27 +29,26 @@ object Parsing {
   }
 
   /** <pre>(#x20 | #x9 | #xD | #xA)+</pre> */
-  final def isSpace(cs: Seq[Char]): Boolean = {
-    val it = cs.iterator
-    it.hasNext && it.forall { isSpace }
-  }
+  final def isSpace(cs: Seq[Char]): Boolean = cs forall isSpace
 
   /** <pre>NameChar ::= Letter | Digit | '.' | '-' | '_' | ':'
    *             | CombiningChar | Extender</pre>
    *
    * see [4] and Appendix B of XML 1.0 specification
    */
-  def isNameChar(ch: Char) = isNameStart(ch) || (ch match {
-    case '.' | '-' | ':' => true
-    case _ => java.lang.Character.getType(ch).asInstanceOf[Byte] match {
-      case java.lang.Character.COMBINING_SPACING_MARK => true  // Mc
-      case java.lang.Character.ENCLOSING_MARK => true          // Me
-      case java.lang.Character.NON_SPACING_MARK => true        // Mn
-      case java.lang.Character.MODIFIER_LETTER => true         // Lm
-      case java.lang.Character.DECIMAL_DIGIT_NUMBER => true    // Nd
-      case _ => false
-    }
-  });
+  private val nameCharTypeList = {
+    import java.lang.Character._
+    List(
+      COMBINING_SPACING_MARK,   // Mc
+      ENCLOSING_MARK,           // Me
+      NON_SPACING_MARK,         // Mn
+      MODIFIER_LETTER,          // Lm
+      DECIMAL_DIGIT_NUMBER      // Nd
+    )
+  }
+  def isNameChar(ch: Char) =
+    isNameStart(ch) || List('.', '-', ':').contains(ch) ||
+    nameCharTypeList.contains(Character.getType(ch).asInstanceOf[Byte])
 
   /** <pre>NameStart ::= ( Letter | '_' )</pre>
    *  where Letter means in one of the Unicode general
@@ -94,12 +93,5 @@ object Parsing {
   def checkSysID(s: String): Boolean =
     s.indexOf('"') == -1 || s.indexOf('\'') == -1
 
-  def checkPubID(s: String): Boolean =
-    if (s.length() > 0) {
-      val z:Seq[Char] = s
-      val y = z.iterator
-      while (y.hasNext && isPubIDChar(y.next)) {}
-      !y.hasNext
-    } else true
-
+  def checkPubID(s: String): Boolean = s forall isPubIDChar
 }

src/library/scala/xml/ProcInstr.scala

@@ -17,11 +17,12 @@ package scala.xml
  * @param  target target name of this PI
  * @param  text   text contained in this node, may not contain "?>"
  */
-case class ProcInstr(target:String, proctext:String) extends SpecialNode {
+case class ProcInstr(target:String, proctext:String) extends SpecialNode
+{
 
   if (!Utility.isName(target))
     throw new IllegalArgumentException(target+" must be an XML Name")
-  else if (text.indexOf("?>") != -1)
+  if (text.indexOf("?>") != -1)
     throw new IllegalArgumentException(proctext+" may not contain \"?>\"")
 
   final override def collectNamespacesAndDontTransform = false

src/library/scala/xml/QNode.scala

@@ -18,7 +18,5 @@ package scala.xml
  * @version 1.0
  */
 object QNode {
-
-  def unapplySeq(n:Node) = Some (Tuple4(n.scope.getURI(n.prefix), n.label, n.attributes, n.child))
-
+  def unapplySeq(n: Node) = Some((n.scope.getURI(n.prefix), n.label, n.attributes, n.child))
 }

src/library/scala/xml/SpecialNode.scala

@@ -21,8 +21,8 @@ package scala.xml
  *
  *  @author Burak Emir
  */
-abstract class SpecialNode extends Node with pull.XMLEvent {
-
+abstract class SpecialNode extends Node with pull.XMLEvent
+{
   /** always empty */
   final override def attributes = Null
 
@@ -34,5 +34,4 @@ abstract class SpecialNode extends Node with pull.XMLEvent {
 
   /** append string representation to the given stringbuffer */
   def buildString(sb: StringBuilder): StringBuilder
-
 }

src/library/scala/xml/Text.scala

@@ -19,10 +19,10 @@ package scala.xml
  *
  *  @param text the text contained in this node, may not be null.
  */
-case class Text(_data: String) extends Atom[String](_data) {
-
+case class Text(_data: String) extends Atom[String](_data)
+{
   if (null == data)
-    throw new java.lang.NullPointerException("tried to construct Text with null")
+    throw new IllegalArgumentException("tried to construct Text with null")
 
   final override def equals(x: Any) = x match {
     case s:String  => s == data

src/library/scala/xml/Unparsed.scala

@@ -15,12 +15,12 @@ package scala.xml
  *  are off regarding wellformedness etc.
  *
  * @author Burak Emir
- * @param _data content in this node, may not be null.
+ * @param data content in this node, may not be null.
  */
-case class Unparsed(_data: String) extends Atom[String](_data) {
-
+class Unparsed(data: String) extends Atom[String](data)
+{
   if (null == data)
-    throw new java.lang.NullPointerException("tried to construct Unparsed with null")
+    throw new IllegalArgumentException("tried to construct Unparsed with null")
 
   final override def equals(x: Any) = x match {
     case s:String   => s == data
@@ -32,5 +32,9 @@ case class Unparsed(_data: String) extends Atom[String](_data) {
 
   /** returns text, with some characters escaped according to XML spec */
   override def buildString(sb: StringBuilder) = sb append data
-
 }
+
+object Unparsed {
+  def apply(data: String) = new Unparsed(data)
+  def unapply(x: Unparsed) = Some(x.data)
+}