tools/idegen/src/Configuration.java - platform/development - Git at Google

 /*
  * Copyright (C) 2008 The Android Open Source Project
  *
  * 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.
  */

 import java.io.File;
 import java.io.IOException;
 import java.io.BufferedReader;
 import java.io.FileReader;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.SortedSet;
 import java.util.regex.Pattern;

 /**
  * Immutable representation of an IDE configuration. Assumes that the current
  * directory is the project's root directory.
  */
 public class Configuration {

     /** Java source tree roots. */
     public final SortedSet<File> sourceRoots;

     /** Found .jar files (that weren't excluded). */
     public final List<File> jarFiles;

     /** Excluded directories which may or may not be under a source root. */
     public final SortedSet<File> excludedDirs;

     /** The root directory for this tool. */
     public final File toolDirectory;

     /** File name used for excluded path files. */
     private static final String EXCLUDED_PATHS = "excluded-paths";

     /**
      * Constructs a Configuration by traversing the directory tree, looking
      * for .java and .jar files and identifying source roots.
      */
     public Configuration() throws IOException {
         this.toolDirectory = new File("development/tools/idegen");
         if (!toolDirectory.isDirectory()) {
             // The wrapper script should have already verified this.
             throw new AssertionError("Not in root directory.");
         }

         Stopwatch stopwatch = new Stopwatch();

         Excludes excludes = readExcludes();

         stopwatch.reset("Read excludes");

         List<File> jarFiles = new ArrayList<File>(500);
         SortedSet<File> excludedDirs = new TreeSet<File>();
         SortedSet<File> sourceRoots = new TreeSet<File>();

         traverse(new File("."), sourceRoots, jarFiles, excludedDirs, excludes);

         stopwatch.reset("Traversed tree");

         Log.debug(sourceRoots.size() + " source roots");
         Log.debug(jarFiles.size() + " jar files");
         Log.debug(excludedDirs.size() + " excluded dirs");

         this.sourceRoots = Collections.unmodifiableSortedSet(sourceRoots);
         this.jarFiles = Collections.unmodifiableList(jarFiles);
         this.excludedDirs = Collections.unmodifiableSortedSet(excludedDirs);
     }

     /**
      * Reads excluded path files.
      */
     private Excludes readExcludes() throws IOException {
         List<Pattern> patterns = new ArrayList<Pattern>();

         File globalExcludes = new File(toolDirectory, EXCLUDED_PATHS);
         parseFile(globalExcludes, patterns);

         // Look for Google-specific excludes.
         // TODO: Traverse all vendor-specific directories.
         File googleExcludes = new File("./vendor/google/" + EXCLUDED_PATHS);
         if (googleExcludes.exists()) {
             parseFile(googleExcludes, patterns);
         }

         // Look for user-specific excluded-paths file in current directory.
         File localExcludes = new File(EXCLUDED_PATHS);
         if (localExcludes.exists()) {
             parseFile(localExcludes, patterns);
         }

         return new Excludes(patterns);
     }

     /**
      * Recursively finds .java source roots, .jar files, and excluded
      * directories.
      */
     private static void traverse(File directory, Set<File> sourceRoots,
             Collection<File> jarFiles, Collection<File> excludedDirs,
             Excludes excludes) throws IOException {
         /*
          * Note it would be faster to stop traversing a source root as soon as
          * we encounter the first .java file, but it appears we have nested
          * source roots in our generated source directory (specifically,
          * R.java files and aidl .java files don't share the same source
          * root).
          */

         boolean firstJavaFile = true;
 	File[] files = directory.listFiles();
 	if (files == null) {
 	    return;
 	}
         for (File file : files) {
             // Trim preceding "./" from path.
             String path = file.getPath().substring(2);

             // Keep track of source roots for .java files.
             if (path.endsWith(".java")) {
                 if (firstJavaFile) {
                     // Only parse one .java file per directory.
                     firstJavaFile = false;

                     File sourceRoot = rootOf(file);
                     if (sourceRoot != null) {
                         sourceRoots.add(sourceRoot);
                     }
                 }

                 continue;
             }

             // Keep track of .jar files.
             if (path.endsWith(".jar")) {
                 if (!excludes.exclude(path)) {
                     jarFiles.add(file);
                 } else {
                     Log.debug("Skipped: " + file);
                 }

                 continue;
             }

             // Traverse nested directories.
             if (file.isDirectory()) {
                 if (excludes.exclude(path)) {
                     // Don't recurse into excluded dirs.
                     Log.debug("Excluding: " + path);
                     excludedDirs.add(file);
                 } else {
                     traverse(file, sourceRoots, jarFiles, excludedDirs,
                             excludes);
                 }
             }
         }
     }

     /**
      * Determines the source root for a given .java file. Returns null
      * if the file doesn't have a package or if the file isn't in the
      * correct directory structure.
      */
     private static File rootOf(File javaFile) throws IOException {
         String packageName = parsePackageName(javaFile);
         if (packageName == null) {
             // No package.
             // TODO: Treat this as a source root?
             return null;
         }

         String packagePath = packageName.replace('.', File.separatorChar);
         File parent = javaFile.getParentFile();
         String parentPath = parent.getPath();
         if (!parentPath.endsWith(packagePath)) {
             // Bad dir structure.
             return null;
         }

         return new File(parentPath.substring(
                 0, parentPath.length() - packagePath.length()));
     }

     /**
      * Reads a Java file and parses out the package name. Returns null if none
      * found.
      */
     private static String parsePackageName(File file) throws IOException {
         BufferedReader in = new BufferedReader(new FileReader(file));
         try {
             String line;
             while ((line = in.readLine()) != null) {
                 String trimmed = line.trim();
                 if (trimmed.startsWith("package")) {
                     // TODO: Make this more robust.
                     // Assumes there's only once space after "package" and the
                     // line ends in a ";".
                     return trimmed.substring(8, trimmed.length() - 1);
                 }
             }

             return null;
         } finally {
             in.close();
         }
     }

     /**
      * Picks out excluded directories that are under source roots.
      */
     public SortedSet<File> excludesUnderSourceRoots() {
         // TODO: Refactor this to share the similar logic in
         // Eclipse.constructExcluding().
         SortedSet<File> picked = new TreeSet<File>();
         for (File sourceRoot : sourceRoots) {
             String sourcePath = sourceRoot.getPath() + "/";
             SortedSet<File> tailSet = excludedDirs.tailSet(sourceRoot);
             for (File file : tailSet) {
                 if (file.getPath().startsWith(sourcePath)) {
                     picked.add(file);
                 } else {
                     break;
                 }
             }
         }
         return picked;
     }

     /**
      * Reads a list of regular expressions from a file, one per line, and adds
      * the compiled patterns to the given collection. Ignores lines starting
      * with '#'.
      *
      * @param file containing regular expressions, one per line
      * @param patterns collection to add compiled patterns from file to
      */
     public static void parseFile(File file, Collection<Pattern> patterns)
             throws IOException {
         BufferedReader in = new BufferedReader(new FileReader(file));
         try {
             String line;
             while ((line = in.readLine()) != null) {
                 String trimmed = line.trim();
                 if (trimmed.length() > 0 && !trimmed.startsWith("#")) {
                     patterns.add(Pattern.compile(trimmed));
                 }
             }
         } finally {
             in.close();
         }
     }
 }
	/*
	* Copyright (C) 2008 The Android Open Source Project
	*
	* 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.
	*/

	import java.io.File;
	import java.io.IOException;
	import java.io.BufferedReader;
	import java.io.FileReader;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.List;
	import java.util.Set;
	import java.util.TreeSet;
	import java.util.SortedSet;
	import java.util.regex.Pattern;

	/**
	* Immutable representation of an IDE configuration. Assumes that the current
	* directory is the project's root directory.
	*/
	public class Configuration {

	/** Java source tree roots. */
	public final SortedSet<File> sourceRoots;

	/** Found .jar files (that weren't excluded). */
	public final List<File> jarFiles;

	/** Excluded directories which may or may not be under a source root. */
	public final SortedSet<File> excludedDirs;

	/** The root directory for this tool. */
	public final File toolDirectory;

	/** File name used for excluded path files. */
	private static final String EXCLUDED_PATHS = "excluded-paths";

	/**
	* Constructs a Configuration by traversing the directory tree, looking
	* for .java and .jar files and identifying source roots.
	*/
	public Configuration() throws IOException {
	this.toolDirectory = new File("development/tools/idegen");
	if (!toolDirectory.isDirectory()) {
	// The wrapper script should have already verified this.
	throw new AssertionError("Not in root directory.");
	}

	Stopwatch stopwatch = new Stopwatch();

	Excludes excludes = readExcludes();

	stopwatch.reset("Read excludes");

	List<File> jarFiles = new ArrayList<File>(500);
	SortedSet<File> excludedDirs = new TreeSet<File>();
	SortedSet<File> sourceRoots = new TreeSet<File>();

	traverse(new File("."), sourceRoots, jarFiles, excludedDirs, excludes);

	stopwatch.reset("Traversed tree");

	Log.debug(sourceRoots.size() + " source roots");
	Log.debug(jarFiles.size() + " jar files");
	Log.debug(excludedDirs.size() + " excluded dirs");

	this.sourceRoots = Collections.unmodifiableSortedSet(sourceRoots);
	this.jarFiles = Collections.unmodifiableList(jarFiles);
	this.excludedDirs = Collections.unmodifiableSortedSet(excludedDirs);
	}

	/**
	* Reads excluded path files.
	*/
	private Excludes readExcludes() throws IOException {
	List<Pattern> patterns = new ArrayList<Pattern>();

	File globalExcludes = new File(toolDirectory, EXCLUDED_PATHS);
	parseFile(globalExcludes, patterns);

	// Look for Google-specific excludes.
	// TODO: Traverse all vendor-specific directories.
	File googleExcludes = new File("./vendor/google/" + EXCLUDED_PATHS);
	if (googleExcludes.exists()) {
	parseFile(googleExcludes, patterns);
	}

	// Look for user-specific excluded-paths file in current directory.
	File localExcludes = new File(EXCLUDED_PATHS);
	if (localExcludes.exists()) {
	parseFile(localExcludes, patterns);
	}

	return new Excludes(patterns);
	}

	/**
	* Recursively finds .java source roots, .jar files, and excluded
	* directories.
	*/
	private static void traverse(File directory, Set<File> sourceRoots,
	Collection<File> jarFiles, Collection<File> excludedDirs,
	Excludes excludes) throws IOException {
	/*
	* Note it would be faster to stop traversing a source root as soon as
	* we encounter the first .java file, but it appears we have nested
	* source roots in our generated source directory (specifically,
	* R.java files and aidl .java files don't share the same source
	* root).
	*/

	boolean firstJavaFile = true;
	File[] files = directory.listFiles();
	if (files == null) {
	return;
	}
	for (File file : files) {
	// Trim preceding "./" from path.
	String path = file.getPath().substring(2);

	// Keep track of source roots for .java files.
	if (path.endsWith(".java")) {
	if (firstJavaFile) {
	// Only parse one .java file per directory.
	firstJavaFile = false;

	File sourceRoot = rootOf(file);
	if (sourceRoot != null) {
	sourceRoots.add(sourceRoot);
	}
	}

	continue;
	}

	// Keep track of .jar files.
	if (path.endsWith(".jar")) {
	if (!excludes.exclude(path)) {
	jarFiles.add(file);
	} else {
	Log.debug("Skipped: " + file);
	}

	continue;
	}

	// Traverse nested directories.
	if (file.isDirectory()) {
	if (excludes.exclude(path)) {
	// Don't recurse into excluded dirs.
	Log.debug("Excluding: " + path);
	excludedDirs.add(file);
	} else {
	traverse(file, sourceRoots, jarFiles, excludedDirs,
	excludes);
	}
	}
	}
	}

	/**
	* Determines the source root for a given .java file. Returns null
	* if the file doesn't have a package or if the file isn't in the
	* correct directory structure.
	*/
	private static File rootOf(File javaFile) throws IOException {
	String packageName = parsePackageName(javaFile);
	if (packageName == null) {
	// No package.
	// TODO: Treat this as a source root?
	return null;
	}

	String packagePath = packageName.replace('.', File.separatorChar);
	File parent = javaFile.getParentFile();
	String parentPath = parent.getPath();
	if (!parentPath.endsWith(packagePath)) {
	// Bad dir structure.
	return null;
	}

	return new File(parentPath.substring(
	0, parentPath.length() - packagePath.length()));
	}

	/**
	* Reads a Java file and parses out the package name. Returns null if none
	* found.
	*/
	private static String parsePackageName(File file) throws IOException {
	BufferedReader in = new BufferedReader(new FileReader(file));
	try {
	String line;
	while ((line = in.readLine()) != null) {
	String trimmed = line.trim();
	if (trimmed.startsWith("package")) {
	// TODO: Make this more robust.
	// Assumes there's only once space after "package" and the
	// line ends in a ";".
	return trimmed.substring(8, trimmed.length() - 1);
	}
	}

	return null;
	} finally {
	in.close();
	}
	}

	/**
	* Picks out excluded directories that are under source roots.
	*/
	public SortedSet<File> excludesUnderSourceRoots() {
	// TODO: Refactor this to share the similar logic in
	// Eclipse.constructExcluding().
	SortedSet<File> picked = new TreeSet<File>();
	for (File sourceRoot : sourceRoots) {
	String sourcePath = sourceRoot.getPath() + "/";
	SortedSet<File> tailSet = excludedDirs.tailSet(sourceRoot);
	for (File file : tailSet) {
	if (file.getPath().startsWith(sourcePath)) {
	picked.add(file);
	} else {
	break;
	}
	}
	}
	return picked;
	}

	/**
	* Reads a list of regular expressions from a file, one per line, and adds
	* the compiled patterns to the given collection. Ignores lines starting
	* with '#'.
	*
	* @param file containing regular expressions, one per line
	* @param patterns collection to add compiled patterns from file to
	*/
	public static void parseFile(File file, Collection<Pattern> patterns)
	throws IOException {
	BufferedReader in = new BufferedReader(new FileReader(file));
	try {
	String line;
	while ((line = in.readLine()) != null) {
	String trimmed = line.trim();
	if (trimmed.length() > 0 && !trimmed.startsWith("#")) {
	patterns.add(Pattern.compile(trimmed));
	}
	}
	} finally {
	in.close();
	}
	}
	}