From fef1af300edfa0697f9d8f749a5c9398f209bf36 Mon Sep 17 00:00:00 2001 From: Felix Mulder Date: Tue, 31 Jan 2017 14:22:57 +0100 Subject: Rename `java.scala` -> `JavaConverters.scala` --- doc-tool/src/dotty/tools/dottydoc/DocDriver.scala | 4 +- .../tools/dottydoc/model/JavaConverters.scala | 312 +++++++++++++++++++++ .../dottydoc/model/comment/CommentCleaner.scala | 3 +- doc-tool/src/dotty/tools/dottydoc/model/java.scala | 311 -------------------- .../tools/dottydoc/staticsite/DefaultParams.scala | 2 +- .../src/dotty/tools/dottydoc/staticsite/Site.scala | 2 +- 6 files changed, 318 insertions(+), 316 deletions(-) create mode 100644 doc-tool/src/dotty/tools/dottydoc/model/JavaConverters.scala delete mode 100644 doc-tool/src/dotty/tools/dottydoc/model/java.scala (limited to 'doc-tool') diff --git a/doc-tool/src/dotty/tools/dottydoc/DocDriver.scala b/doc-tool/src/dotty/tools/dottydoc/DocDriver.scala index b675cabb6..515de9ae9 100644 --- a/doc-tool/src/dotty/tools/dottydoc/DocDriver.scala +++ b/doc-tool/src/dotty/tools/dottydoc/DocDriver.scala @@ -14,8 +14,8 @@ import staticsite.Site * tool. It's methods are used by the external scala and java APIs. */ class DocDriver extends Driver { - import _root_.java.util.{ Map => JMap } - import model.java._ + import java.util.{ Map => JMap } + import model.JavaConverters._ override def setup(args: Array[String], rootCtx: Context): (List[String], Context) = { val ctx = rootCtx.fresh diff --git a/doc-tool/src/dotty/tools/dottydoc/model/JavaConverters.scala b/doc-tool/src/dotty/tools/dottydoc/model/JavaConverters.scala new file mode 100644 index 000000000..9c423c3ea --- /dev/null +++ b/doc-tool/src/dotty/tools/dottydoc/model/JavaConverters.scala @@ -0,0 +1,312 @@ +package dotty.tools.dottydoc +package model + +import comment._ +import references._ + +import _root_.java.util.HashMap +import _root_.java.util.LinkedList + +object JavaConverters { + import scala.collection.JavaConverters._ + import _root_.java.util.{ Optional => JOptional, Map => JMap } + + implicit class OptStr(val opt: Option[String]) extends AnyVal { + def asJava = opt.getOrElse(null) + } + + implicit class OptMap(val opt: Option[JMap[String, _]]) extends AnyVal { + def asJava = opt.getOrElse(Map.empty.asJava) + } + + implicit class JavaComment(val cmt: Comment) extends AnyVal { + def asJava: JMap[String, _] = Map( + "body" -> cmt.body, + "short" -> cmt.short, + "authors" -> cmt.authors.asJava, + "see" -> cmt.see.asJava, + "result" -> cmt.result.asJava, + "throws" -> cmt.throws.asJava, + "valueParams" -> cmt.valueParams.asJava, + "typeParams" -> cmt.typeParams.asJava, + "version" -> cmt.version.asJava, + "since" -> cmt.since.asJava, + "todo" -> cmt.todo.asJava, + "deprecated" -> cmt.deprecated.asJava, + "note" -> cmt.note.asJava, + "example" -> cmt.example.asJava, + "constructor" -> cmt.constructor.asJava, + "group" -> cmt.group.asJava, + "groupDesc" -> cmt.groupDesc.asJava, + "groupNames" -> cmt.groupNames.asJava, + "groupPrio" -> cmt.groupPrio.asJava, + "hideImplicitConversions" -> cmt.hideImplicitConversions.asJava + ).asJava + } + + implicit class JavaPackage(val ent: Package) extends AnyVal { + def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = (Map( + "kind" -> ent.kind, + "annotations" -> ent.annotations.asJava, + "name" -> ent.name, + "path" -> ent.path.asJava, + "members" -> ent.members.map(_.asJava()).asJava, + "children" -> ent.children.map(_.asJava()).asJava, + "comment" -> ent.comment.map(_.asJava).asJava, + "superTypes" -> ent.superTypes, + "hasVisibleMembers" -> ent.hasVisibleMembers, + "signature" -> ent.signature + ) ++ extras).asJava + } + + implicit class JavaCaseClass(val ent: CaseClass) extends AnyVal { + def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = (Map( + "kind" -> ent.kind, + "annotations" -> ent.annotations.asJava, + "name" -> ent.name, + "members" -> ent.members.map(_.asJava()).asJava, + "modifiers" -> ent.modifiers.asJava, + "path" -> ent.path.asJava, + "typeParams" -> ent.typeParams.asJava, + "superTypes" -> ent.superTypes.map(_.asJava).asJava, + "comment" -> ent.comment.map(_.asJava).asJava, + "isPrivate" -> ent.isPrivate, + "isProtected" -> ent.isProtected, + "hasVisibleMembers" -> ent.hasVisibleMembers, + "hasCompanion" -> ent.hasCompanion, + "companionPath" -> ent.companionPath.asJava, + "signature" -> ent.signature + ) ++ extras).asJava + } + + implicit class JavaClass(val ent: Class) extends AnyVal { + def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = (Map( + "kind" -> ent.kind, + "annotations" -> ent.annotations.asJava, + "name" -> ent.name, + "members" -> ent.members.map(_.asJava()).asJava, + "modifiers" -> ent.modifiers.asJava, + "path" -> ent.path.asJava, + "typeParams" -> ent.typeParams.asJava, + "superTypes" -> ent.superTypes.map(_.asJava).asJava, + "comment" -> ent.comment.map(_.asJava).asJava, + "isPrivate" -> ent.isPrivate, + "isProtected" -> ent.isProtected, + "hasVisibleMembers" -> ent.hasVisibleMembers, + "hasCompanion" -> ent.hasCompanion, + "companionPath" -> ent.companionPath.asJava, + "signature" -> ent.signature + ) ++ extras).asJava + } + + implicit class JavaTrait(val ent: Trait) extends AnyVal { + def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = (Map( + "kind" -> ent.kind, + "annotations" -> ent.annotations.asJava, + "name" -> ent.name, + "members" -> ent.members.map(_.asJava()).asJava, + "modifiers" -> ent.modifiers.asJava, + "path" -> ent.path.asJava, + "typeParams" -> ent.typeParams.asJava, + "superTypes" -> ent.superTypes.map(_.asJava).asJava, + "comment" -> ent.comment.map(_.asJava).asJava, + "isPrivate" -> ent.isPrivate, + "isProtected" -> ent.isProtected, + "hasVisibleMembers" -> ent.hasVisibleMembers, + "hasCompanion" -> ent.hasCompanion, + "companionPath" -> ent.companionPath.asJava, + "signature" -> ent.signature + ) ++ extras).asJava + } + + implicit class JavaObject(val ent: Object) extends AnyVal { + def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = (Map( + "kind" -> ent.kind, + "annotations" -> ent.annotations.asJava, + "name" -> ent.name, + "members" -> ent.members.map(_.asJava()).asJava, + "modifiers" -> ent.modifiers.asJava, + "path" -> ent.path.asJava, + "superTypes" -> ent.superTypes.map(_.asJava).asJava, + "comment" -> ent.comment.map(_.asJava).asJava, + "isPrivate" -> ent.isPrivate, + "isProtected" -> ent.isProtected, + "hasVisibleMembers" -> ent.hasVisibleMembers, + "hasCompanion" -> ent.hasCompanion, + "companionPath" -> ent.companionPath.asJava, + "signature" -> ent.signature + ) ++ extras).asJava + } + + implicit class JavaDef(val ent: Def) extends AnyVal { + def asJava: JMap[String, _] = Map( + "kind" -> ent.kind, + "annotations" -> ent.annotations.asJava, + "name" -> ent.name, + "modifiers" -> ent.modifiers.asJava, + "path" -> ent.path.asJava, + "returnValue" -> ent.returnValue.asJava, + "typeParams" -> ent.typeParams.asJava, + "paramLists" -> ent.paramLists.map(_.asJava).asJava, + "comment" -> ent.comment.map(_.asJava).asJava, + "implicitlyAddedFrom" -> ent.implicitlyAddedFrom.map(_.asJava).asJava, + "isPrivate" -> ent.isPrivate, + "isProtected" -> ent.isProtected, + "signature" -> ent.signature + ).asJava + } + + implicit class JavaVal(val ent: Val) extends AnyVal { + def asJava: JMap[String, _] = Map( + "kind" -> ent.kind, + "annotations" -> ent.annotations.asJava, + "name" -> ent.name, + "modifiers" -> ent.modifiers.asJava, + "path" -> ent.path.asJava, + "returnValue" -> ent.returnValue.asJava, + "comment" -> ent.comment.map(_.asJava).asJava, + "implicitlyAddedFrom" -> ent.implicitlyAddedFrom.map(_.asJava).asJava, + "isPrivate" -> ent.isPrivate, + "isProtected" -> ent.isProtected, + "signature" -> ent.signature + ).asJava + } + + implicit class JavaTypeAlias(val ent: TypeAlias) extends AnyVal { + def asJava: JMap[String, _] = Map( + "kind" -> ent.kind, + "annotations" -> ent.annotations.asJava, + "modifiers" -> ent.modifiers.asJava, + "name" -> ent.name, + "path" -> ent.path.asJava, + "alias" -> ent.alias.map(_.asJava).asJava, + "comment" -> ent.comment.map(_.asJava).asJava, + "isPrivate" -> ent.isPrivate, + "isProtected" -> ent.isProtected, + "signature" -> ent.signature + ).asJava + } + + implicit class JavaParamList(val pl: ParamList) extends AnyVal { + def asJava: JMap[String, _] = Map( + "list" -> pl.list.map(_.asJava).asJava, + "isImplicit" -> pl.isImplicit + ).asJava + } + + implicit class JavaReference(val ref: Reference) extends AnyVal { + def asJava: JMap[String, _] = ref match { + case TypeReference(title, tpeLink, paramLinks) => Map( + "kind" -> "TypeReference", + "title" -> title, + "tpeLink" -> tpeLink.asJava, + "paramLinks" -> paramLinks.map(_.asJava).asJava, + "scala" -> ref + ).asJava + + case OrTypeReference(left, right) => Map( + "kind" -> "OrTypeReference", + "left" -> left.asJava, + "right" -> right.asJava, + "scala" -> ref + ).asJava + + case AndTypeReference(left, right) => Map( + "kind" -> "AndTypeReference", + "left" -> left.asJava, + "right" -> right.asJava, + "scala" -> ref + ).asJava + + case FunctionReference(args, returnValue) => Map( + "kind" -> "FunctionReference", + "args" -> args.map(_.asJava).asJava, + "returnValue" -> returnValue.asJava, + "scala" -> ref + ).asJava + + case TupleReference(args) => Map( + "kind" -> "TupleReference", + "args" -> args.map(_.asJava).asJava, + "scala" -> ref + ).asJava + + case BoundsReference(low, high) => Map( + "kind" -> "BoundsReference", + "low" -> low.asJava, + "hight" -> high.asJava, + "scala" -> ref + ).asJava + + case NamedReference(title, ref, isByName, isRepeated) => Map( + "kind" -> "NamedReference", + "title" -> title, + "ref" -> ref.asJava, + "isByName" -> isByName, + "isRepeated" -> isRepeated, + "scala" -> ref + ).asJava + + case ConstantReference(title) => Map( + "kind" -> "ConstantReference", + "title" -> title, + "scala" -> ref + ).asJava + + case EmptyReference => + throw new IllegalStateException("Empty reference discovered while converting to Java Map") + } + } + + implicit class JavaMaterializableLink(val link: MaterializableLink) extends AnyVal { + def asJava: JMap[String, _] = link match { + case UnsetLink(title, query) => Map( + "kind" -> "UnsetLink", + "title" -> title, + "query" -> query, + "scala" -> link + ).asJava + + case MaterializedLink(title, target) => Map( + "kind" -> "MaterializedLink", + "title" -> title, + "target" -> target, + "scala" -> link + ).asJava + + case NoLink(title, target) => Map( + "kind" -> "NoLink", + "title" -> title, + "target" -> target, + "scala" -> link + ).asJava + } + } + + implicit class JavaEntity(val ent: Entity) extends AnyVal { + def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = parseEntity(ent, extras) + } + + private def parseEntity(ent: Entity, extras: Map[String, _]): JMap[String, _] = ent match { + case ent: Package => ent.asJava(extras) + case ent: CaseClass => ent.asJava(extras) + case ent: Class => ent.asJava(extras) + case ent: Trait => ent.asJava(extras) + case ent: Object => ent.asJava(extras) + case ent: Def => ent.asJava + case ent: Val => ent.asJava + case ent: TypeAlias => ent.asJava + case _ => Map.empty.asJava + } + + implicit class JavaMap(val map: collection.Map[String, Package]) extends AnyVal { + def toJavaList: LinkedList[AnyRef] = { + map.toList + .sortBy(_._1) + .foldLeft(new LinkedList[AnyRef]()) { case (list, (_, pkg)) => + list.add(pkg.asJava()) + list + } + } + } +} diff --git a/doc-tool/src/dotty/tools/dottydoc/model/comment/CommentCleaner.scala b/doc-tool/src/dotty/tools/dottydoc/model/comment/CommentCleaner.scala index 30b3b0de0..5b60cd5f9 100644 --- a/doc-tool/src/dotty/tools/dottydoc/model/comment/CommentCleaner.scala +++ b/doc-tool/src/dotty/tools/dottydoc/model/comment/CommentCleaner.scala @@ -4,6 +4,7 @@ package comment trait CommentCleaner { import Regexes._ + import java.util.regex.Matcher def clean(comment: String): List[String] = { def cleanLine(line: String): String = { @@ -18,7 +19,7 @@ trait CommentCleaner { val javadoclessComment = JavadocTags.replaceAllIn(safeComment, { javadocReplacement(_) }) val markedTagComment = SafeTags.replaceAllIn(javadoclessComment, { mtch => - _root_.java.util.regex.Matcher.quoteReplacement(safeTagMarker + mtch.matched + safeTagMarker) + Matcher.quoteReplacement(safeTagMarker + mtch.matched + safeTagMarker) }) markedTagComment.lines.toList map (cleanLine) } diff --git a/doc-tool/src/dotty/tools/dottydoc/model/java.scala b/doc-tool/src/dotty/tools/dottydoc/model/java.scala deleted file mode 100644 index b30c10734..000000000 --- a/doc-tool/src/dotty/tools/dottydoc/model/java.scala +++ /dev/null @@ -1,311 +0,0 @@ -package dotty.tools.dottydoc -package model - -import comment._ -import references._ - -import _root_.java.util.HashMap -import _root_.java.util.LinkedList - -object java { - import scala.collection.JavaConverters._ - import _root_.java.util.{ Optional => JOptional, Map => JMap } - - implicit class OptStr(val opt: Option[String]) extends AnyVal { - def asJava = opt.getOrElse(null) - } - - implicit class OptMap(val opt: Option[JMap[String, _]]) extends AnyVal { - def asJava = opt.getOrElse(Map.empty.asJava) - } - - implicit class JavaComment(val cmt: Comment) extends AnyVal { - def asJava: JMap[String, _] = Map( - "body" -> cmt.body, - "short" -> cmt.short, - "authors" -> cmt.authors.asJava, - "see" -> cmt.see.asJava, - "result" -> cmt.result.asJava, - "throws" -> cmt.throws.asJava, - "valueParams" -> cmt.valueParams.asJava, - "typeParams" -> cmt.typeParams.asJava, - "version" -> cmt.version.asJava, - "since" -> cmt.since.asJava, - "todo" -> cmt.todo.asJava, - "deprecated" -> cmt.deprecated.asJava, - "note" -> cmt.note.asJava, - "example" -> cmt.example.asJava, - "constructor" -> cmt.constructor.asJava, - "group" -> cmt.group.asJava, - "groupDesc" -> cmt.groupDesc.asJava, - "groupNames" -> cmt.groupNames.asJava, - "groupPrio" -> cmt.groupPrio.asJava, - "hideImplicitConversions" -> cmt.hideImplicitConversions.asJava - ).asJava - } - - implicit class JavaPackage(val ent: Package) extends AnyVal { - def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = (Map( - "kind" -> ent.kind, - "annotations" -> ent.annotations.asJava, - "name" -> ent.name, - "path" -> ent.path.asJava, - "members" -> ent.members.map(_.asJava()).asJava, - "children" -> ent.children.map(_.asJava()).asJava, - "comment" -> ent.comment.map(_.asJava).asJava, - "superTypes" -> ent.superTypes, - "hasVisibleMembers" -> ent.hasVisibleMembers, - "signature" -> ent.signature - ) ++ extras).asJava - } - - implicit class JavaCaseClass(val ent: CaseClass) extends AnyVal { - def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = (Map( - "kind" -> ent.kind, - "annotations" -> ent.annotations.asJava, - "name" -> ent.name, - "members" -> ent.members.map(_.asJava()).asJava, - "modifiers" -> ent.modifiers.asJava, - "path" -> ent.path.asJava, - "typeParams" -> ent.typeParams.asJava, - "superTypes" -> ent.superTypes.map(_.asJava).asJava, - "comment" -> ent.comment.map(_.asJava).asJava, - "isPrivate" -> ent.isPrivate, - "isProtected" -> ent.isProtected, - "hasVisibleMembers" -> ent.hasVisibleMembers, - "hasCompanion" -> ent.hasCompanion, - "companionPath" -> ent.companionPath.asJava, - "signature" -> ent.signature - ) ++ extras).asJava - } - - implicit class JavaClass(val ent: Class) extends AnyVal { - def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = (Map( - "kind" -> ent.kind, - "annotations" -> ent.annotations.asJava, - "name" -> ent.name, - "members" -> ent.members.map(_.asJava()).asJava, - "modifiers" -> ent.modifiers.asJava, - "path" -> ent.path.asJava, - "typeParams" -> ent.typeParams.asJava, - "superTypes" -> ent.superTypes.map(_.asJava).asJava, - "comment" -> ent.comment.map(_.asJava).asJava, - "isPrivate" -> ent.isPrivate, - "isProtected" -> ent.isProtected, - "hasVisibleMembers" -> ent.hasVisibleMembers, - "hasCompanion" -> ent.hasCompanion, - "companionPath" -> ent.companionPath.asJava, - "signature" -> ent.signature - ) ++ extras).asJava - } - - implicit class JavaTrait(val ent: Trait) extends AnyVal { - def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = (Map( - "kind" -> ent.kind, - "annotations" -> ent.annotations.asJava, - "name" -> ent.name, - "members" -> ent.members.map(_.asJava()).asJava, - "modifiers" -> ent.modifiers.asJava, - "path" -> ent.path.asJava, - "typeParams" -> ent.typeParams.asJava, - "superTypes" -> ent.superTypes.map(_.asJava).asJava, - "comment" -> ent.comment.map(_.asJava).asJava, - "isPrivate" -> ent.isPrivate, - "isProtected" -> ent.isProtected, - "hasVisibleMembers" -> ent.hasVisibleMembers, - "hasCompanion" -> ent.hasCompanion, - "companionPath" -> ent.companionPath.asJava, - "signature" -> ent.signature - ) ++ extras).asJava - } - - implicit class JavaObject(val ent: Object) extends AnyVal { - def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = (Map( - "kind" -> ent.kind, - "annotations" -> ent.annotations.asJava, - "name" -> ent.name, - "members" -> ent.members.map(_.asJava()).asJava, - "modifiers" -> ent.modifiers.asJava, - "path" -> ent.path.asJava, - "superTypes" -> ent.superTypes.map(_.asJava).asJava, - "comment" -> ent.comment.map(_.asJava).asJava, - "isPrivate" -> ent.isPrivate, - "isProtected" -> ent.isProtected, - "hasVisibleMembers" -> ent.hasVisibleMembers, - "hasCompanion" -> ent.hasCompanion, - "companionPath" -> ent.companionPath.asJava, - "signature" -> ent.signature - ) ++ extras).asJava - } - - implicit class JavaDef(val ent: Def) extends AnyVal { - def asJava: JMap[String, _] = Map( - "kind" -> ent.kind, - "annotations" -> ent.annotations.asJava, - "name" -> ent.name, - "modifiers" -> ent.modifiers.asJava, - "path" -> ent.path.asJava, - "returnValue" -> ent.returnValue.asJava, - "typeParams" -> ent.typeParams.asJava, - "paramLists" -> ent.paramLists.map(_.asJava).asJava, - "comment" -> ent.comment.map(_.asJava).asJava, - "implicitlyAddedFrom" -> ent.implicitlyAddedFrom.map(_.asJava).asJava, - "isPrivate" -> ent.isPrivate, - "isProtected" -> ent.isProtected, - "signature" -> ent.signature - ).asJava - } - - implicit class JavaVal(val ent: Val) extends AnyVal { - def asJava: JMap[String, _] = Map( - "kind" -> ent.kind, - "annotations" -> ent.annotations.asJava, - "name" -> ent.name, - "modifiers" -> ent.modifiers.asJava, - "path" -> ent.path.asJava, - "returnValue" -> ent.returnValue.asJava, - "comment" -> ent.comment.map(_.asJava).asJava, - "implicitlyAddedFrom" -> ent.implicitlyAddedFrom.map(_.asJava).asJava, - "isPrivate" -> ent.isPrivate, - "isProtected" -> ent.isProtected, - "signature" -> ent.signature - ).asJava - } - - implicit class JavaTypeAlias(val ent: TypeAlias) extends AnyVal { - def asJava: JMap[String, _] = Map( - "kind" -> ent.kind, - "annotations" -> ent.annotations.asJava, - "modifiers" -> ent.modifiers.asJava, - "name" -> ent.name, - "path" -> ent.path.asJava, - "alias" -> ent.alias.map(_.asJava).asJava, - "comment" -> ent.comment.map(_.asJava).asJava, - "isPrivate" -> ent.isPrivate, - "isProtected" -> ent.isProtected, - "signature" -> ent.signature - ).asJava - } - - implicit class JavaParamList(val pl: ParamList) extends AnyVal { - def asJava: JMap[String, _] = Map( - "list" -> pl.list.map(_.asJava).asJava, - "isImplicit" -> pl.isImplicit - ).asJava - } - - implicit class JavaReference(val ref: Reference) extends AnyVal { - def asJava: JMap[String, _] = ref match { - case TypeReference(title, tpeLink, paramLinks) => Map( - "kind" -> "TypeReference", - "title" -> title, - "tpeLink" -> tpeLink.asJava, - "paramLinks" -> paramLinks.map(_.asJava).asJava, - "scala" -> ref - ).asJava - - case OrTypeReference(left, right) => Map( - "kind" -> "OrTypeReference", - "left" -> left.asJava, - "right" -> right.asJava, - "scala" -> ref - ).asJava - - case AndTypeReference(left, right) => Map( - "kind" -> "AndTypeReference", - "left" -> left.asJava, - "right" -> right.asJava, - "scala" -> ref - ).asJava - - case FunctionReference(args, returnValue) => Map( - "kind" -> "FunctionReference", - "args" -> args.map(_.asJava).asJava, - "returnValue" -> returnValue.asJava, - "scala" -> ref - ).asJava - - case TupleReference(args) => Map( - "kind" -> "TupleReference", - "args" -> args.map(_.asJava).asJava, - "scala" -> ref - ).asJava - - case BoundsReference(low, high) => Map( - "kind" -> "BoundsReference", - "low" -> low.asJava, - "hight" -> high.asJava, - "scala" -> ref - ).asJava - - case NamedReference(title, ref, isByName, isRepeated) => Map( - "kind" -> "NamedReference", - "title" -> title, - "ref" -> ref.asJava, - "isByName" -> isByName, - "isRepeated" -> isRepeated, - "scala" -> ref - ).asJava - - case ConstantReference(title) => Map( - "kind" -> "ConstantReference", - "title" -> title, - "scala" -> ref - ).asJava - - case EmptyReference => ??? - } - } - - implicit class JavaMaterializableLink(val link: MaterializableLink) extends AnyVal { - def asJava: JMap[String, _] = link match { - case UnsetLink(title, query) => Map( - "kind" -> "UnsetLink", - "title" -> title, - "query" -> query, - "scala" -> link - ).asJava - - case MaterializedLink(title, target) => Map( - "kind" -> "MaterializedLink", - "title" -> title, - "target" -> target, - "scala" -> link - ).asJava - - case NoLink(title, target) => Map( - "kind" -> "NoLink", - "title" -> title, - "target" -> target, - "scala" -> link - ).asJava - } - } - - implicit class JavaEntity(val ent: Entity) extends AnyVal { - def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = parseEntity(ent, extras) - } - - private def parseEntity(ent: Entity, extras: Map[String, _]): JMap[String, _] = ent match { - case ent: Package => ent.asJava(extras) - case ent: CaseClass => ent.asJava(extras) - case ent: Class => ent.asJava(extras) - case ent: Trait => ent.asJava(extras) - case ent: Object => ent.asJava(extras) - case ent: Def => ent.asJava - case ent: Val => ent.asJava - case ent: TypeAlias => ent.asJava - case _ => Map.empty.asJava - } - - implicit class JavaMap(val map: collection.Map[String, Package]) extends AnyVal { - def toJavaList: LinkedList[AnyRef] = { - map.toList - .sortBy(_._1) - .foldLeft(new LinkedList[AnyRef]()) { case (list, (_, pkg)) => - list.add(pkg.asJava()) - list - } - } - } -} diff --git a/doc-tool/src/dotty/tools/dottydoc/staticsite/DefaultParams.scala b/doc-tool/src/dotty/tools/dottydoc/staticsite/DefaultParams.scala index cc1f8862f..066b23e0b 100644 --- a/doc-tool/src/dotty/tools/dottydoc/staticsite/DefaultParams.scala +++ b/doc-tool/src/dotty/tools/dottydoc/staticsite/DefaultParams.scala @@ -15,7 +15,7 @@ case class DefaultParams( sidebar: Sidebar, entity: Entity = NonEntity ) { - import model.java._ + import model.JavaConverters._ def toMap: Map[String, AnyRef] = Map( "docs" -> docs, diff --git a/doc-tool/src/dotty/tools/dottydoc/staticsite/Site.scala b/doc-tool/src/dotty/tools/dottydoc/staticsite/Site.scala index 895668df2..4d4dbc75d 100644 --- a/doc-tool/src/dotty/tools/dottydoc/staticsite/Site.scala +++ b/doc-tool/src/dotty/tools/dottydoc/staticsite/Site.scala @@ -30,7 +30,7 @@ import scala.collection.mutable.ArrayBuffer case class Site(val root: JFile, val projectTitle: String, val documentation: Map[String, Package]) extends ResourceFinder { /** Documentation serialized to java maps */ private val docs: JList[_] = { - import model.java._ + import model.JavaConverters._ documentation.toJavaList } -- cgit v1.2.3