lombok.installer.eclipse.EclipseFinder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of lombok Show documentation
Spice up your java: Automatic Resource Management, automatic generation of getters, setters, equals, hashCode and toString, and more!
There is a newer version: 1.18.36
Show newest version
/*
 * Copyright © 2009-2011 Reinier Zwitserloot, Roel Spilker and Robbert Jan Grootjans.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
package lombok.installer.eclipse;

import static java.util.Arrays.asList;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import lombok.installer.IdeFinder;
import lombok.installer.IdeLocation;
import lombok.installer.CorruptedIdeLocationException;

import org.mangosdk.spi.ProviderFor;

@ProviderFor(IdeFinder.class)
public class EclipseFinder extends IdeFinder {
	/** should be lowercase! */
	protected String getDirName() {
		return "eclipse";
	}
	
	protected String getWindowsExecutableName() {
		return "eclipse.exe";
	}
	
	protected String getUnixExecutableName() {
		return "eclipse";
	}
	
	protected String getMacExecutableName() {
		return "Eclipse.app";
	}
	
	protected IdeLocation createLocation(String guess) throws CorruptedIdeLocationException {
		return new EclipseLocationProvider().create0(guess);
	}
	
	protected List getSourceDirsOnWindows() {
		return Arrays.asList("\\", "\\Program Files", "\\Program Files (x86)", System.getProperty("user.home", "."));
	}
	
	/**
	 * Returns a list of paths of Eclipse installations.
	 * Eclipse installations are found by checking for the existence of 'eclipse.exe' in the following locations:
	 * 
	 * X:\*Program Files*\*Eclipse*
	 * X:\*Eclipse*
	 * 
	 * 
	 * Where 'X' is tried for all local disk drives, unless there's a problem calling fsutil, in which case only
	 * C: is tried.
	 */
	private List getSourceDirsOnWindowsWithDriveLetters() {
		List driveLetters = asList("C");
		try {
			driveLetters = getDrivesOnWindows();
		} catch (Throwable ignore) {
			ignore.printStackTrace();
		}
		List sourceDirs = new ArrayList();
		for (String letter : driveLetters) {
			for (String possibleSource : getSourceDirsOnWindows()) {
				sourceDirs.add(letter + ":" + possibleSource);
			}
		}
		return sourceDirs;
	}
	
	protected List getSourceDirsOnMac() {
		return Arrays.asList("/Applications", System.getProperty("user.home", "."));
	}
	
	protected List getSourceDirsOnUnix() {
		return Arrays.asList(System.getProperty("user.home", "."));
	}
	
	private List transformToFiles(List fileNames) {
		List files = new ArrayList();
		for (String fileName : fileNames) {
			files.add(new File(fileName));
		}
		return files;
	}
	
	private List getFlatSourceLocationsOnUnix() {
		List dirs = new ArrayList();
		dirs.add(new File("/usr/bin/"));
		dirs.add(new File("/usr/local/bin/"));
		dirs.add(new File(System.getProperty("user.home", "."), "bin/"));
		return dirs;
	}
	
	private List getNestedSourceLocationOnUnix() {
		List dirs = new ArrayList();
		dirs.add(new File("/usr/local/share"));
		dirs.add(new File("/usr/local"));
		dirs.add(new File("/usr/share"));
		return dirs;
	}
	
	/**
	 * Calls the OS-dependent 'find Eclipse' routine. If the local OS doesn't have a routine written for it,
	 * null is returned.
	 * 
	 * @param locations
	 *            List of valid eclipse locations - provide an empty list; this
	 *            method will fill it.
	 * @param problems
	 *            List of eclipse locations that seem to contain half-baked
	 *            eclipses that can't be installed. Provide an empty list; this
	 *            method will fill it.
	 */
	@Override
	public void findIdes(List locations, List problems) {
		switch (getOS()) {
		case WINDOWS:
			new WindowsFinder().findEclipse(locations, problems);
			break;
		case MAC_OS_X:
			new MacFinder().findEclipse(locations, problems);
			break;
		default:
		case UNIX:
			new UnixFinder().findEclipse(locations, problems);
			break;
		}
	}
	
	private class UnixFinder extends DirectoryFinder {
		UnixFinder() {
			super(getNestedSourceLocationOnUnix(), getFlatSourceLocationsOnUnix());
		}
		
		@Override protected String findEclipseOnPlatform(File dir) {
			File possible = new File(dir, getUnixExecutableName());
			return (possible.exists()) ? possible.getAbsolutePath() : null;
		}
	}
	
	private class WindowsFinder extends DirectoryFinder {
		WindowsFinder() {
			super(transformToFiles(getSourceDirsOnWindowsWithDriveLetters()), Collections.emptyList());
		}
		
		/** Checks if the provided directory contains 'eclipse.exe', and if so, returns the directory, otherwise null. */
		@Override 
		protected String findEclipseOnPlatform(File dir) {
			File possible = new File(dir, getWindowsExecutableName());
			return (possible.isFile()) ? dir.getAbsolutePath() : null;
		}
	}
	
	private class MacFinder extends DirectoryFinder {
		MacFinder() {
			super(transformToFiles(getSourceDirsOnMac()), Collections.emptyList());
		}
		
		protected String findEclipseOnPlatform(File dir) {
			if (dir.getName().toLowerCase().equals(getMacExecutableName().toLowerCase())) return dir.getParent();
			if (dir.getName().toLowerCase().contains(getDirName())) {
				if (new File(dir, getMacExecutableName()).exists()) return dir.toString();
			}
			return null;
		}
	}
	
	private abstract class DirectoryFinder {
		private final List flatSourceDirs;
		private final List nestedSourceDirs;

		DirectoryFinder(List nestedSourceDirs, List flatSourceDirs) {
			this.nestedSourceDirs = nestedSourceDirs;
			this.flatSourceDirs = flatSourceDirs;
		}
		
		public void findEclipse(List locations, List problems) {
			for (File dir : nestedSourceDirs) recurseDirectory(locations, problems, dir);
			for (File dir : flatSourceDirs) findEclipse(locations, problems, dir);
		}
		
		protected abstract String findEclipseOnPlatform(File dir);
		
		protected void recurseDirectory(List locations, List problems, File dir) {
			recurseDirectory0(locations, problems, dir, 0);
		}
		
		private void recurseDirectory0(List locations, List problems, File f, int loopCounter) {
			//Various try/catch/ignore statements are in this for loop. Weird conditions on the disk can cause exceptions,
			//such as an unformatted drive causing a NullPointerException on listFiles. Best action is almost invariably to just
			//continue onwards.
			File[] listFiles = f.listFiles();
			if (listFiles == null) return;
			
			for (File dir : listFiles) {
				if (!dir.isDirectory()) continue;
				try {
					if (dir.getName().toLowerCase().contains(getDirName())) {
						findEclipse(locations, problems, dir);
						if (loopCounter < 50) recurseDirectory0(locations, problems, dir, loopCounter + 1);
					}
				} catch (Exception ignore) {}
			}
		}

		private void findEclipse(List locations, List problems, File dir) {
			String eclipseLocation = findEclipseOnPlatform(dir);
			if (eclipseLocation != null) {
				try {
					IdeLocation newLocation = createLocation(eclipseLocation);
					if (newLocation != null) locations.add(newLocation);
				} catch (CorruptedIdeLocationException e) {
					problems.add(e);
				}
			}
		}
	}
}