diff options
Diffstat (limited to 'src')
11 files changed, 11 insertions, 1226 deletions
diff --git a/src/scaladoc/scala/tools/nsc/doc/DocFactory.scala b/src/scaladoc/scala/tools/nsc/doc/DocFactory.scala index 47ddfb8aa9..fb6c39d7e3 100644 --- a/src/scaladoc/scala/tools/nsc/doc/DocFactory.scala +++ b/src/scaladoc/scala/tools/nsc/doc/DocFactory.scala @@ -111,11 +111,6 @@ class DocFactory(val reporter: Reporter, val settings: doc.Settings) { processor case universer: Universer => val universe = makeUniverse(Left(files)) getOrElse { throw NoCompilerRunException } universer setUniverse universe - - docletInstance match { - case indexer: Indexer => indexer setIndex model.IndexModelFactory.makeIndex(universe) - case _ => () - } case _ => () } docletInstance.generate() diff --git a/src/scaladoc/scala/tools/nsc/doc/doclet/Generator.scala b/src/scaladoc/scala/tools/nsc/doc/doclet/Generator.scala index 42b56aa927..b4ede6d358 100644 --- a/src/scaladoc/scala/tools/nsc/doc/doclet/Generator.scala +++ b/src/scaladoc/scala/tools/nsc/doc/doclet/Generator.scala @@ -9,7 +9,6 @@ import scala.collection._ * to configure what data is actually available to the generator: * - A `Universer` provides a `Universe` data structure representing the interfaces and comments of the documented * program. - * - An `Indexer` provides precalculated indexing information about a universe. * To implement this class only requires defining method `generateImpl`. */ abstract class Generator { diff --git a/src/scaladoc/scala/tools/nsc/doc/doclet/Indexer.scala b/src/scaladoc/scala/tools/nsc/doc/doclet/Indexer.scala deleted file mode 100644 index 12fee69cca..0000000000 --- a/src/scaladoc/scala/tools/nsc/doc/doclet/Indexer.scala +++ /dev/null @@ -1,21 +0,0 @@ -package scala.tools.nsc -package doc -package doclet - -/** A `Generator` may implement the `Indexer` trait to gain access to pre-calculated indexing information */ -trait Indexer extends Generator with Universer { - - protected var indexField: Index = null - - def index: Index = indexField - - def setIndex(i: Index) { - assert(indexField == null) - indexField = i - } - - checks += { () => - indexField != null - } - -} diff --git a/src/scaladoc/scala/tools/nsc/doc/html/Doclet.scala b/src/scaladoc/scala/tools/nsc/doc/html/Doclet.scala index cad7cf3298..541266e4cc 100644 --- a/src/scaladoc/scala/tools/nsc/doc/html/Doclet.scala +++ b/src/scaladoc/scala/tools/nsc/doc/html/Doclet.scala @@ -11,10 +11,10 @@ import doclet._ /** The default doclet used by the scaladoc command line tool * when no user-provided doclet is provided. */ -class Doclet extends Generator with Universer with Indexer { +class Doclet extends Generator with Universer { def generateImpl() { - new html.HtmlFactory(universe, index, new ScalaDocReporter(universe.settings)).generate() + new html.HtmlFactory(universe, new ScalaDocReporter(universe.settings)).generate() } } diff --git a/src/scaladoc/scala/tools/nsc/doc/html/HtmlFactory.scala b/src/scaladoc/scala/tools/nsc/doc/html/HtmlFactory.scala index 4f332f1dbe..9d61cd2e2b 100644 --- a/src/scaladoc/scala/tools/nsc/doc/html/HtmlFactory.scala +++ b/src/scaladoc/scala/tools/nsc/doc/html/HtmlFactory.scala @@ -16,7 +16,7 @@ import page.diagram._ /** A class that can generate Scaladoc sites to some fixed root folder. * @author David Bernard * @author Gilles Dubochet */ -class HtmlFactory(val universe: doc.Universe, index: doc.Index, val reporter: ScalaDocReporter) { +class HtmlFactory(val universe: doc.Universe, val reporter: ScalaDocReporter) { import page.{IndexScript, EntityPage} /** The character encoding to be used for generated Scaladoc sites. @@ -99,16 +99,10 @@ class HtmlFactory(val universe: doc.Universe, index: doc.Index, val reporter: Sc libResources foreach (s => copyResource("lib/" + s)) - IndexScript(universe, index) writeFor this + IndexScript(universe) writeFor this - if (index.hasDeprecatedMembers) - new page.DeprecatedIndex(universe, index, reporter) writeFor this try { writeTemplates(_ writeFor this) - - for (letter <- index.firstLetterIndex) { - new html.page.ReferenceIndex(letter._1, index, universe, reporter) writeFor this - } } finally { DiagramStats.printStats(universe.settings) universe.dotRunner.cleanup() diff --git a/src/scaladoc/scala/tools/nsc/doc/html/page/DeprecatedIndex.scala b/src/scaladoc/scala/tools/nsc/doc/html/page/DeprecatedIndex.scala deleted file mode 100644 index e8cb58c732..0000000000 --- a/src/scaladoc/scala/tools/nsc/doc/html/page/DeprecatedIndex.scala +++ /dev/null @@ -1,60 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2007-2013 LAMP/EPFL - */ - -package scala -package tools -package nsc -package doc -package html -package page - -import doc.model._ - -class DeprecatedIndex(universe: Universe, index: doc.Index, rep: ScalaDocReporter) extends HtmlPage { - - def reporter = rep - - def path = List("deprecated-list.html") - - def title = { - val s = universe.settings - ( if (!s.doctitle.isDefault) s.doctitle.value else "" ) + - ( if (!s.docversion.isDefault) (" " + s.docversion.value) else "" ) - } - - def headers = - <xml:group> - <link href={ relativeLinkTo(List("ref-index.css", "lib")) } media="screen" type="text/css" rel="stylesheet"/> - <script type="text/javascript" src={ relativeLinkTo{List("jquery.js", "lib")} }></script> - </xml:group> - - - private def entry(name: String, methods: Iterable[MemberEntity]) = { - val occurrences = methods.filter(_.deprecation.isDefined).map(method => - templateToHtml(method.inDefinitionTemplates.head) - ).toList.distinct - - <div class="entry"> - <div class="name">{ name }</div> - <div class="occurrences">{ - for (owner <- occurrences) yield owner ++ scala.xml.Text(" ") - }</div> - </div> - } - - def deprecatedEntries = { - val available = ('_' +: ('a' to 'z')).flatMap(index.firstLetterIndex.get) - - for (group <- available; - value <- group if value._2.find(_.deprecation.isDefined).isDefined) - yield value - } - - def body = - <body>{ - for(value <- deprecatedEntries) yield - entry(value._1, value._2.view) - }</body> - -} diff --git a/src/scaladoc/scala/tools/nsc/doc/html/page/Entity.scala b/src/scaladoc/scala/tools/nsc/doc/html/page/Entity.scala index 55a85474f6..6c8f989b8c 100644 --- a/src/scaladoc/scala/tools/nsc/doc/html/page/Entity.scala +++ b/src/scaladoc/scala/tools/nsc/doc/html/page/Entity.scala @@ -585,7 +585,7 @@ trait EntityPage extends HtmlPage { <br/> ++ scala.xml.Text("To access this member you can use a ") ++ <a href="http://stackoverflow.com/questions/2087250/what-is-the-purpose-of-type-ascription-in-scala" target="_blank">type ascription</a> ++ scala.xml.Text(":") ++ - <br/> ++ <div class="cmt"><pre>{"(" + Template.lowerFirstLetter(tpl.name) + ": " + conv.targetType.name + ")." + mbr.name + params }</pre></div> + <br/> ++ <div class="cmt"><pre>{"(" + EntityPage.lowerFirstLetter(tpl.name) + ": " + conv.targetType.name + ")." + mbr.name + params }</pre></div> } val shadowingWarning: NodeSeq = @@ -1129,4 +1129,8 @@ object EntityPage { def tpl = docTpl def reporter = rep } + + /* Vlad: Lesson learned the hard way: don't put any stateful code that references the model here, + * it won't be garbage collected and you'll end up filling the heap with garbage */ + def lowerFirstLetter(s: String) = if (s.length >= 1) s.substring(0,1).toLowerCase() + s.substring(1) else s } diff --git a/src/scaladoc/scala/tools/nsc/doc/html/page/Index.scala b/src/scaladoc/scala/tools/nsc/doc/html/page/Index.scala deleted file mode 100644 index 8204f413fd..0000000000 --- a/src/scaladoc/scala/tools/nsc/doc/html/page/Index.scala +++ /dev/null @@ -1,75 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2007-2013 LAMP/EPFL - * @author David Bernard, Manohar Jonnalagedda, Felix Mulder - */ - -package scala.tools.nsc -package doc -package html -package page - -import model._ -import scala.collection._ -import scala.xml._ - -class Index(universe: doc.Universe, val index: doc.Index, rep: ScalaDocReporter) extends HtmlPage { - - def reporter = rep - - def path = List("index.html") - - def title = "" - - val headers = - <xml:group> - <link href={ relativeLinkTo{List("index.css", "lib")} } media="screen" type="text/css" rel="stylesheet"/> - <script type="text/javascript" src={ relativeLinkTo{List("jquery.js", "lib")} }></script> - <script type="text/javascript" src={ relativeLinkTo{List("index.js", "lib")} }></script> - <script type="text/javascript" src="index.js"></script> - <script type="text/javascript" src={ relativeLinkTo{List("scheduler.js", "lib")} }></script> - </xml:group> - - val body = - <body> - { search } - <div id="search-results"> - <div id="results-content"> - <div id="entity-results"></div> - <div id="member-results"></div> - </div> - </div> - <div id="content" style="-webkit-overflow-scrolling: touch;"> - <iframe id="template" name="template" src={ relativeLinkTo{List("package.html")} }/> - </div> - </body> - - def search = - <div id="search"> - <span id="doc-title"> - {universe.settings.doctitle.value} - <span id="doc-version"> - { - val version = universe.settings.docversion.value - - if (version.length > "XX.XX.XX-XXX".length) { - reporter.warning(null, - s"doc-version ($version) is too long to be displayed in the webview") - "" - } else version - } - </span> - </span> - <span class="close-results"><span class="left"><</span> Back</span> - <div id="textfilter"> - <span class="input"> - <input autocapitalize="none" placeholder="Search" id="index-input" type="text" accesskey="/"/> - <span class="clear">✖</span> - </span> - </div> - </div> - - def packageQualifiedName(ety: DocTemplateEntity): String = - if (ety.inTemplate.isPackage) ety.name - else (packageQualifiedName(ety.inTemplate) + "." + ety.name) - -} diff --git a/src/scaladoc/scala/tools/nsc/doc/html/page/IndexScript.scala b/src/scaladoc/scala/tools/nsc/doc/html/page/IndexScript.scala index 2c38036bb6..dd242e6b3b 100644 --- a/src/scaladoc/scala/tools/nsc/doc/html/page/IndexScript.scala +++ b/src/scaladoc/scala/tools/nsc/doc/html/page/IndexScript.scala @@ -12,7 +12,7 @@ import scala.tools.nsc.doc.model.{Package, DocTemplateEntity} import scala.tools.nsc.doc.html.{Page, HtmlFactory} import scala.util.parsing.json.{JSONObject, JSONArray, JSONType} -class IndexScript(universe: doc.Universe, index: doc.Index) extends Page { +class IndexScript(universe: doc.Universe) extends Page { import model._ import scala.tools.nsc.doc.base.comment.Text import scala.collection.immutable.Map @@ -140,6 +140,5 @@ class IndexScript(universe: doc.Universe, index: doc.Index) extends Page { } object IndexScript { - def apply(universe: doc.Universe, index: doc.Index) = - new IndexScript(universe, index) + def apply(universe: doc.Universe) = new IndexScript(universe) } diff --git a/src/scaladoc/scala/tools/nsc/doc/html/page/ReferenceIndex.scala b/src/scaladoc/scala/tools/nsc/doc/html/page/ReferenceIndex.scala deleted file mode 100644 index 6780f17a8c..0000000000 --- a/src/scaladoc/scala/tools/nsc/doc/html/page/ReferenceIndex.scala +++ /dev/null @@ -1,63 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2007-2013 LAMP/EPFL - * @author Pedro Furlanetto - */ - -package scala -package tools -package nsc -package doc -package html -package page - -import doc.model._ - -class ReferenceIndex(letter: Char, index: doc.Index, universe: Universe, rep: ScalaDocReporter) extends HtmlPage { - - def reporter = rep - - def path = List("index-"+letter+".html", "index") - - def title = { - val s = universe.settings - ( if (!s.doctitle.isDefault) s.doctitle.value else "" ) + - ( if (!s.docversion.isDefault) (" " + s.docversion.value) else "" ) - } - - def headers = - <xml:group> - <link href={ relativeLinkTo(List("ref-index.css", "lib")) } media="screen" type="text/css" rel="stylesheet"/> - <script type="text/javascript" src={ relativeLinkTo{List("jquery.js", "lib")} }></script> - </xml:group> - - - private def entry(name: String, methods: Iterable[MemberEntity]) = { - val occurrences = methods.map(method => { - val html = templateToHtml(method.inDefinitionTemplates.head) - if (method.deprecation.isDefined) { - <strike>{ html }</strike> - } else { - html - } - }).toList.distinct - - <div class="entry"> - <div class="name">{ - if (methods.find { ! _.deprecation.isDefined } != None) - name - else - <strike>{ name }</strike> - }</div> - <div class="occurrences">{ - for (owner <- occurrences) yield owner ++ scala.xml.Text(" ") - }</div> - </div> - } - - def body = - <body>{ - for(groups <- index.firstLetterIndex(letter)) yield - entry(groups._1, groups._2.view) - }</body> - -} diff --git a/src/scaladoc/scala/tools/nsc/doc/html/page/Template.scala b/src/scaladoc/scala/tools/nsc/doc/html/page/Template.scala deleted file mode 100644 index f5e909cf90..0000000000 --- a/src/scaladoc/scala/tools/nsc/doc/html/page/Template.scala +++ /dev/null @@ -1,987 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2007-2013 LAMP/EPFL - * @author David Bernard, Manohar Jonnalagedda - */ - -package scala -package tools -package nsc -package doc -package html -package page - -import base._ -import base.comment._ - -import scala.collection.mutable -import scala.xml.{NodeSeq, Text, UnprefixedAttribute} -import scala.language.postfixOps - -import model._ -import model.diagram._ -import diagram._ - -class Template(universe: doc.Universe, generator: DiagramGenerator, tpl: DocTemplateEntity, rep: ScalaDocReporter) extends HtmlPage { - - def reporter = rep - - val path = templateToPath(tpl) - - def title = { - val s = universe.settings - ( if (!s.doctitle.isDefault) s.doctitle.value + " " else "" ) + - ( if (!s.docversion.isDefault) s.docversion.value else "" ) + - ( if ((!s.doctitle.isDefault || !s.docversion.isDefault) && tpl.qualifiedName != "_root_") " - " + tpl.qualifiedName else "" ) - } - - val headers = - <xml:group> - <link href={ relativeLinkTo{List("template.css", "lib")} } media="screen" type="text/css" rel="stylesheet"/> - <link href={ relativeLinkTo{List("diagrams.css", "lib")} } media="screen" type="text/css" rel="stylesheet" id="diagrams-css" /> - <script type="text/javascript" src={ relativeLinkTo{List("jquery.js", "lib")} } id="jquery-js"></script> - <script type="text/javascript" src={ relativeLinkTo{List("jquery.panzoom.min.js", "lib")} }></script> - <script type="text/javascript" src={ relativeLinkTo{List("jquery.mousewheel.min.js", "lib")} }></script> - <script type="text/javascript" src={ relativeLinkTo{List("template.js", "lib")} }></script> - <script type="text/javascript" src={ relativeLinkTo{List("tools.tooltip.js", "lib")} }></script> - { if (universe.settings.docDiagrams.value) { - <script type="text/javascript" src={ relativeLinkTo{List("modernizr.custom.js", "lib")} }></script> - <script type="text/javascript" src={ relativeLinkTo{List("diagrams.js", "lib")} } id="diagrams-js"></script> - } else NodeSeq.Empty } - <script type="text/javascript"> - if(top === self) {{ - var url = '{ val p = templateToPath(tpl); "../" * (p.size - 1) + "index.html" }'; - var hash = '{ val p = templateToPath(tpl); (p.tail.reverse ::: List(p.head.replace(".html", ""))).mkString(".") }'; - var anchor = window.location.hash; - var anchor_opt = ''; - if (anchor.length { scala.xml.Unparsed(">=") /* unless we use Unparsed, it gets escaped and crashes the script */ } 1) - anchor_opt = '@' + anchor.substring(1); - window.location.href = url + '#' + hash + anchor_opt; - }} - </script> - </xml:group> - - val valueMembers = - tpl.methods ++ tpl.values ++ tpl.templates.filter(x => x.isObject || x.isPackage) sorted - - val (absValueMembers, nonAbsValueMembers) = - valueMembers partition (_.isAbstract) - - val (deprValueMembers, nonDeprValueMembers) = - nonAbsValueMembers partition (_.deprecation.isDefined) - - val (concValueMembers, shadowedImplicitMembers) = - nonDeprValueMembers partition (!_.isShadowedOrAmbiguousImplicit) - - val typeMembers = - tpl.abstractTypes ++ tpl.aliasTypes ++ tpl.templates.filter(x => x.isTrait || x.isClass) sorted (implicitly[Ordering[MemberEntity]]) - - val constructors = (tpl match { - case cls: Class => (cls.constructors: List[MemberEntity]).sorted - case _ => Nil - }) - - /* for body, there is a special case for AnyRef, otherwise AnyRef appears - * like a package/object this problem should be fixed, this implementation - * is just a patch. */ - val body = { - val templateName = if (tpl.isRootPackage) "root package" else tpl.name - val displayName = tpl.companion match { - case Some(companion) if (companion.visibility.isPublic && companion.inSource != None) => - <a href={relativeLinkTo(companion)} title={docEntityKindToCompanionTitle(tpl)}>{ templateName }</a> - case _ => - templateName - } - val owner = { - if (tpl.isRootPackage || tpl.inTemplate.isRootPackage) - NodeSeq.Empty - else - <p id="owner">{ templatesToHtml(tpl.inTemplate.toRoot.reverse.tail, scala.xml.Text(".")) }</p> - } - - <body class={ tpl.kind + (if (tpl.isType) " type" else " value") }> - <div id="definition"> - { - val (src, alt) = docEntityKindToBigImage(tpl) - - val identifier = alt.toString.substring(0,2).toLowerCase - - tpl.companion match { - case Some(companion) if (companion.visibility.isPublic && companion.inSource != None) => - <a href={relativeLinkTo(companion)} title={docEntityKindToCompanionTitle(tpl)}><div class={s"big-circle companion $identifier"}>{ identifier.substring(0,1) }</div></a> - case _ => - <div class={ "big-circle " + alt.toString.toLowerCase }>{ identifier.substring(0,1) }</div> - }} - { owner } - <h1>{ displayName }</h1>{ - if (tpl.isPackage) NodeSeq.Empty else <h3>{companionAndPackage(tpl)}</h3> - }{ permalink(tpl) } - { signature(tpl, isSelf = true) } - </div> - - { memberToCommentHtml(tpl, tpl.inTemplate, isSelf = true) } - - <div id="mbrsel"> - <div class='toggle'></div> - <div id='textfilter'><span class='input'><input id='mbrsel-input' placeholder='Filter members' type='text' accesskey='/'/></span><span class='clear'>✖</span></div> - <div id='filterby'> - { if (tpl.linearizationTemplates.isEmpty && tpl.conversions.isEmpty && (!universe.settings.docGroups.value || (tpl.members.map(_.group).distinct.length == 1))) - NodeSeq.Empty - else - <div id="order"> - <span class="filtertype">Ordering</span> - <ol> - { - if (!universe.settings.docGroups.value || (tpl.members.map(_.group).distinct.length == 1)) - NodeSeq.Empty - else - <li class="group out"><span>Grouped</span></li> - } - <li class="alpha in"><span>Alphabetic</span></li> - { - if (tpl.linearizationTemplates.isEmpty && tpl.conversions.isEmpty) - NodeSeq.Empty - else - <li class="inherit out"><span>By Inheritance</span></li> - } - </ol> - </div> - } - { if (tpl.linearizationTemplates.isEmpty && tpl.conversions.isEmpty) NodeSeq.Empty else - { - if (!tpl.linearizationTemplates.isEmpty) - <div class="ancestors"> - <span class="filtertype">Inherited<br/> - </span> - <ol id="linearization"> - { (tpl :: tpl.linearizationTemplates).map(wte => <li class="in" name={ wte.qualifiedName }><span>{ wte.name }</span></li>) } - </ol> - </div> - else NodeSeq.Empty - } ++ { - if (!tpl.conversions.isEmpty) - <div class="ancestors"> - <span class="filtertype">Implicitly<br/> - </span> - <ol id="implicits"> { - tpl.conversions.map { conv => - val name = conv.conversionQualifiedName - val hide = universe.settings.hiddenImplicits(name) - <li class="in" name={ name } data-hidden={ hide.toString }><span>{ "by " + conv.conversionShortName }</span></li> - } - } - </ol> - </div> - else NodeSeq.Empty - } ++ - <div class="ancestors"> - <span class="filtertype"></span> - <ol> - <li class="hideall out"><span>Hide All</span></li> - <li class="showall in"><span>Show All</span></li> - </ol> - </div> - } - { - <div id="visbl"> - <span class="filtertype">Visibility</span> - <ol><li class="public in"><span>Public</span></li><li class="all out"><span>All</span></li></ol> - </div> - } - </div> - </div> - - <div id="template"> - <div id="allMembers"> - { if (constructors.isEmpty) NodeSeq.Empty else - <div id="constructors" class="members"> - <h3>Instance Constructors</h3> - <ol>{ constructors map (memberToHtml(_, tpl)) }</ol> - </div> - } - - { if (typeMembers.isEmpty) NodeSeq.Empty else - <div id="types" class="types members"> - <h3>Type Members</h3> - <ol>{ typeMembers map (memberToHtml(_, tpl)) }</ol> - </div> - } - - { if (absValueMembers.isEmpty) NodeSeq.Empty else - <div class="values members"> - <h3>Abstract Value Members</h3> - <ol>{ absValueMembers map (memberToHtml(_, tpl)) }</ol> - </div> - } - - { if (concValueMembers.isEmpty) NodeSeq.Empty else - <div class="values members"> - <h3>{ if (absValueMembers.isEmpty) "Value Members" else "Concrete Value Members" }</h3> - <ol>{ concValueMembers map (memberToHtml(_, tpl)) }</ol> - </div> - } - - { if (shadowedImplicitMembers.isEmpty) NodeSeq.Empty else - <div class="values members"> - <h3>Shadowed Implicit Value Members</h3> - <ol>{ shadowedImplicitMembers map (memberToHtml(_, tpl)) }</ol> - </div> - } - - { if (deprValueMembers.isEmpty) NodeSeq.Empty else - <div class="values members"> - <h3>Deprecated Value Members</h3> - <ol>{ deprValueMembers map (memberToHtml(_, tpl)) }</ol> - </div> - } - </div> - - <div id="inheritedMembers"> - { - // linearization - NodeSeq fromSeq (for ((superTpl, superType) <- (tpl.linearizationTemplates zip tpl.linearizationTypes)) yield - <div class="parent" name={ superTpl.qualifiedName }> - <h3>Inherited from { - typeToHtmlWithStupidTypes(tpl, superTpl, superType) - }</h3> - </div> - ) - } - { - // implicitly inherited - NodeSeq fromSeq (for (conversion <- (tpl.conversions)) yield - <div class="conversion" name={ conversion.conversionQualifiedName }> - <h3>Inherited by implicit conversion { conversion.conversionShortName } from - { typeToHtml(tpl.resultType, hasLinks = true) } to { typeToHtml(conversion.targetType, hasLinks = true) } - </h3> - </div> - ) - } - </div> - - <div id="groupedMembers"> - { - val allGroups = tpl.members.map(_.group).distinct - val orderedGroups = allGroups.map(group => (tpl.groupPriority(group), group)).sorted.map(_._2) - // linearization - NodeSeq fromSeq (for (group <- orderedGroups) yield - <div class="group" name={ group }> - <h3>{ tpl.groupName(group) }</h3> - { - tpl.groupDescription(group) match { - case Some(body) => <div class="comment cmt">{ bodyToHtml(body) }</div> - case _ => NodeSeq.Empty - } - } - </div> - ) - } - </div> - - </div> - - <div id="tooltip" ></div> - - { - if (Set("epfl", "EPFL").contains(tpl.universe.settings.docfooter.value)) - <div id="footer">Scala programming documentation. Copyright (c) 2003-2016 <a href="http://www.epfl.ch" target="_top">EPFL</a>, with contributions from <a href="http://typesafe.com" target="_top">Typesafe</a>.</div> - else - <div id="footer"> { tpl.universe.settings.docfooter.value } </div> - } - </body> - } - - def memberToHtml(mbr: MemberEntity, inTpl: DocTemplateEntity): NodeSeq = { - // Sometimes it's same, do we need signatureCompat still? - val sig = if (mbr.signature == mbr.signatureCompat) { - <a id={ mbr.signature }/> - } else { - <a id={ mbr.signature }/><a id={ mbr.signatureCompat }/> - } - - val memberComment = memberToCommentHtml(mbr, inTpl, isSelf = false) - <li name={ mbr.definitionName } visbl={ if (mbr.visibility.isProtected) "prt" else "pub" } - data-isabs={ mbr.isAbstract.toString } - fullComment={ if(memberComment.filter(_.label=="div").isEmpty) "no" else "yes" } - group={ mbr.group }> - { sig } - { signature(mbr, isSelf = false) } - { memberComment } - </li> - } - - def memberToCommentHtml(mbr: MemberEntity, inTpl: DocTemplateEntity, isSelf: Boolean): NodeSeq = { - mbr match { - case dte: DocTemplateEntity if isSelf => - // comment of class itself - <xml:group> - <div id="comment" class="fullcommenttop">{ memberToCommentBodyHtml(mbr, inTpl, isSelf = true) }</div> - </xml:group> - case _ => - // comment of non-class member or non-documentented inner class - val commentBody = memberToCommentBodyHtml(mbr, inTpl, isSelf = false) - if (commentBody.isEmpty) - NodeSeq.Empty - else { - val shortComment = memberToShortCommentHtml(mbr, isSelf) - val longComment = memberToUseCaseCommentHtml(mbr, isSelf) ++ memberToCommentBodyHtml(mbr, inTpl, isSelf) - - val includedLongComment = if (shortComment.text.trim == longComment.text.trim) - NodeSeq.Empty - else - <div class="fullcomment">{ longComment }</div> - - shortComment ++ includedLongComment - } - } - } - - def memberToUseCaseCommentHtml(mbr: MemberEntity, isSelf: Boolean): NodeSeq = { - mbr match { - case nte: NonTemplateMemberEntity if nte.isUseCase => - inlineToHtml(comment.Text("[use case] ")) - case _ => NodeSeq.Empty - } - } - - def memberToShortCommentHtml(mbr: MemberEntity, isSelf: Boolean): NodeSeq = - mbr.comment.fold(NodeSeq.Empty) { comment => - <p class="shortcomment cmt">{ memberToUseCaseCommentHtml(mbr, isSelf) }{ inlineToHtml(comment.short) }</p> - } - - def memberToInlineCommentHtml(mbr: MemberEntity, isSelf: Boolean): NodeSeq = - <p class="comment cmt">{ inlineToHtml(mbr.comment.get.short) }</p> - - def memberToCommentBodyHtml(mbr: MemberEntity, inTpl: DocTemplateEntity, isSelf: Boolean, isReduced: Boolean = false): NodeSeq = { - val s = universe.settings - - val memberComment = - if (mbr.comment.isEmpty) NodeSeq.Empty - else <div class="comment cmt">{ commentToHtml(mbr.comment) }</div> - - val authorComment = - if (! s.docAuthor || mbr.comment.isEmpty || - mbr.comment.isDefined && mbr.comment.get.authors.isEmpty) NodeSeq.Empty - else <div class="comment cmt"> - {if (mbr.comment.get.authors.size > 1) <h6>Authors:</h6> else <h6>Author:</h6>} - { mbr.comment.get.authors map bodyToHtml} - </div> - - val paramComments = { - val prs: List[ParameterEntity] = mbr match { - case cls: Class => cls.typeParams ::: cls.valueParams.flatten - case trt: Trait => trt.typeParams - case dfe: Def => dfe.typeParams ::: dfe.valueParams.flatten - case ctr: Constructor => ctr.valueParams.flatten - case _ => Nil - } - - def paramCommentToHtml(prs: List[ParameterEntity], comment: Comment): NodeSeq = prs match { - - case (tp: TypeParam) :: rest => - val paramEntry: NodeSeq = { - <dt class="tparam">{ tp.name }</dt><dd class="cmt">{ bodyToHtml(comment.typeParams(tp.name)) }</dd> - } - paramEntry ++ paramCommentToHtml(rest, comment) - - case (vp: ValueParam) :: rest => - val paramEntry: NodeSeq = { - <dt class="param">{ vp.name }</dt><dd class="cmt">{ bodyToHtml(comment.valueParams(vp.name)) }</dd> - } - paramEntry ++ paramCommentToHtml(rest, comment) - - case _ => - NodeSeq.Empty - } - - mbr.comment.fold(NodeSeq.Empty) { comment => - val cmtedPrs = prs filter { - case tp: TypeParam => comment.typeParams isDefinedAt tp.name - case vp: ValueParam => comment.valueParams isDefinedAt vp.name - } - if (cmtedPrs.isEmpty && comment.result.isEmpty) NodeSeq.Empty - else { - <dl class="paramcmts block">{ - paramCommentToHtml(cmtedPrs, comment) ++ ( - comment.result match { - case None => NodeSeq.Empty - case Some(cmt) => - <dt>returns</dt><dd class="cmt">{ bodyToHtml(cmt) }</dd> - }) - }</dl> - } - } - } - - val implicitInformation = mbr.byConversion match { - case Some(conv) => - <dt class="implicit">Implicit information</dt> ++ - { - val targetType = typeToHtml(conv.targetType, hasLinks = true) - val conversionMethod = conv.convertorMethod match { - case Left(member) => Text(member.name) - case Right(name) => Text(name) - } - - // strip off the package object endings, they make things harder to follow - val conversionOwnerQualifiedNane = conv.convertorOwner.qualifiedName.stripSuffix(".package") - val conversionOwner = templateToHtml(conv.convertorOwner, conversionOwnerQualifiedNane) - - val constraintText = conv.constraints match { - case Nil => - NodeSeq.Empty - case List(constraint) => - scala.xml.Text("This conversion will take place only if ") ++ constraintToHtml(constraint) ++ scala.xml.Text(".") - case List(constraint1, constraint2) => - scala.xml.Text("This conversion will take place only if ") ++ constraintToHtml(constraint1) ++ - scala.xml.Text(" and at the same time ") ++ constraintToHtml(constraint2) ++ scala.xml.Text(".") - case constraints => - <br/> ++ "This conversion will take place only if all of the following constraints are met:" ++ <br/> ++ { - var index = 0 - constraints map { constraint => scala.xml.Text({ index += 1; index } + ". ") ++ constraintToHtml(constraint) ++ <br/> } - } - } - - <dd> - This member is added by an implicit conversion from { typeToHtml(inTpl.resultType, hasLinks = true) } to - { targetType } performed by method { conversionMethod } in { conversionOwner }. - { constraintText } - </dd> - } ++ { - if (mbr.isShadowedOrAmbiguousImplicit) { - // These are the members that are shadowing or ambiguating the current implicit - // see ImplicitMemberShadowing trait for more information - val shadowingSuggestion = { - val params = mbr match { - case d: Def => d.valueParams map (_ map (_ name) mkString("(", ", ", ")")) mkString - case _ => "" // no parameters - } - <br/> ++ scala.xml.Text("To access this member you can use a ") ++ - <a href="http://stackoverflow.com/questions/2087250/what-is-the-purpose-of-type-ascription-in-scala" - target="_blank">type ascription</a> ++ scala.xml.Text(":") ++ - <br/> ++ <div class="cmt"><pre>{"(" + Template.lowerFirstLetter(tpl.name) + ": " + conv.targetType.name + ")." + mbr.name + params }</pre></div> - } - - val shadowingWarning: NodeSeq = - if (mbr.isShadowedImplicit) - scala.xml.Text("This implicitly inherited member is shadowed by one or more members in this " + - "class.") ++ shadowingSuggestion - else if (mbr.isAmbiguousImplicit) - scala.xml.Text("This implicitly inherited member is ambiguous. One or more implicitly " + - "inherited members have similar signatures, so calling this member may produce an ambiguous " + - "implicit conversion compiler error.") ++ shadowingSuggestion - else NodeSeq.Empty - - <dt class="implicit">Shadowing</dt> ++ - <dd>{ shadowingWarning }</dd> - - } else NodeSeq.Empty - } - case _ => - NodeSeq.Empty - } - - // --- start attributes block vals - val attributes: NodeSeq = { - val fvs: List[comment.Paragraph] = visibility(mbr).toList - if (fvs.isEmpty || isReduced) NodeSeq.Empty - else { - <dt>Attributes</dt> - <dd>{ fvs map { fv => { inlineToHtml(fv.text) ++ scala.xml.Text(" ") } } }</dd> - } - } - - val definitionClasses: NodeSeq = { - val inDefTpls = mbr.inDefinitionTemplates - if ((inDefTpls.tail.isEmpty && (inDefTpls.head == inTpl)) || isReduced) NodeSeq.Empty - else { - <dt>Definition Classes</dt> - <dd>{ templatesToHtml(inDefTpls, scala.xml.Text(" → ")) }</dd> - } - } - - val fullSignature: NodeSeq = { - mbr match { - case nte: NonTemplateMemberEntity if nte.isUseCase => - <div class="full-signature-block toggleContainer"> - <span class="toggle">Full Signature</span> - <div class="hiddenContent full-signature-usecase">{ signature(nte.useCaseOf.get,isSelf = true) }</div> - </div> - case _ => NodeSeq.Empty - } - } - - val selfType: NodeSeq = mbr match { - case dtpl: DocTemplateEntity if (isSelf && !dtpl.selfType.isEmpty && !isReduced) => - <dt>Self Type</dt> - <dd>{ typeToHtml(dtpl.selfType.get, hasLinks = true) }</dd> - case _ => NodeSeq.Empty - } - - val annotations: NodeSeq = { - // A list of annotations which don't show their arguments, e. g. because they are shown separately. - val annotationsWithHiddenArguments = List("deprecated", "Deprecated", "migration") - - def showArguments(annotation: Annotation) = - !(annotationsWithHiddenArguments.contains(annotation.qualifiedName)) - - if (!mbr.annotations.isEmpty) { - <dt>Annotations</dt> - <dd>{ - mbr.annotations.map { annot => - <xml:group> - <span class="name">@{ templateToHtml(annot.annotationClass) }</span>{ - if (showArguments(annot)) argumentsToHtml(annot.arguments) else NodeSeq.Empty - } - </xml:group> - } - } - </dd> - } else NodeSeq.Empty - } - - val sourceLink: NodeSeq = mbr match { - case dtpl: DocTemplateEntity if (isSelf && dtpl.sourceUrl.isDefined && dtpl.inSource.isDefined && !isReduced) => - val (absFile, _) = dtpl.inSource.get - <dt>Source</dt> - <dd>{ <a href={ dtpl.sourceUrl.get.toString } target="_blank">{ Text(absFile.file.getName) }</a> }</dd> - case _ => NodeSeq.Empty - } - - val deprecation: NodeSeq = - mbr.deprecation match { - case Some(deprecation) if !isReduced => - <dt>Deprecated</dt> - <dd class="cmt">{ bodyToHtml(deprecation) }</dd> - case _ => NodeSeq.Empty - } - - val migration: NodeSeq = - mbr.migration match { - case Some(migration) if !isReduced => - <dt>Migration</dt> - <dd class="cmt">{ bodyToHtml(migration) }</dd> - case _ => NodeSeq.Empty - } - - val mainComment: NodeSeq = mbr.comment match { - case Some(comment) if (! isReduced) => - def orEmpty[T](it: Iterable[T])(gen: =>NodeSeq): NodeSeq = - if (it.isEmpty) NodeSeq.Empty else gen - - val example = - orEmpty(comment.example) { - <div class="block">Example{ if (comment.example.length > 1) "s" else ""}: - <ol>{ - val exampleXml: List[NodeSeq] = for (ex <- comment.example) yield - <li class="cmt">{ bodyToHtml(ex) }</li> - exampleXml.reduceLeft(_ ++ Text(", ") ++ _) - }</ol> - </div> - } - - val version: NodeSeq = - orEmpty(comment.version) { - <dt>Version</dt> - <dd>{ for(body <- comment.version.toList) yield bodyToHtml(body) }</dd> - } - - val sinceVersion: NodeSeq = - orEmpty(comment.since) { - <dt>Since</dt> - <dd>{ for(body <- comment.since.toList) yield bodyToHtml(body) }</dd> - } - - val note: NodeSeq = - orEmpty(comment.note) { - <dt>Note</dt> - <dd>{ - val noteXml: List[NodeSeq] = for(note <- comment.note ) yield <span class="cmt">{bodyToHtml(note)}</span> - noteXml.reduceLeft(_ ++ Text(", ") ++ _) - }</dd> - } - - val seeAlso: NodeSeq = - orEmpty(comment.see) { - <dt>See also</dt> - <dd>{ - val seeXml: List[NodeSeq] = for(see <- comment.see ) yield <span class="cmt">{bodyToHtml(see)}</span> - seeXml.reduceLeft(_ ++ _) - }</dd> - } - - val exceptions: NodeSeq = - orEmpty(comment.throws) { - <dt>Exceptions thrown</dt> - <dd>{ - val exceptionsXml: List[NodeSeq] = - for((name, body) <- comment.throws.toList.sortBy(_._1) ) yield - <span class="cmt">{bodyToHtml(body)}</span> - exceptionsXml.reduceLeft(_ ++ Text("") ++ _) - }</dd> - } - - val todo: NodeSeq = - orEmpty(comment.todo) { - <dt>To do</dt> - <dd>{ - val todoXml: List[NodeSeq] = (for(todo <- comment.todo ) yield <span class="cmt">{bodyToHtml(todo)}</span> ) - todoXml.reduceLeft(_ ++ _) - }</dd> - } - - example ++ version ++ sinceVersion ++ exceptions ++ todo ++ note ++ seeAlso - - case _ => NodeSeq.Empty - } - // end attributes block vals --- - - val attributesInfo = implicitInformation ++ attributes ++ definitionClasses ++ fullSignature ++ selfType ++ annotations ++ deprecation ++ migration ++ sourceLink ++ mainComment - val attributesBlock = - if (attributesInfo.isEmpty) - NodeSeq.Empty - else - <dl class="attributes block"> { attributesInfo }</dl> - - val linearization = mbr match { - case dtpl: DocTemplateEntity if isSelf && !isReduced && dtpl.linearizationTemplates.nonEmpty => - <div class="toggleContainer block"> - <span class="toggle">Linear Supertypes</span> - <div class="superTypes hiddenContent">{ - typesToHtml(dtpl.linearizationTypes, hasLinks = true, sep = scala.xml.Text(", ")) - }</div> - </div> - case _ => NodeSeq.Empty - } - - val subclasses = mbr match { - case dtpl: DocTemplateEntity if isSelf && !isReduced => - val subs = mutable.HashSet.empty[DocTemplateEntity] - def transitive(dtpl: DocTemplateEntity) { - for (sub <- dtpl.directSubClasses if !(subs contains sub)) { - subs add sub - transitive(sub) - } - } - transitive(dtpl) - if (subs.nonEmpty) - <div class="toggleContainer block"> - <span class="toggle">Known Subclasses</span> - <div class="subClasses hiddenContent">{ - templatesToHtml(subs.toList.sorted(Entity.EntityOrdering), scala.xml.Text(", ")) - }</div> - </div> - else NodeSeq.Empty - case _ => NodeSeq.Empty - } - - def createDiagram(f: DocTemplateEntity => Option[Diagram], description: String, id: String): NodeSeq = - if (s.docDiagrams.value) mbr match { - case dtpl: DocTemplateEntity if isSelf && !isReduced => - val diagram = f(dtpl) - if (diagram.isDefined) { - val diagramSvg = generator.generate(diagram.get, tpl, this) - if (diagramSvg != NodeSeq.Empty) { - <div class="toggleContainer block diagram-container" id={ id + "-container"}> - <span class="toggle diagram-link">{ description }</span> - <div class="diagram" id={ id }>{ diagramSvg }</div> - <div id="diagram-controls" class="hiddenContent"> - <button id="diagram-zoom-out" class="diagram-btn"><i class="material-icons"></i></button> - <button id="diagram-zoom-in" class="diagram-btn"><i class="material-icons"></i></button> - <button title="Toggle full-screen" id="diagram-fs" class="diagram-btn to-full"><i class="material-icons"></i></button> - </div> - </div> - } else NodeSeq.Empty - } else NodeSeq.Empty - case _ => NodeSeq.Empty - } else NodeSeq.Empty // diagrams not generated - - val typeHierarchy = createDiagram(_.inheritanceDiagram, "Type Hierarchy", "inheritance-diagram") - val contentHierarchy = createDiagram(_.contentDiagram, "Content Hierarchy", "content-diagram") - - memberComment ++ authorComment ++ paramComments ++ attributesBlock ++ linearization ++ subclasses ++ typeHierarchy ++ contentHierarchy - } - - def boundsToHtml(hi: Option[TypeEntity], lo: Option[TypeEntity], hasLinks: Boolean): NodeSeq = { - def bound0(bnd: Option[TypeEntity], pre: String): NodeSeq = bnd match { - case None => NodeSeq.Empty - case Some(tpe) => scala.xml.Text(pre) ++ typeToHtml(tpe, hasLinks) - } - bound0(lo, " >: ") ++ bound0(hi, " <: ") - } - - def visibility(mbr: MemberEntity): Option[comment.Paragraph] = { - import comment._ - import comment.{ Text => CText } - mbr.visibility match { - case PrivateInInstance() => - Some(Paragraph(CText("private[this]"))) - case PrivateInTemplate(owner) if (owner == mbr.inTemplate) => - Some(Paragraph(CText("private"))) - case PrivateInTemplate(owner) => - Some(Paragraph(Chain(List(CText("private["), EntityLink(comment.Text(owner.qualifiedName), LinkToTpl(owner)), CText("]"))))) - case ProtectedInInstance() => - Some(Paragraph(CText("protected[this]"))) - case ProtectedInTemplate(owner) if (owner == mbr.inTemplate) => - Some(Paragraph(CText("protected"))) - case ProtectedInTemplate(owner) => - Some(Paragraph(Chain(List(CText("protected["), EntityLink(comment.Text(owner.qualifiedName), LinkToTpl(owner)), CText("]"))))) - case Public() => - None - } - } - - /** name, tparams, params, result */ - def signature(mbr: MemberEntity, isSelf: Boolean, isReduced: Boolean = false): NodeSeq = { - - def inside(hasLinks: Boolean, nameLink: String = ""): NodeSeq = - <xml:group> - <span class="modifier_kind"> - <span class="modifier">{ mbr.flags.map(flag => inlineToHtml(flag.text) ++ scala.xml.Text(" ")) }</span> - <span class="kind">{ kindToString(mbr) }</span> - </span> - <span class="symbol"> - { - val nameClass = - if (mbr.isImplicitlyInherited) - if (mbr.isShadowedOrAmbiguousImplicit) - "implicit shadowed" - else - "implicit" - else - "name" - - val nameHtml = { - val value = if (mbr.isConstructor) tpl.name else mbr.name - val span = if (mbr.deprecation.isDefined) - <span class={ nameClass + " deprecated"} title={"Deprecated: "+bodyToStr(mbr.deprecation.get)}>{ value }</span> - else - <span class={ nameClass }>{ value }</span> - val encoded = scala.reflect.NameTransformer.encode(value) - if (encoded != value) { - span % new UnprefixedAttribute("title", - "gt4s: " + encoded + - span.attribute("title").map( - node => ". " + node - ).getOrElse(""), - scala.xml.Null) - } else { - span - } - } - if (!nameLink.isEmpty) - <a href={nameLink}>{nameHtml}</a> - else nameHtml - }{ - def tparamsToHtml(mbr: Any): NodeSeq = mbr match { - case hk: HigherKinded => - val tpss = hk.typeParams - if (tpss.isEmpty) NodeSeq.Empty else { - def tparam0(tp: TypeParam): NodeSeq = - <span name={ tp.name }>{ tp.variance + tp.name }{ tparamsToHtml(tp) }{ boundsToHtml(tp.hi, tp.lo, hasLinks)}</span> - def tparams0(tpss: List[TypeParam]): NodeSeq = (tpss: @unchecked) match { - case tp :: Nil => tparam0(tp) - case tp :: tps => tparam0(tp) ++ Text(", ") ++ tparams0(tps) - } - <span class="tparams">[{ tparams0(tpss) }]</span> - } - case _ => NodeSeq.Empty - } - tparamsToHtml(mbr) - }{ - if (isReduced) NodeSeq.Empty else { - def paramsToHtml(vlsss: List[List[ValueParam]]): NodeSeq = { - def param0(vl: ValueParam): NodeSeq = - // notice the }{ in the next lines, they are necessary to avoid an undesired whitespace in output - <span name={ vl.name }>{ - Text(vl.name) - }{ Text(": ") ++ typeToHtml(vl.resultType, hasLinks) }{ - vl.defaultValue match { - case Some(v) => Text(" = ") ++ treeToHtml(v) - case None => NodeSeq.Empty - } - }</span> - - def params0(vlss: List[ValueParam]): NodeSeq = vlss match { - case Nil => NodeSeq.Empty - case vl :: Nil => param0(vl) - case vl :: vls => param0(vl) ++ Text(", ") ++ params0(vls) - } - def implicitCheck(vlss: List[ValueParam]): NodeSeq = vlss match { - case vl :: vls => if(vl.isImplicit) { <span class="implicit">implicit </span> } else Text("") - case _ => Text("") - } - vlsss map { vlss => <span class="params">({implicitCheck(vlss) ++ params0(vlss) })</span> } - } - mbr match { - case cls: Class => paramsToHtml(cls.valueParams) - case ctr: Constructor => paramsToHtml(ctr.valueParams) - case dfe: Def => paramsToHtml(dfe.valueParams) - case _ => NodeSeq.Empty - } - } - }{ if (isReduced) NodeSeq.Empty else { - mbr match { - case tme: MemberEntity if (tme.isDef || tme.isVal || tme.isLazyVal || tme.isVar) => - <span class="result">: { typeToHtml(tme.resultType, hasLinks) }</span> - - case abt: MemberEntity with AbstractType => - val b2s = boundsToHtml(abt.hi, abt.lo, hasLinks) - if (b2s != NodeSeq.Empty) - <span class="result">{ b2s }</span> - else NodeSeq.Empty - - case alt: MemberEntity with AliasType => - <span class="result"> = { typeToHtml(alt.alias, hasLinks) }</span> - - case tpl: MemberTemplateEntity if !tpl.parentTypes.isEmpty => - <span class="result"> extends { typeToHtml(tpl.parentTypes.map(_._2), hasLinks) }</span> - - case _ => NodeSeq.Empty - } - }} - </span> - </xml:group> - mbr match { - case dte: DocTemplateEntity if !isSelf => - <h4 class="signature">{ inside(hasLinks = true, nameLink = relativeLinkTo(dte)) }</h4> ++ permalink(dte, isSelf) - case _ if isSelf => - <h4 id="signature" class="signature">{ inside(hasLinks = true) }</h4> - case _ => - <h4 class="signature">{ inside(hasLinks = true) }</h4> ++ permalink(mbr) - } - - } - - /** */ - def treeToHtml(tree: TreeEntity): NodeSeq = { - - /** Makes text good looking in the html page : newlines and basic indentation, - * You must change this function if you want to improve pretty printing of default Values - */ - def codeStringToXml(text: String): NodeSeq = { - var goodLookingXml: NodeSeq = NodeSeq.Empty - var indent = 0 - for (c <- text) c match { - case '{' => indent+=1 - goodLookingXml ++= Text("{") - case '}' => indent-=1 - goodLookingXml ++= Text("}") - case '\n' => - goodLookingXml++= <br/> ++ indentation - case _ => goodLookingXml ++= Text(c.toString) - } - def indentation:NodeSeq = { - var indentXml = NodeSeq.Empty - for (x <- 1 to indent) indentXml ++= Text(" ") - indentXml - } - goodLookingXml - } - - var index = 0 - val str = tree.expression - val length = str.length - var myXml: NodeSeq = NodeSeq.Empty - for ((from, (member, to)) <- tree.refEntity.toSeq) { - if (index < from) { - myXml ++= codeStringToXml(str.substring(index,from)) - index = from - } - if (index == from) { - member match { - case mbr: DocTemplateEntity => - val link = relativeLinkTo(mbr) - myXml ++= <span class="name"><a href={link}>{str.substring(from, to)}</a></span> - case mbr: MemberEntity => - val anchor = "#" + mbr.signature - val link = relativeLinkTo(mbr.inTemplate) - myXml ++= <span class="name"><a href={link ++ anchor}>{str.substring(from, to)}</a></span> - } - index = to - } - } - - if (index <= length-1) - myXml ++= codeStringToXml(str.substring(index, length )) - - if (length < 36) - <span class="symbol">{ myXml }</span> - else - <span class="defval" name={ myXml }>{ "..." }</span> - } - - private def argumentsToHtml(argss: List[ValueArgument]): NodeSeq = { - def argumentsToHtml0(argss: List[ValueArgument]): NodeSeq = argss match { - case Nil => NodeSeq.Empty - case arg :: Nil => argumentToHtml(arg) - case arg :: args => argumentToHtml(arg) ++ scala.xml.Text(", ") ++ argumentsToHtml0(args) - } - <span class="args">({ argumentsToHtml0(argss) })</span> - } - - private def argumentToHtml(arg: ValueArgument): NodeSeq = { - <span> - { - arg.parameter match { - case Some(param) => Text(param.name + " = ") - case None => NodeSeq.Empty - } - } - { treeToHtml(arg.value) } - </span> - } - - private def bodyToStr(body: comment.Body): String = - body.blocks flatMap (blockToStr(_)) mkString "" - - private def blockToStr(block: comment.Block): String = block match { - case comment.Paragraph(in) => inlineToStr(in) - case _ => block.toString - } - - private def typeToHtmlWithStupidTypes(tpl: TemplateEntity, superTpl: TemplateEntity, superType: TypeEntity): NodeSeq = - if (tpl.universe.settings.useStupidTypes.value) - superTpl match { - case dtpl: DocTemplateEntity => - val sig = signature(dtpl, isSelf = false, isReduced = true) \ "_" - sig - case tpl: TemplateEntity => - Text(tpl.name) - } - else - typeToHtml(superType, hasLinks = true) - - private def constraintToHtml(constraint: Constraint): NodeSeq = constraint match { - case ktcc: KnownTypeClassConstraint => - scala.xml.Text(ktcc.typeExplanation(ktcc.typeParamName) + " (" + ktcc.typeParamName + ": ") ++ - templateToHtml(ktcc.typeClassEntity) ++ scala.xml.Text(")") - case tcc: TypeClassConstraint => - scala.xml.Text(tcc.typeParamName + " is ") ++ - <a href="http://stackoverflow.com/questions/2982276/what-is-a-context-bound-in-scala" target="_blank"> - context-bounded</a> ++ scala.xml.Text(" by " + tcc.typeClassEntity.qualifiedName + " (" + tcc.typeParamName + ": ") ++ - templateToHtml(tcc.typeClassEntity) ++ scala.xml.Text(")") - case impl: ImplicitInScopeConstraint => - scala.xml.Text("an implicit value of type ") ++ typeToHtml(impl.implicitType, hasLinks = true) ++ scala.xml.Text(" is in scope") - case eq: EqualTypeParamConstraint => - scala.xml.Text(eq.typeParamName + " is " + eq.rhs.name + " (" + eq.typeParamName + " =:= ") ++ - typeToHtml(eq.rhs, hasLinks = true) ++ scala.xml.Text(")") - case bt: BoundedTypeParamConstraint => - scala.xml.Text(bt.typeParamName + " is a superclass of " + bt.lowerBound.name + " and a subclass of " + - bt.upperBound.name + " (" + bt.typeParamName + " >: ") ++ - typeToHtml(bt.lowerBound, hasLinks = true) ++ scala.xml.Text(" <: ") ++ - typeToHtml(bt.upperBound, hasLinks = true) ++ scala.xml.Text(")") - case lb: LowerBoundedTypeParamConstraint => - scala.xml.Text(lb.typeParamName + " is a superclass of " + lb.lowerBound.name + " (" + lb.typeParamName + " >: ") ++ - typeToHtml(lb.lowerBound, hasLinks = true) ++ scala.xml.Text(")") - case ub: UpperBoundedTypeParamConstraint => - scala.xml.Text(ub.typeParamName + " is a subclass of " + ub.upperBound.name + " (" + ub.typeParamName + " <: ") ++ - typeToHtml(ub.upperBound, hasLinks = true) ++ scala.xml.Text(")") - } -} - -object Template { - /* Vlad: Lesson learned the hard way: don't put any stateful code that references the model here, - * it won't be garbage collected and you'll end up filling the heap with garbage */ - - def lowerFirstLetter(s: String) = if (s.length >= 1) s.substring(0,1).toLowerCase() + s.substring(1) else s -} |