Living documentation

@Retention(RetentionPolicy.RUNTIME)
public @interface Functionnality {
    String name();
}

@Functionnality(name = "Living Documentation")
public void functionnalityToDocument() {
    // ...
}

public String generateFunctionnalities() {
    Set<Method> annotatedMethod = getAnnotatedMethod();

    return annotatedMethod.stream()
            .map(m -> formatDoc(m))
            .collect(joining("\n\n"));
}

/// Retrieve methods with a specific annotation.
private Set<Method> getAnnotatedMethod() {

    String packageToScan = "org.dojo.livingdoc";
    Reflections reflections = new Reflections(packageToScan, new MethodAnnotationsScanner());

    return reflections.getMethodsAnnotatedWith(Functionnality.class);
}

/// Extract information from annotation parameters (here the attribute name).
private String formatDoc(Method method) {
    return String.format("*%s* (%s): %s",
            method.getName(),
            method.getDeclaringClass().getSimpleName(),
            method.getDeclaredAnnotation(Functionnality.class).name());
}

public GlossaryDoc() {
    builder = new JavaProjectBuilder();
    builder.addSourceTree(new File("src/main/java"));
}

public String generateGlossary() {
    return new Reflections("org.dojo.livingdoc")
            .getTypesAnnotatedWith(Glossary.class, false)
            .stream()
            .map(this::formatGlossary)
            .collect(joining("\n"));
}

/// Format class to generate glossary information.
private String formatGlossary(Class<?> classToDocument) {
    return classToDocument.getSimpleName() + "::" + getDescription(classToDocument);
}

private String getDescription(Class<?> classToDocument) {
    JavaClass javaClass = builder.getClassByName(classToDocument.getCanonicalName());
    return " " + Optional.ofNullable(javaClass.getComment()).orElse("");
}

public String generateGitMessages() throws IOException, GitAPIException {
    Repository repository = new FileRepositoryBuilder()
            .setGitDir(gitPath.toFile())
            .setMustExist(true)
            .build();

    Iterable<RevCommit> logs = new Git(repository).log().call();

    return StreamSupport.stream(logs.spliterator(), false)
            .limit(10)
            .map(rev -> formatMessage(rev, "dd/MM/yyyy"))
            .collect(Collectors.joining("\n"));
}

public String formatMessage(RevCommit rev, String dateFormat) {
    Date authorDate = rev.getAuthorIdent().getWhen();

    String dateFormatted = new SimpleDateFormat(dateFormat).format(authorDate);
    return String.format("* *%s* (%s): %s",
            dateFormatted,
            rev.getName().substring(0, 10),
            rev.getShortMessage());
}

public String generateDendencies()
        throws IOException, SAXException {

    Path PROJECT_PATH = Path.of("src", "main", "resources", "project");
    List<String> modules = getModules(PROJECT_PATH);

    String dependenciesGraph = modules.stream()
            .flatMap(module -> findDependencies(PROJECT_PATH.resolve(module)).stream()
                    .map(dependency -> String.format("\"%s\" -> \"%s\"", module, dependency))
            )
            .collect(Collectors.joining("\n"));

    return String.join("\n",
            "",
            "[graphviz]",
            "----",
            "digraph g {",
            dependenciesGraph,
            "}",
            "----");
}

private List<String> findDependencies(Path path) {

    List<String> recorder = executeCommand(path, List.of("mvn", "dependency:list"));

    return recorder.stream()
            .map(s -> s.replaceFirst("^\\[INFO\\]", ""))
            .map(String::trim)
            .filter(isADependencyLine())
            .map(this::extractArtifact)
            .collect(Collectors.toList());
}

private List<String> getModules(Path path) {
    return Arrays.stream(path.toFile().listFiles(java.io.File::isDirectory))
            .filter(f -> Paths.get(f.getPath(), "pom.xml").toFile().exists())
            .map(java.io.File::getName)
            .collect(Collectors.toList());
}

public String generateDoc(Object instance) {
    return String.format("Default values of %s class\n\n", instance.getClass().getSimpleName())
            + String.format("[options=\"header\"]\n|===\n|Field|Default value\n%s\n|===\n",
                Arrays.stream(Configuration.class.getDeclaredMethods())
                    .filter(this::isGetter)
                    .map(m -> formatRow(instance, m))
                    .collect(Collectors.joining("\n")));
}

private String formatRow(Object instance, Method method) {
    try {
        return String.format("|%s|%s", method.getName(), method.invoke(instance));

    } catch (IllegalAccessException | InvocationTargetException e) {
        return "Value could not be retrieve";
    }
}

private boolean isGetter(Method m) {
    return (m.getName().startsWith("get") || m.getName().startsWith("is"))
            && Modifier.isPublic(m.getModifiers());
}

public String generateCallFlow() throws Error {

    final TraceAnswer recordCalls = new TraceAnswer();
    final Notifier notifier = spyWithTracer(new NotifierImpl(), recordCalls);
    final Dao dao = spyWithTracer(new DaoImpl(notifier), recordCalls);

    // Call method to trace
    final Service service = new Service(dao, notifier);
    service.findHomonyms(5);

    return String.join("\n",
                    "",
                    ".Calls from Service.findHomonyms method",
                    "[plantuml]",
                    "----",
                    recordCalls.linksPlantUml.stream()
                            .collect(Collectors.joining("\n")),
                    "----");
}

/**
 * Create a spy over a object to trace every methods called.
 * @param instance
 * @param recordCalls
 * @param <T>
 * @return
 */
private <T> T spyWithTracer(T instance, TraceAnswer recordCalls) {
    return Mockito.mock((Class<T>) instance.getClass(),
            Mockito.withSettings()
                    .spiedInstance(instance)
                    .defaultAnswer(recordCalls));
}

    public String generateWorkflowGraph() throws Error {

        final Workflow workflow = new Workflow();

        return String.join("\n",
                "",
                "[graphviz]",
                "----",
                "digraph g {",
                Arrays.stream(Workflow.State.values())
                        .flatMap(state -> formatStateLinks(workflow, state))
                        .collect(Collectors.joining("\n")),
                "",
                "}",
                "----");
    }

    private Stream<String> formatStateLinks(Workflow workflow, Workflow.State currentState) {
        return workflow.availableTransition(currentState).stream()
                .map(availableState -> currentState + " -> " + availableState);
    }

/**
 * Class in application that defined workflow.
 */
class Workflow {

    public enum State {
        OPEN, RESOLVED, IN_PROGRESS, CLOSED, REOPENED;
    }

    public List<State> availableTransition(State state) {

        switch (state) {
            case OPEN:
                return Arrays.asList(RESOLVED, IN_PROGRESS, CLOSED);
            case RESOLVED:
                return Arrays.asList(REOPENED, CLOSED);
            case CLOSED:
                return Arrays.asList();
            case IN_PROGRESS:
                return Arrays.asList(OPEN, RESOLVED);
            case REOPENED:
                return Arrays.asList(CLOSED, IN_PROGRESS);
            default:
                return Arrays.asList();

        }
    }
}

public String generateWorkflowGraph() throws Error {

    final Workflow workflow = new Workflow();

    final DotGraph graph = new DotGraph("");
    final DotGraph.Digraph digraph = graph.getDigraph();
    Arrays.asList(Workflow.State.values()).forEach(state -> addStateTransitions(digraph, workflow, state));

    return String.join("\n",
            "",
            "[graphviz]",
            "----",
            graph.render(),
            "----");
}

private void addStateTransitions(DotGraph.Digraph digraph, Workflow workflow, Workflow.State currentState) {
    digraph.addNode(currentState.name()).setLabel(currentState.name());
    workflow.availableTransition(currentState)
            .forEach(availableState -> digraph.addAssociation(currentState.name(), availableState.name()));
}

public String generateDoc() {
    Class<?> classToDocument = ClassToDocument.class;

    // Parse class source code.
    SourceRoot sourceRoot = new SourceRoot(Paths.get("src/main/java"));
    CompilationUnit cu = sourceRoot.parse(
            classToDocument.getPackage().getName(),
            classToDocument.getSimpleName() + ".java");

    // Visit code tree to retrieve javadoc.
    JavadocVisitorAdapter javadocVisitor = new JavadocVisitorAdapter();
    cu.accept(javadocVisitor, null);

    // Format result to create documentation.
    return String.join("\n",
            formatClass(javadocVisitor.javaDocOfClasses),
            "",
            javadocVisitor.javaDocOfMethods.stream()
                    .map(this::formatMethod)
                    .collect(Collectors.joining()));
}

/// Visitor to store class and methods javadoc.
public static class JavadocVisitorAdapter extends GenericVisitorAdapter<Object, Void> {

    JavaDocOfElement javaDocOfClasses;
    List<JavaDocOfElement> javaDocOfMethods = new ArrayList<>();

    @Override
    public Object visit(ClassOrInterfaceDeclaration declaration, Void arg) {
        String className = declaration.getFullyQualifiedName().orElse(null);
        javaDocOfClasses =
                new JavaDocOfElement(className, declaration.getComment());
        return super.visit(declaration, arg);
    }

    @Override
    public Object visit(MethodDeclaration declaration, Void arg) {
        javaDocOfMethods.add(
                new JavaDocOfElement(declaration.getNameAsString(), declaration.getComment())
        );
        return super.visit(declaration, arg);
    }
}

public String generateDoc() {
    JavaProjectBuilder builder = new JavaProjectBuilder();
    builder.addSourceTree(new File("src/main/java"));

    JavaClass javaClass = builder.getClassByName(classToDocument.getCanonicalName());

    return String.format("%s: \n%s\n\n%s",
            javaClass.getName(),
            javaClass.getComment(),
            methodList(javaClass));
}

private static String methodList(JavaClass javaClass) {
    return javaClass.getMethods().stream()
            .map(javaMethod -> String.format("- %s: %s",
                    javaMethod.getName(),
                    javaMethod.getComment()))
            .collect(Collectors.joining("\n"));
}

public FindMainDoc() {
    builder = new JavaProjectBuilder();
    builder.addSourceTree(new File("src/main/java"));
}

public String generate() {
    return new Reflections("org.dojo.livingdoc", new SubTypesScanner(false))
            .getSubTypesOf(Object.class).stream()
            .filter(this::isContainMainMethod)
            .map(o -> o.getSimpleName())
            .collect(joining("\n* ", "* ", ""));
}

private boolean isContainMainMethod(Class<?> aClass) {
    return Arrays.stream(aClass.getDeclaredMethods())
            .anyMatch(m -> Modifier.isStatic(m.getModifiers())
                        && m.getName().equals("main")
            );
}

/**
 *  stem:[(1.55^"level") + sqrt(12*"level") + 50]
 */
public double xpNeedsToNextLevel(int level) {
    return Math.pow(1.55, level) + Math.sqrt(12*level) + 50;
}

public static String fromJava(String javaFormula) {
    return new FormulaAsciiMath().parse(javaFormula);
}

private String parse(String javaFormula) {
    final Provider codeProvider = Providers.provider("class X { String formula = " + javaFormula + " }");
    ParseResult<CompilationUnit> result = (new JavaParser()).parse(ParseStart.COMPILATION_UNIT, codeProvider);
    if (!result.isSuccessful()) {
        throw new RuntimeException(result.getProblems().stream()
                .map(problem -> problem.getVerboseMessage())
                .collect(Collectors.joining("\n")));
    }

    final CompilationUnit compilationUnit = result.getResult().get();

    final FormulaVisitor formulaVisitor = new FormulaVisitor();
    Stack<String> stack = new Stack<>();
    compilationUnit.accept(formulaVisitor, stack);

    return  stack.peek();
}

public static class FormulaVisitor extends VoidVisitorAdapter<Stack<String>> {

    @Override
    public void visit(IntegerLiteralExpr n, Stack<String> arg) {
        super.visit(n, arg);
        arg.push(n.getValue());
    }

    @Override
    public void visit(DoubleLiteralExpr n, Stack<String> arg) {
        super.visit(n, arg);
        arg.push(n.getValue());
    }

    @Override
    public void visit(BinaryExpr n, Stack<String> arg) {
        n.getLeft().accept(this, arg);
        String left = arg.pop();
        n.getRight().accept(this, arg);
        String right = arg.pop();
        arg.push(left + n.getOperator().asString() + right);
    }

    @Override
    public void visit(NameExpr n, Stack<String> arg) {
        super.visit(n, arg);
        arg.push("\"" + n.getNameAsString() + "\"");
    }

    @Override
    public void visit(MethodCallExpr n, Stack<String> arg) {

        for (Expression expression : n.getArguments()) {
            expression.accept(this, arg);
        }

        final String mathFunction = n.getName().asString();

        if ("pow".equals(mathFunction)) {
            String exponent = arg.pop();
            String base = arg.pop();
            arg.push("(" + base + "^" + exponent + ")");

        } else  if ("sqrt".equals(mathFunction)) {
            String value = arg.pop();
            arg.push(mathFunction + "(" + value + ")");

        } else {
            throw new RuntimeException("Function '"+mathFunction+"' not supported");
        }
    }
}

public FormulaDoc() {
    builder = new JavaProjectBuilder();
    builder.addSourceTree(new File("src/main/java"));
}

public String generateFormulaFromJavaDoc() {
    JavaProjectBuilder builder = new JavaProjectBuilder();
    builder.addSourceTree(new File("src/main/java"));

    JavaClass javaClass = builder.getClassByName(SpecificRule.class.getName());
    final List<JavaMethod> methods = javaClass.getMethods();

    return methods.stream()
            .map(method -> method.getName() + ": " + method.getComment())
            .collect(Collectors.joining("\n"));

}

public String generateFormulaParsingCode() {
    final Class classWithFormula = SpecificRule.class;
    final String methodWithFormula = "xpNeedsToNextLevel";

    String javaCode = extractMethodBody(classWithFormula, methodWithFormula);
    String formulaCode = javaCode.replaceAll("^\\{\\s*return (.*)\\s*\\}$", "$1");

    return methodWithFormula + ": stem:[" + FormulaAsciiMath.fromJava(formulaCode) + "]";

}

private String extractMethodBody(Class classWithFormula, String methodWithFormula) {
    SourceRoot sourceRoot = new SourceRoot(Paths.get("src/main/java"));

    CompilationUnit cu = sourceRoot.parse(
            classWithFormula.getPackage().getName(),
            classWithFormula.getSimpleName() + ".java");

    StringBuffer javaCode = new StringBuffer();
    cu.accept(new VoidVisitorAdapter<StringBuffer>() {
        @Override
        public void visit(MethodDeclaration n, StringBuffer arg) {
            if (methodWithFormula.equals(n.getNameAsString())) {
                final String str = n.getBody()
                        .map(body -> body.toString())
                        .orElse("");
                System.out.println("BODY:" + str);
                javaCode.append(str);

            }
        }
    }, null);
    return javaCode.toString();
}

// tag::InterestingCode[]
public void doNothing() {
// Really interesting code.
}
// end::InterestingCode[]

public String includeCodeToDoc() {
    return String.join("\n",
            "[source,java,indent=0]",
            ".Best practice to follow",
            "----",
            "include::{sourcedir}/org/dojo/livingdoc/application/TechnicalStuff.java[tags=InterestingCode]",
            "----");
}

public String execute() throws Error {

    final Reflections reflections = new Reflections("org.dojo.livingdoc");
    Set<Class<?>> typesAnnotatedWith =
            reflections.getTypesAnnotatedWith(ClassDemo.class, false);

    SourceRoot sourceRoot = new SourceRoot(Paths.get("src/main/java"));

    return getImports(typesAnnotatedWith, sourceRoot)
            .limit(3)
            .collect(Collectors.joining("\n", "", "\n* ..."));

}

private Stream<String> getImports(Set<Class<?>> typesAnnotatedWith, SourceRoot sourceRoot) {

    return typesAnnotatedWith.stream().map(aClass -> {

        CompilationUnit cu = sourceRoot.parse(
                aClass.getPackage().getName(),
                aClass.getSimpleName() + ".java");

        List<String> imports = new ArrayList();
        cu.accept(new RecordImportsVisitor(), imports);

        return (String.format("* %s\n%s",
                aClass.getSimpleName(),
                imports.stream()
                        .distinct()
                        .filter(importName -> !importName.startsWith("java"))
                        .map(s -> "** " + s)
                        .collect(Collectors.joining("\n"))));
    });
}

/// Visitor that record imports
class RecordImportsVisitor extends GenericVisitorAdapter<Object, List<String>> {
    @Override
    public Object visit(ImportDeclaration declaration, List<String> imports) {

        imports.add(extractPackageFromImport(declaration, imports));
        return super.visit(declaration, imports);
    }
}

public String generatePomDescription()
        throws ParserConfigurationException, IOException, SAXException {

    Element root = parsePom().getDocumentElement();

    return root.getElementsByTagName("description").item(0).getTextContent();

}

private static Document parsePom()
        throws ParserConfigurationException, SAXException, IOException {

    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    DocumentBuilder builder = factory.newDocumentBuilder();

    return builder.parse(new File("pom.xml"));
}