diff options
author | Paul Phillips <paulp@improving.org> | 2010-04-06 18:27:29 +0000 |
---|---|---|
committer | Paul Phillips <paulp@improving.org> | 2010-04-06 18:27:29 +0000 |
commit | 2a8667d1cd0649c5567c65b087f08f5d42e2062b (patch) | |
tree | fde7b369a290faeb85257e22f18b05dac26e6f6f /src/compiler | |
parent | 288c4aaa29f5ef56994fc6f697c7bcd6310aeb5c (diff) | |
download | scala-2a8667d1cd0649c5567c65b087f08f5d42e2062b.tar.gz scala-2a8667d1cd0649c5567c65b087f08f5d42e2062b.tar.bz2 scala-2a8667d1cd0649c5567c65b087f08f5d42e2062b.zip |
Removing some code duplication from scaladoc.
Diffstat (limited to 'src/compiler')
-rw-r--r-- | src/compiler/scala/tools/nsc/doc/html/HtmlFactory.scala | 37 | ||||
-rw-r--r-- | src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala | 130 |
2 files changed, 71 insertions, 96 deletions
diff --git a/src/compiler/scala/tools/nsc/doc/html/HtmlFactory.scala b/src/compiler/scala/tools/nsc/doc/html/HtmlFactory.scala index f01984052f..f695d0067f 100644 --- a/src/compiler/scala/tools/nsc/doc/html/HtmlFactory.scala +++ b/src/compiler/scala/tools/nsc/doc/html/HtmlFactory.scala @@ -7,10 +7,10 @@ package scala.tools.nsc package doc package html +import java.io.{ File => JFile } +import io.{ Streamable, Directory } import reporters.Reporter import model._ - -import java.io.{FileOutputStream, File} import scala.collection._ /** A class that can generate Scaladoc sites to some fixed root folder. @@ -21,31 +21,24 @@ class HtmlFactory(val universe: Universe) { /** The character encoding to be used for generated Scaladoc sites. This value is currently always UTF-8. */ def encoding: String = "UTF-8" - /** The character encoding to be used for generated Scaladoc sites. This value is defined by the generator's - * settings. */ - def siteRoot: File = new File(universe.settings.outdir.value) + def siteRoot: JFile = new JFile(universe.settings.outdir.value) - /** Generates the Scaladoc site for a model into the site toot. A scaladoc site is a set of HTML and related files + /** Generates the Scaladoc site for a model into the site root. A scaladoc site is a set of HTML and related files * that document a model extracted from a compiler run. * @param model The model to generate in the form of a sequence of packages. */ def generate(universe: Universe): Unit = { - def copyResource(subPath: String) { - val buf = new Array[Byte](1024) - val in = getClass.getResourceAsStream("/scala/tools/nsc/doc/html/resource/" + subPath) - assert(in != null) - val dest = new File(siteRoot, subPath) - dest.getParentFile.mkdirs() - val out = new FileOutputStream(dest) - try { - var len = 0 - while ({len = in.read(buf); len != -1}) - out.write(buf, 0, len) - } - finally { - in.close() - out.close() - } + val bytes = new Streamable.Bytes { + val inputStream = getClass.getResourceAsStream("/scala/tools/nsc/doc/html/resource/" + subPath) + assert(inputStream != null) + } . toByteArray() + + val dest = Directory(siteRoot) / subPath + dest.parent.createDirectory() + val out = dest.toFile.bufferedOutput() + + try out.write(bytes, 0, bytes.length) + finally out.close() } copyResource("lib/jquery.js") diff --git a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala index 7811d2d7af..3968d3483c 100644 --- a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala +++ b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala @@ -16,7 +16,7 @@ import model.{ RootPackage => RootPackageEntity } class ModelFactory(val global: Global, val settings: doc.Settings) extends CommentFactory { thisFactory => import global._ - import definitions.{ ObjectClass, ScalaObjectClass, RootPackage, EmptyPackage } + import definitions.{ ObjectClass, ScalaObjectClass, RootPackage, EmptyPackage, NothingClass, AnyClass, AnyRefClass } private var droppedPackages = 0 def templatesCount = templatesCache.size - droppedPackages @@ -84,24 +84,22 @@ class ModelFactory(val global: Global, val settings: doc.Settings) extends Comme else makeTemplate(sym.owner) :: (sym.allOverriddenSymbols map { inhSym => makeTemplate(inhSym.owner) }) def visibility = { - if (sym hasFlag Flags.LOCAL) { - if (sym hasFlag Flags.PRIVATE) PrivateInInstance() - else ProtectedInInstance() - } + if (sym.isPrivateLocal) PrivateInInstance() + else if (sym.isProtectedLocal) ProtectedInInstance() else { val qual = if (sym.privateWithin != null && sym.privateWithin != NoSymbol) Some(makeTemplate(sym.privateWithin)) else None - if (sym hasFlag Flags.PRIVATE) PrivateInTemplate(inTpl) - else if (sym hasFlag Flags.PROTECTED) ProtectedInTemplate(qual getOrElse inTpl) + if (sym.isPrivate) PrivateInTemplate(inTpl) + else if (sym.isProtected) ProtectedInTemplate(qual getOrElse inTpl) else if (qual.isDefined) PrivateInTemplate(qual.get) else Public() } } def flags = { val fgs = mutable.ListBuffer.empty[Paragraph] - if (sym hasFlag Flags.IMPLICIT) fgs += Paragraph(Text("implicit")) + if (sym.isImplicit) fgs += Paragraph(Text("implicit")) if (sym hasFlag Flags.SEALED) fgs += Paragraph(Text("sealed")) if (!sym.isTrait && (sym hasFlag Flags.ABSTRACT)) fgs += Paragraph(Text("abstract")) if (!sym.isTrait && (sym hasFlag Flags.DEFERRED)) fgs += Paragraph(Text("abstract")) @@ -109,14 +107,11 @@ class ModelFactory(val global: Global, val settings: doc.Settings) extends Comme fgs.toList } def deprecation = - if (sym.isDeprecated && sym.deprecationMessage.isDefined) - Some(parseWiki(sym.deprecationMessage.get, NoPosition)) - else if (sym.isDeprecated) - Some(Body(Nil)) - else if (comment.isDefined) - comment.get.deprecated + if (sym.isDeprecated) + Some(sym.deprecationMessage map (x => parseWiki(x, NoPosition)) getOrElse Body(Nil)) else - None + comment flatMap (_.deprecated) + def inheritedFrom = if (inTemplate.sym == this.sym.owner || inTemplate.sym.isPackage) Nil else makeTemplate(this.sym.owner) :: (sym.allOverriddenSymbols map { os => makeTemplate(os.owner) }) @@ -167,7 +162,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) extends Comme case _ => } } - sym.ancestors filter (_ != ScalaObjectClass) map (makeTemplate(_)) + sym.ancestors filter (_ != ScalaObjectClass) map makeTemplate } private lazy val subClassesCache = mutable.Buffer.empty[DocTemplateEntity] def registerSubClass(sc: DocTemplateEntity) = { @@ -209,18 +204,25 @@ class ModelFactory(val global: Global, val settings: doc.Settings) extends Comme override def inTemplate = inTpl } + private trait StdTypeBounds extends EntityImpl { + def lo = sym.info.normalize match { + case TypeBounds(lo, hi) if lo.typeSymbol != NothingClass => Some(makeType(lo, inTemplate, sym)) + case _ => None + } + def hi = sym.info.normalize match { + case TypeBounds(lo, hi) if hi.typeSymbol != AnyClass => Some(makeType(hi, inTemplate, sym)) + case _ => None + } + } + /* ============== MAKER METHODS ============== */ /** */ - def normalizeTemplate(aSym: Symbol): Symbol = { - if (aSym == null || aSym == EmptyPackage || aSym == NoSymbol) - normalizeTemplate(RootPackage) - else if (aSym == ScalaObjectClass || aSym == ObjectClass) - normalizeTemplate(definitions.AnyRefClass) - else if (aSym.isModuleClass || aSym.isPackageObject) - normalizeTemplate(aSym.sourceModule) - else - aSym + def normalizeTemplate(aSym: Symbol): Symbol = aSym match { + case null | EmptyPackage | NoSymbol => normalizeTemplate(RootPackage) + case ScalaObjectClass | ObjectClass => normalizeTemplate(AnyRefClass) + case _ if aSym.isModuleClass || aSym.isPackageObject => normalizeTemplate(aSym.sourceModule) + case _ => aSym } def makeRootPackage: Option[PackageImpl] = @@ -303,7 +305,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) extends Comme List(sym.constrParamAccessors map (makeValueParam(_, this))) val constructors = members collect { case d: Constructor => d } - def primaryConstructor = (constructors find (_.isPrimary)) + def primaryConstructor = constructors find (_.isPrimary) def isCaseClass = sym.isClass && sym.hasFlag(Flags.CASE) } else @@ -312,55 +314,47 @@ class ModelFactory(val global: Global, val settings: doc.Settings) extends Comme /** */ def makeMember(aSym: Symbol, inTpl: => DocTemplateImpl): List[MemberImpl] = { + def makeMember0(bSym: Symbol): Option[MemberImpl] = { - if (bSym.isGetter && (bSym.accessed hasFlag Flags.MUTABLE)) - Some(new NonTemplateMemberImpl(bSym, inTpl) with Val { + abstract class MakeMemberTemplateImpl extends NonTemplateMemberImpl(bSym, inTpl) { + def isUseCase = bSym.isSynthetic + } + trait MethodParams extends MakeMemberTemplateImpl { + def valueParams = + sym.paramss map { ps => + ps.zipWithIndex map { case (p, i) => + if (p.nameString contains "$") makeValueParam(p, inTemplate, optimize("arg" + i)) + else makeValueParam(p, inTemplate) + } + } + } + + if (bSym.isGetter && bSym.accessed.isMutable) + Some(new MakeMemberTemplateImpl with Val { override def isVar = true - def isUseCase = bSym hasFlag Flags.SYNTHETIC }) - else if (bSym.isMethod && !(bSym hasFlag Flags.ACCESSOR) && !bSym.isConstructor) - Some(new NonTemplateMemberImpl(bSym, inTpl) with Def { + else if (bSym.isMethod && !bSym.isGetterOrSetter && !bSym.isConstructor) + Some(new MakeMemberTemplateImpl with Def with MethodParams { override def isDef = true - def isUseCase = bSym hasFlag Flags.SYNTHETIC def typeParams = sym.tpe.typeParams map (makeTypeParam(_, inTpl)) - def valueParams = - sym.paramss map { ps => (ps.zipWithIndex) map { case (p, i) => - if (p.nameString contains "$") makeValueParam(p, inTpl, optimize("arg" + i)) else makeValueParam(p, inTpl) - }} }) else if (bSym.isConstructor) - Some(new NonTemplateMemberImpl(bSym, inTpl) with Constructor { + Some(new MakeMemberTemplateImpl with Constructor with MethodParams { override def isConstructor = true - def isUseCase = bSym hasFlag Flags.SYNTHETIC def isPrimary = sym.isPrimaryConstructor - def valueParams = - sym.paramss map { ps => (ps.zipWithIndex) map { case (p, i) => - if (p.nameString contains "$") makeValueParam(p, inTpl, optimize("arg" + i)) else makeValueParam(p, inTpl) - }} }) else if (bSym.isGetter) // Scala field accessor or Java field - Some(new NonTemplateMemberImpl(bSym, inTpl) with Val { + Some(new MakeMemberTemplateImpl with Val { override def isVal = true - def isUseCase = bSym hasFlag Flags.SYNTHETIC }) else if (bSym.isAbstractType) - Some(new NonTemplateMemberImpl(bSym, inTpl) with AbstractType { + Some(new MakeMemberTemplateImpl with AbstractType with StdTypeBounds { override def isAbstractType = true - def isUseCase = bSym hasFlag Flags.SYNTHETIC - def lo = sym.info.normalize match { - case TypeBounds(lo, hi) if lo.typeSymbol != definitions.NothingClass => Some(makeType(lo, inTpl, sym)) - case _ => None - } - def hi = sym.info.normalize match { - case TypeBounds(lo, hi) if hi.typeSymbol != definitions.AnyClass => Some(makeType(hi, inTpl, sym)) - case _ => None - } }) else if (bSym.isAliasType) - Some(new NonTemplateMemberImpl(bSym, inTpl) with AliasType { + Some(new MakeMemberTemplateImpl with AliasType { override def isAliasType = true - def isUseCase = bSym hasFlag Flags.SYNTHETIC def alias = makeType(sym.tpe, inTpl, sym) }) else if (bSym.isPackage) @@ -376,13 +370,13 @@ class ModelFactory(val global: Global, val settings: doc.Settings) extends Comme val allSyms = useCases(aSym, inTpl.sym) map { case (bSym, bComment, bPos) => addCommentBody(bSym, inTpl, bComment, bPos) } - (allSyms ::: List(aSym)) flatMap (makeMember0(_)) + (allSyms :+ aSym) flatMap makeMember0 } } /** */ def makeTypeParam(aSym: Symbol, inTpl: => DocTemplateImpl): TypeParam = { - new ParameterImpl(aSym, inTpl) with TypeParam { + new ParameterImpl(aSym, inTpl) with TypeParam with StdTypeBounds { def isTypeParam = true def isValueParam = false def variance: String = { @@ -390,16 +384,6 @@ class ModelFactory(val global: Global, val settings: doc.Settings) extends Comme else if (sym hasFlag Flags.CONTRAVARIANT) "-" else "" } - def lo = sym.info.normalize match { - case TypeBounds(lo, hi) if lo.typeSymbol != definitions.NothingClass => - Some(makeType(lo, inTpl, sym)) - case _ => None - } - def hi = sym.info.normalize match { - case TypeBounds(lo, hi) if hi.typeSymbol != definitions.AnyClass => - Some(makeType(hi, inTpl, sym)) - case _ => None - } } } @@ -415,7 +399,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) extends Comme def isTypeParam = false def isValueParam = true def defaultValue = - if (aSym.hasFlag(Flags.DEFAULTPARAM)) + if (aSym.hasDefault) // units.filter should return only one element (currentRun.units filter (_.source.file == aSym.sourceFile)).toList match { case List(unit) => @@ -428,7 +412,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) extends Comme else None def resultType = makeType(sym.tpe, inTpl, sym) - def isImplicit = aSym.hasFlag(Flags.IMPLICIT) + def isImplicit = aSym.isImplicit } /** */ @@ -512,8 +496,6 @@ class ModelFactory(val global: Global, val settings: doc.Settings) extends Comme (aSym.isPackageClass || (aSym.sourceFile != null)) && localShouldDocument(aSym) && ( aSym.owner == NoSymbol || templateShouldDocument(aSym.owner) ) } - def localShouldDocument(aSym: Symbol): Boolean = { - !(aSym hasFlag Flags.PRIVATE) && ((aSym hasFlag Flags.PROTECTED) || aSym.privateWithin == NoSymbol) && !(aSym hasFlag Flags.SYNTHETIC) - } - + def localShouldDocument(aSym: Symbol): Boolean = + !aSym.isPrivate && (aSym.isProtected || aSym.privateWithin == NoSymbol) && !aSym.isSynthetic } |