z2-Environment

/*

 * z2-Environment

 * 

 * Copyright(c) ZFabrik Software KG

 * 

 * contact@zfabrik.de

 * 

 * http://www.z2-environment.eu

 */

package com.zfabrik.impl.javadoc;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileFilter;

import java.io.FileWriter;

import java.io.IOException;

import java.lang.reflect.Method;

import java.net.URL;

import java.net.URLClassLoader;

import java.util.HashSet;

import java.util.LinkedList;

import java.util.List;

import java.util.Set;

import java.util.StringTokenizer;

import java.util.logging.Logger;

import com.zfabrik.components.IComponentDescriptor;

import com.zfabrik.components.IComponentsLookup;

import com.zfabrik.components.IComponentsManager;

import com.zfabrik.components.java.IJavaComponent;

import com.zfabrik.components.java.JavaComponentUtil;

import com.zfabrik.components.provider.util.LockingRevFile;

import com.zfabrik.util.fs.FileUtils;

import com.zfabrik.util.html.Escaper;

public class ComponentJavaDoc {

	public final static short TYPE_API  = 1;

	public final static short TYPE_IMPL = 2;

	public final static short TYPE_BOTH = 3;

	private static final FileFilter FOLDER_OR_JAVA_AND_NOT_HIDDEN = new FileFilter() {

		public boolean accept(File pathname) {

			return (pathname.isDirectory() || pathname.getName().endsWith(".java")) && !pathname.getName().startsWith(".");

		}

	};

	private static final String IMPLEMENTATION_VERSION = "11";

	private static class InvokeContext {

		ClassLoader cl;

		Method		m;

	}

	private short type;

	private String component;

	private boolean resolved;

	private File root;

	public ComponentJavaDoc(String component,short type) {

		super();

		this.type = type;

		this.component = component;

	}

	public File getRootFolder() {

		this.resolve();

		return this.root;

	}

	private File resolve() {

		if (!this.resolved) {

			this.resolved = true;

			this.root = getJavaDoc(this.component,this.type);

		}

		return this.root;

	}

	private static File getJavaDocFolderInComponentFolder(File cf, short type) {

		switch (type) {

		case TYPE_IMPL:

			return new File(cf,"gen/doc.impl");

		case TYPE_API:

			return new File(cf,"gen/doc.api");

		case TYPE_BOTH:

			return new File(cf,"gen/doc.both");

		}

		throw new IllegalArgumentException();

	}

	private static synchronized File getJavaDoc(String component, short type)  {

		try {

			// need to check.

			// rely on the java components logic. Look it up as Java Component to

			// force compilation check

			IJavaComponent jc = IComponentsLookup.INSTANCE.lookup(component, IJavaComponent.class);

			if (jc!=null) {

				IComponentDescriptor desc = IComponentsManager.INSTANCE.getComponent(component);

				File croot = IComponentsManager.INSTANCE.retrieve(component);

				File jdoc  = getJavaDocFolderInComponentFolder(croot, type);

				if (Boolean.parseBoolean(desc.getProperty(IJavaComponent.NOBUILD))) {

					// no jdoc gen for no build components

					if (jdoc.exists()) {

						return jdoc;

					}

					return null;

				} else {

					// check revision

					String revfile = "doc_"+qualifier(type)+".rev";

					LockingRevFile lrf = new LockingRevFile(new File(croot,revfile));

					lrf.open();

					try {

						if (jdoc.exists() && IMPLEMENTATION_VERSION.equals(lrf.properties().get("v"))) {

							// javadocs exist, no build component or right version 

							return jdoc;

						} else {

							logger.info("Updating Javadoc for component "+component+" ("+qualifier(type)+")");

							// no jdocs or wrong implementation version

							// must generate javadocs

							// check javadoc tool

							InvokeContext ic = getTool();

							if (ic==null) {

								return null;

							}

							// compute params

							List<String> params = new LinkedList<String>();

							List<File> files = new LinkedList<File>();

							// 1. source paths and packages

							List<File> fs = new LinkedList<File>();

							if ((type & TYPE_IMPL)!= 0) {

								File sf = new File(croot,"src.impl");

								if (sf.exists()) {

									fs.add(sf);

								}

							} 

							if ((type & TYPE_API)!= 0) {

								File sf = new File(croot,"src.api");

								if (sf.exists()) {

									fs.add(sf);

								}

							}

							if (!fs.isEmpty()) {

								// 1a. ok, there is something to do

								StringBuilder sourcepath = new StringBuilder(200);

								for (File f : fs) {

									// add as source path and

									// list all packages

									int l = files.size();

									addSourceFiles(files,f);

									if (l<files.size()) {

										sourcepath.append((sourcepath.length()>0? File.pathSeparator:"")).append(f.getCanonicalPath());

									}

								}

								params.add("-sourcepath");

								params.add(sourcepath.toString());

								// 2. deps translate to -linkoffline relations

								addLinks(component, new HashSet<String>(), params, type, true);							

								params.add("-link");

								params.add("http://download.oracle.com/javase/6/docs/api");

								// 3. class path

								StringBuilder classpath = new StringBuilder(200);

								// add the classpath

								addToPath(classpath, ((type & TYPE_IMPL)!=0? jc.getPrivateLoader().getURLs() : jc.getPublicLoader().getURLs()));

								params.add("-classpath");

								params.add(classpath.toString());

								// 4. outpath

								FileUtils.delete(jdoc);

								jdoc.mkdirs();

								params.add("-d");

								params.add(jdoc.getCanonicalPath());

								if (!files.isEmpty()) {

									// 5. add files to generate javadoc for

									File fileList = File.createTempFile("javadoc_",".lst");

									BufferedWriter w = new BufferedWriter(new FileWriter(fileList));

									try {

										for (File sf : files) {

											w.write(sf.getAbsolutePath());

											w.newLine();

										}

									} finally {

										w.close();

									}

									params.add("@"+fileList.getAbsolutePath());

									try {

										// 6. and GO!

										logger.info("Running Javadoc command with command line: "+params);

										ClassLoader ol = Thread.currentThread().getContextClassLoader();

										Thread.currentThread().setContextClassLoader(ic.cl);

										try {

											int rc = (Integer) ic.m.invoke(null, new Object[]{params.toArray(new String[params.size()])});

											if (rc==0 && !empty(jdoc)) {

												// done

												lrf.properties().setProperty("v", IMPLEMENTATION_VERSION);

												lrf.update();

												return jdoc;

											}

										} finally {

											Thread.currentThread().setContextClassLoader(ol);

										}

									} finally {

										fileList.delete();

									}

								} else {

									logger.info("Found no packages: Nothing to do");

								}

							} 

						}

					} finally {

						lrf.close();

					}

				}

			}

		} catch (Exception e) {

			throw new RuntimeException("Javadoc generation failed",e);

		}

		return null;

	}

	private static String qualifier(short type) {

		return type==TYPE_IMPL?"impl":type==TYPE_API?"api":"both";

	}

	private static void addToPath(StringBuilder classpath, URL[] urls) {

		if (urls!=null) {

			for (URL u : urls) {

				if (classpath.length()>0) {

					classpath.append(File.pathSeparator);

				}

				classpath.append(u.getPath());

			}

		}

	}

	private static boolean empty(File tf) {

		return (!tf.isDirectory() || tf.list().length==0);

	}

	//

	// find the actual javadoc implementation 

	//

	private static InvokeContext getTool() throws Exception {

		String jhs = System.getenv("JAVA_HOME");

		if (jhs==null) {

			jhs = System.getProperty("java.home");

			if (jhs.endsWith("/jre")) {

				// try one level up

				jhs = jhs.substring(0,jhs.length()-4);

			}

		}

		File jh = new File(jhs);

		File tj = new File(jh,"lib/tools.jar");

		ClassLoader cl = ComponentJavaDoc.class.getClassLoader();

		if (!tj.exists()) {

			logger.warning("Library tools.jar not found at "+tj.getCanonicalPath()+" will try to load Javadoc tool directly");

		} else {

			cl = new URLClassLoader(new URL[]{tj.toURI().toURL()}, cl);

		}

		try {

			Class<?> jdclz = Class.forName("com.sun.tools.javadoc.Main",false,cl);

			InvokeContext r = new InvokeContext();

			r.cl = cl;

			r.m=jdclz.getMethod("execute",String[].class);

			return r;

		} catch (Exception e) {

			logger.warning("Failed to load JavaDoc tool class (are you running a JDK?) - cannot update javadocs ("+e+")");

			return null;

		}

	}

	//

	// recursively find package names in a folder hierarchy

	//

	private static void addSourceFiles(List<File> files, File f) {

		for (File g : f.listFiles(FOLDER_OR_JAVA_AND_NOT_HIDDEN)) {

			if (g.isDirectory()) {

				addSourceFiles(files,g);

			} else {

				files.add(g);

			}

		}

	}

	//

	// add external refs as link params following the 

	// java refs

	//

	private static void addLinks(String component, Set<String> traversed, List<String> params, short type, boolean start) throws IOException {

		component = JavaComponentUtil.fixJavaComponentName(component);

		if (traversed.contains(component+"@"+type)) {

			// already traversed.

			return;

		}

		traversed.add(component+"@"+type);

		IComponentDescriptor desc = IComponentsManager.INSTANCE.getComponent(component);

		if (desc==null) {

			return;

		}

		// deps 

		addAllLinks(traversed, params, desc.getProperty(IJavaComponent.PUBREFS));

		if (start && (type&TYPE_IMPL)!=0) {

			// add private references

			addAllLinks(traversed, params, desc.getProperty(IJavaComponent.PRIREFS));

			// add our own API

			addLinks(component, traversed, params, TYPE_API,false);

		}

		if (start) {

			// at start of recursion add the always present core api

			// add the core api

			addLinks("com.zfabrik.core.api",traversed,params,TYPE_API,false);

		} else {

			// otherwise add the actual API

			File f = getJavaDoc(component, TYPE_API);

			if (f!=null) {

				params.add("-linkoffline");

				params.add("/javadoc/"+Escaper.urlEncode(component,'!')+"/api");

				params.add(f.toURI().toString());

			}

		}

	}

	private static void addAllLinks(Set<String> traversed, List<String> params,String refs) throws IOException {

		if (refs!=null) {

			StringTokenizer tk = new StringTokenizer(refs);

			while (tk.hasMoreTokens()) {

				addLinks(tk.nextToken().trim(), traversed, params, TYPE_API,false);

			}

		}

	}

	private final static Logger logger = Logger.getLogger(ComponentJavaDoc.class.getName());

}