// Copyright 2014 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.devtools.build.docgen;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.google.devtools.build.docgen.skylark.SkylarkBuiltinMethodDoc;
import com.google.devtools.build.docgen.skylark.SkylarkJavaMethodDoc;
import com.google.devtools.build.docgen.skylark.SkylarkModuleDoc;
import com.google.devtools.build.lib.skylarkinterface.SkylarkCallable;
import com.google.devtools.build.lib.skylarkinterface.SkylarkModule;
import com.google.devtools.build.lib.skylarkinterface.SkylarkModuleCategory;
import com.google.devtools.build.lib.skylarkinterface.SkylarkSignature;
import com.google.devtools.build.lib.syntax.FuncallExpression;
import com.google.devtools.build.lib.syntax.Runtime;
import com.google.devtools.build.lib.util.Classpath;
import com.google.devtools.build.lib.util.Classpath.ClassPathException;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
/**
* A helper class that collects Skylark module documentation.
*/
final class SkylarkDocumentationCollector {
@SkylarkModule(
name = "globals",
title = "Globals",
category = SkylarkModuleCategory.TOP_LEVEL_TYPE,
doc = "Objects, functions and modules registered in the global environment."
)
private static final class TopLevelModule {}
// Common prefix of packages that may contain Skylark modules.
private static final String MODULES_PACKAGE_PREFIX = "com/google/devtools/build";
private SkylarkDocumentationCollector() {}
/**
* Returns the SkylarkModule annotation for the top-level Skylark module.
*/
public static SkylarkModule getTopLevelModule() {
return TopLevelModule.class.getAnnotation(SkylarkModule.class);
}
/**
* Collects the documentation for all Skylark modules and returns a map that maps Skylark module
* name to the module documentation.
*
* <p>WARNING: This method no longer supports the specification of additional module classes via
* parameters. Instead, all module classes are being picked up automatically.
*
* @param clazz DEPRECATED.
*/
public static Map<String, SkylarkModuleDoc> collectModules(@Deprecated String... clazz)
throws ClassPathException {
Map<String, SkylarkModuleDoc> modules = new TreeMap<>();
Map<SkylarkModule, Class<?>> builtinModules = new HashMap<>();
for (Class<?> candidateClass : Classpath.findClasses(MODULES_PACKAGE_PREFIX)) {
SkylarkModule annotation = candidateClass.getAnnotation(SkylarkModule.class);
if (annotation != null) {
collectBuiltinModule(builtinModules, candidateClass);
collectJavaObjects(annotation, candidateClass, modules);
}
collectBuiltinDoc(modules, candidateClass.getDeclaredFields());
}
return modules;
}
/**
* Collects and returns all the Java objects reachable in Skylark from (and including)
* firstClass with the corresponding SkylarkModule annotation.
*
* <p>Note that the {@link SkylarkModule} annotation for firstClass - firstModule -
* is also an input parameter, because some top level Skylark built-in objects and methods
* are not annotated on the class, but on a field referencing them.
*/
@VisibleForTesting
static void collectJavaObjects(SkylarkModule firstModule, Class<?> firstClass,
Map<String, SkylarkModuleDoc> modules) {
Set<Class<?>> done = new HashSet<>();
Deque<Class<?>> toProcess = new LinkedList<>();
Map<Class<?>, SkylarkModule> annotations = new HashMap<>();
toProcess.addLast(firstClass);
annotations.put(firstClass, firstModule);
while (!toProcess.isEmpty()) {
Class<?> c = toProcess.removeFirst();
SkylarkModule annotation = annotations.get(c);
done.add(c);
if (!modules.containsKey(annotation.name())) {
modules.put(annotation.name(), new SkylarkModuleDoc(annotation, c));
}
SkylarkModuleDoc module = modules.get(annotation.name());
if (module.javaMethodsNotCollected()) {
ImmutableMap<Method, SkylarkCallable> methods =
FuncallExpression.collectSkylarkMethodsWithAnnotation(c);
for (Map.Entry<Method, SkylarkCallable> entry : methods.entrySet()) {
module.addMethod(new SkylarkJavaMethodDoc(module, entry.getKey(), entry.getValue()));
}
for (Map.Entry<Method, SkylarkCallable> method : methods.entrySet()) {
Class<?> returnClass = method.getKey().getReturnType();
if (returnClass.isAnnotationPresent(SkylarkModule.class)
&& !done.contains(returnClass)) {
toProcess.addLast(returnClass);
annotations.put(returnClass, returnClass.getAnnotation(SkylarkModule.class));
}
}
}
}
}
private static void collectBuiltinDoc(Map<String, SkylarkModuleDoc> modules, Field[] fields) {
for (Field field : fields) {
if (field.isAnnotationPresent(SkylarkSignature.class)) {
SkylarkSignature skylarkSignature = field.getAnnotation(SkylarkSignature.class);
Class<?> moduleClass = skylarkSignature.objectType();
SkylarkModule skylarkModule = moduleClass.equals(Object.class)
? getTopLevelModule()
: Runtime.getCanonicalRepresentation(moduleClass).getAnnotation(SkylarkModule.class);
if (skylarkModule == null) {
// TODO(bazel-team): we currently have undocumented methods on undocumented data
// structures, namely java.util.List. Remove this case when we are done.
Preconditions.checkState(!skylarkSignature.documented());
Preconditions.checkState(moduleClass == List.class);
} else {
if (!modules.containsKey(skylarkModule.name())) {
modules.put(skylarkModule.name(), new SkylarkModuleDoc(skylarkModule, moduleClass));
}
SkylarkModuleDoc module = modules.get(skylarkModule.name());
module.addMethod(new SkylarkBuiltinMethodDoc(module, skylarkSignature, field.getType()));
}
}
}
}
private static void collectBuiltinModule(
Map<SkylarkModule, Class<?>> modules, Class<?> moduleClass) {
if (moduleClass.isAnnotationPresent(SkylarkModule.class)) {
SkylarkModule skylarkModule = moduleClass.getAnnotation(SkylarkModule.class);
modules.put(skylarkModule, moduleClass);
}
}
}