12466: Ingore/TextBin API inconsistencies

1 files changed, 504 insertions, 0 deletions

diff --git a/bundles/org.eclipse.team.core/src/org/eclipse/team/core/Team.java b/bundles/org.eclipse.team.core/src/org/eclipse/team/core/Team.java
new file mode 100644
index 000000000..4618b7a8d
--- /dev/null
+++ b/bundles/org.eclipse.team.core/src/org/eclipse/team/core/Team.java
@@ -0,0 +1,504 @@
+package org.eclipse.team.core;
+
+/*******************************************************************************
+ * Copyright (c) 2002 IBM Corporation and others.
+ * All rights reserved.   This program and the accompanying materials
+ * are made available under the terms of the Common Public License v0.5
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v05.html
+ * 
+ * Contributors:
+ * IBM - Initial API and implementation
+ ******************************************************************************/
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.EOFException;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IProjectDescription;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IExtension;
+import org.eclipse.core.runtime.IExtensionPoint;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.team.core.internal.Policy;
+import org.eclipse.team.core.internal.StringMatcher;
+import org.omg.CORBA.UNKNOWN;
+
+/**
+ * The Team class provides a global point of reference for the global ignore set
+ * and the text/binary registry.
+ */
+public final class Team {
+	// File type constants
+	public static final int UNKNOWN = 0;
+	public static final int TEXT = 1;
+	public static final int BINARY = 2;
+	
+	// File name of the persisted file type information
+	private static final String STATE_FILE = ".fileTypes"; //$NON-NLS-1$
+	
+	// File name of the persisted global ignore patterns
+	private final static String GLOBALIGNORE_FILE = ".globalIgnores"; //$NON-NLS-1$
+
+	// Keys: file extensions. Values: Integers
+	private static Hashtable table;
+
+	// The ignore list that is read at startup from the persisted file
+	private static Map globalIgnore = new HashMap(11);
+
+	private static class FileTypeInfo implements IFileTypeInfo {
+		private String extension;
+		private int type;
+		
+		public FileTypeInfo(String extension, int type) {
+			this.extension = extension;
+			this.type = type;
+		}
+		public String getExtension() {
+			return extension;
+		}
+		public int getType() {
+			return type;
+		}
+	}
+	
+	private static class IgnoreInfo implements IIgnoreInfo {
+		private String pattern;
+		private boolean enabled;
+		
+		public IgnoreInfo(String pattern, boolean enabled) {
+			this.pattern = pattern;
+			this.enabled = enabled;
+		}
+		public String getPattern() {
+			return pattern;
+		}
+		public boolean getEnabled() {
+			return enabled;
+		}
+	};
+	
+	/**
+	 * Return the type of the given file.
+	 * 
+	 * Valid return values are:
+	 * IFileTypeRegistry.TEXT
+	 * IFileTypeRegistry.BINARY
+	 * IFileTypeRegistry.UNKNOWN
+	 * 
+	 * @param file  the file
+	 * @return whether files with the given extension are TEXT, BINARY, or UNKNOWN
+	 */
+	public static int getType(IFile file) {
+		String extension = file.getFileExtension();
+		if (extension == null) return UNKNOWN;
+		Integer integer = (Integer)table.get(extension);
+		if (integer == null) return UNKNOWN;
+		return integer.intValue();
+	}
+
+	/**
+	 * Returns whether the given file is ignored by any of the global ignore patterns.
+	 */
+	public static boolean isIgnored(IFile file) {
+		IIgnoreInfo[] ignorePatterns = getAllIgnores();
+		StringMatcher matcher;
+		for (int i = 0; i < ignorePatterns.length; i++) {
+			IIgnoreInfo info = ignorePatterns[i];
+			if (info.getEnabled()) {
+				matcher = new StringMatcher(info.getPattern(), true, false);
+				if (matcher.match(file.getName())) return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Return all known file types.
+	 * 
+	 * @return all known file types
+	 */
+	public static IFileTypeInfo[] getAllTypes() {
+		List result = new ArrayList();
+		Enumeration e = table.keys();
+		while (e.hasMoreElements()) {
+			String string = (String)e.nextElement();
+			int type = ((Integer)table.get(string)).intValue();
+			result.add(new FileTypeInfo(string, type));
+		}
+		return (IFileTypeInfo[])result.toArray(new IFileTypeInfo[result.size()]);
+	}
+	
+	/**
+	 * Returns the list of global ignores.
+	 */
+	public static IIgnoreInfo[] getAllIgnores() {
+		IIgnoreInfo[] result = new IIgnoreInfo[globalIgnore.size()];
+		Iterator e = globalIgnore.keySet().iterator();
+		int i = 0;
+		while (e.hasNext() ) {
+			final String pattern = (String)e.next();
+			final boolean enabled = ((Boolean)globalIgnore.get(pattern)).booleanValue();
+			result[i++] = new IIgnoreInfo() {
+				private String p = pattern;
+				private boolean e = enabled;
+				public String getPattern() {
+					return p;
+				}
+				public boolean getEnabled() {
+					return e;
+				}
+			};
+		}
+		return result;
+	}
+
+	/**
+	 * Set the file type for the give extension to the given type.
+	 *
+	 * Valid types are:
+	 * IFileTypeRegistry.TEXT
+	 * IFileTypeRegistry.BINARY
+	 * IFileTypeRegistry.UNKNOWN
+	 * 
+	 * @param extension  the file extension
+	 * @param type  the file type
+	 */
+	public static void setAllTypes(String[] extensions, int[] types) {
+		table = new Hashtable(11);
+		for (int i = 0; i < extensions.length; i++) {
+			table.put(extensions[i], new Integer(types[i]));
+		}
+	}
+	
+	/**
+	 * Add patterns to the list of global ignores.
+	 */
+	public static void setAllIgnores(String[] patterns, boolean[] enabled) {
+		globalIgnore = new Hashtable(11);
+		for (int i = 0; i < patterns.length; i++) {
+			globalIgnore.put(patterns[i], new Boolean(enabled[i]));
+		}
+	}
+	
+	/**
+	 * Utility method for removing a project nature from a project.
+	 * 
+	 * @param proj the project to remove the nature from
+	 * @param natureId the nature id to remove
+	 * @param monitor a progress monitor to indicate the duration of the operation, or
+	 * <code>null</code> if progress reporting is not required.
+	 */
+	public static void removeNatureFromProject(IProject proj, String natureId, IProgressMonitor monitor) throws TeamException {
+		try {
+			IProjectDescription description = proj.getDescription();
+			String[] prevNatures= description.getNatureIds();
+			List newNatures = new ArrayList(Arrays.asList(prevNatures));
+			newNatures.remove(natureId);
+			description.setNatureIds((String[])newNatures.toArray(new String[newNatures.size()]));
+			proj.setDescription(description, monitor);
+		} catch(CoreException e) {
+				throw new TeamException(new Status(IStatus.ERROR, TeamPlugin.ID, 0, Policy.bind("manager.errorRemovingNature",  //$NON-NLS-1$
+														 proj.getName(), natureId), e));
+		}
+	}
+	
+	/**
+	 * Utility method for adding a nature to a project.
+	 * 
+	 * @param proj the project to add the nature
+	 * @param natureId the id of the nature to assign to the project
+	 * @param monitor a progress monitor to indicate the duration of the operation, or
+	 * <code>null</code> if progress reporting is not required.
+	 * 
+	 * @exception TeamException if a problem occured setting the nature
+	 */
+	public static void addNatureToProject(IProject proj, String natureId, IProgressMonitor monitor) throws TeamException {
+		try {
+			IProjectDescription description = proj.getDescription();
+			String[] prevNatures= description.getNatureIds();
+			String[] newNatures= new String[prevNatures.length + 1];
+			System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length);
+			newNatures[prevNatures.length]= natureId;
+			description.setNatureIds(newNatures);
+			proj.setDescription(description, monitor);
+		} catch(CoreException e) {
+				throw new TeamException(new Status(IStatus.ERROR, TeamPlugin.ID, 0, Policy.bind("manager.errorSettingNature",  //$NON-NLS-1$
+														 proj.getName(), natureId), e));
+		}
+	}
+	
+	/*
+	 * TEXT
+	 * 
+	 * Reads the text patterns currently defined by extensions.
+	 */
+	private static void initializePluginPatterns() {
+		TeamPlugin plugin = TeamPlugin.getPlugin();
+		if (plugin != null) {
+			IExtensionPoint extension = plugin.getDescriptor().getExtensionPoint(TeamPlugin.FILE_TYPES_EXTENSION);
+			if (extension != null) {
+				IExtension[] extensions =  extension.getExtensions();
+				for (int i = 0; i < extensions.length; i++) {
+					IConfigurationElement[] configElements = extensions[i].getConfigurationElements();
+					for (int j = 0; j < configElements.length; j++) {
+						String ext = configElements[j].getAttribute("extension"); //$NON-NLS-1$
+						if (ext != null) {
+							String type = configElements[j].getAttribute("type"); //$NON-NLS-1$
+							// If the extension doesn't already exist, add it.
+							if (!table.containsKey(ext)) {
+								if (type.equals("text")) { //$NON-NLS-1$
+									table.put(ext, new Integer(TEXT));
+								} else if (type.equals("binary")) { //$NON-NLS-1$
+									table.put(ext, new Integer(BINARY));
+								}
+							}
+						}
+					}
+				}
+			}		
+		}
+	}
+	
+	/*
+	 * TEXT
+	 * 
+	 * Read the saved file type state from the given input stream.
+	 * 
+	 * @param dis  the input stream to read the saved state from
+	 * @throws IOException if an I/O problem occurs
+	 */
+	private static void readTextState(DataInputStream dis) throws IOException {
+		table = new Hashtable(11);
+		int extensionCount = 0;
+		try {
+			extensionCount = dis.readInt();
+		} catch (EOFException e) {
+			// Ignore the exception, it will occur if there are no
+			// patterns stored in the state file.
+			return;
+		}
+		for (int i = 0; i < extensionCount; i++) {
+			String extension = dis.readUTF();
+			int type = dis.readInt();
+			table.put(extension, new Integer(type));
+		}
+	}
+	
+	/*
+	 * TEXT
+	 * 
+	 * Write the current state to the given output stream.
+	 * 
+	 * @param dos  the output stream to write the saved state to
+	 * @throws IOException if an I/O problem occurs
+	 */
+	private static void writeTextState(DataOutputStream dos) throws IOException {
+		dos.writeInt(table.size());
+		Iterator it = table.keySet().iterator();
+		while (it.hasNext()) {
+			String extension = (String)it.next();
+			dos.writeUTF(extension);
+			Integer integer = (Integer)table.get(extension);
+			dos.writeInt(integer.intValue());
+		}
+	}
+	
+	/*
+	 * TEXT
+	 * 
+	 * Load the file type registry saved state. This loads the previously saved
+	 * contents, as well as discovering any values contributed by plug-ins.
+	 */
+	private static void loadTextState() {
+		IPath pluginStateLocation = TeamPlugin.getPlugin().getStateLocation().append(STATE_FILE);
+		File f = pluginStateLocation.toFile();
+		if (f.exists()) {
+			try {
+				DataInputStream dis = new DataInputStream(new FileInputStream(f));
+				readTextState(dis);
+				dis.close();
+			} catch (IOException ex) {
+				// Throw an exception here
+			}
+		}
+		// Read values contributed by plugins
+		initializePluginPatterns();
+	}
+	
+	/*
+	 * TEXT
+	 * 
+	 * Save the file type registry state.
+	 */
+	private static void saveTextState() {
+		IPath pluginStateLocation = TeamPlugin.getPlugin().getStateLocation();
+		File tempFile = pluginStateLocation.append(STATE_FILE + ".tmp").toFile(); //$NON-NLS-1$
+		File stateFile = pluginStateLocation.append(STATE_FILE).toFile();
+		try {
+			DataOutputStream dos = new DataOutputStream(new FileOutputStream(tempFile));
+			writeTextState(dos);
+			dos.close();
+			if (stateFile.exists() && !stateFile.delete()) {
+				// Throw an exception here
+			}
+			boolean renamed = tempFile.renameTo(stateFile);
+			if (!renamed) {
+				// Throw an exception here
+			}
+		} catch (Exception e) {
+			// Throw an exception here
+		}
+	}
+	
+	/*
+	 * IGNORE
+	 * 
+	 * Reads the ignores currently defined by extensions.
+	 */
+	private static void initializePluginIgnores() {
+		TeamPlugin plugin = TeamPlugin.getPlugin();
+		if (plugin != null) {
+			IExtensionPoint extension = plugin.getDescriptor().getExtensionPoint(TeamPlugin.IGNORE_EXTENSION);
+			if (extension != null) {
+				IExtension[] extensions =  extension.getExtensions();
+				for (int i = 0; i < extensions.length; i++) {
+					IConfigurationElement [] configElements = extensions[i].getConfigurationElements();
+					for (int j = 0; j < configElements.length; j++) {
+						String pattern = configElements[j].getAttribute("pattern"); //$NON-NLS-1$
+						if (pattern != null) {
+							String selected = configElements[j].getAttribute("selected"); //$NON-NLS-1$
+							boolean enabled = selected != null && selected.equalsIgnoreCase("true"); //$NON-NLS-1$
+							// if this ignore doesn't already exist, add it to the global list
+							if (!globalIgnore.containsKey(pattern)) {
+								globalIgnore.put(pattern, new Boolean(enabled));
+							}
+						}
+					}
+				}
+			}		
+		}
+	}
+	
+	/*
+	 * IGNORE
+	 * 
+	 * Save global ignore file
+	 */
+	private static void saveIgnoreState() throws TeamException {
+		// save global ignore list to disk
+		IPath pluginStateLocation = TeamPlugin.getPlugin().getStateLocation();
+		File tempFile = pluginStateLocation.append(GLOBALIGNORE_FILE + ".tmp").toFile(); //$NON-NLS-1$
+		File stateFile = pluginStateLocation.append(GLOBALIGNORE_FILE).toFile();
+		try {
+			DataOutputStream dos = new DataOutputStream(new FileOutputStream(tempFile));
+			writeIgnoreState(dos);
+			dos.close();
+			if (stateFile.exists())
+				stateFile.delete();
+			boolean renamed = tempFile.renameTo(stateFile);
+			if (!renamed)
+				throw new TeamException(new Status(IStatus.ERROR, TeamPlugin.ID, 0, Policy.bind("TeamPlugin_renaming_21"), null)); //$NON-NLS-1$
+		} catch (IOException ex) {
+			throw new TeamException(new Status(IStatus.ERROR, TeamPlugin.ID, 0, Policy.bind("TeamPlugin_closing_stream_22"), ex)); //$NON-NLS-1$
+		}
+	}
+	
+	/*
+	 * IGNORE
+	 * 
+	 * Write the global ignores to the stream
+	 */
+	private static void writeIgnoreState(DataOutputStream dos) throws IOException {
+		// write the global ignore list
+		int ignoreLength = globalIgnore.size();
+		dos.writeInt(ignoreLength);
+		Iterator e = globalIgnore.keySet().iterator();
+		while (e.hasNext()) {
+			String pattern = (String)e.next();
+			boolean enabled = ((Boolean)globalIgnore.get(pattern)).booleanValue();
+			dos.writeUTF(pattern);
+			dos.writeBoolean(enabled);
+		}
+	}
+	
+	/*
+	 * IGNORE
+	 * 
+	 * Reads the global ignore file
+	 */
+	private static void readIgnoreState() throws TeamException {
+		// read saved repositories list and ignore list from disk, only if the file exists
+		IPath pluginStateLocation = TeamPlugin.getPlugin().getStateLocation().append(GLOBALIGNORE_FILE);
+		File f = pluginStateLocation.toFile();
+		if(f.exists()) {
+			try {
+				DataInputStream dis = new DataInputStream(new FileInputStream(f));
+				globalIgnore = new Hashtable(11);
+				int ignoreCount = 0;
+				try {
+					ignoreCount = dis.readInt();
+				} catch (EOFException e) {
+					// Ignore the exception, it will occur if there are no ignore
+					// patterns stored in the provider state file.
+					return;
+				}
+				for (int i = 0; i < ignoreCount; i++) {
+					String pattern = dis.readUTF();
+					boolean enabled = dis.readBoolean();
+					globalIgnore.put(pattern, new Boolean(enabled));
+				}
+			} catch (FileNotFoundException e) {
+				// not a fatal error, there just happens not to be any state to read
+			} catch (IOException ex) {
+				throw new TeamException(new Status(IStatus.ERROR, TeamPlugin.ID, 0, Policy.bind("TeamPlugin_closing_stream_23"), ex));			 //$NON-NLS-1$
+			}
+		}
+	}
+
+	/*
+	 * Initialize the registry, restoring its state
+	 */
+	static void startup() throws CoreException {
+		try {
+			table = new Hashtable(11);
+			loadTextState();
+			readIgnoreState();
+			initializePluginIgnores();
+		} catch (TeamException e) {
+			throw new CoreException(e.getStatus());
+		}
+	}
+	
+	/*
+	 * Shut down the registry, persisting its state
+	 */	
+	static void shutdown() {
+		saveTextState();
+		try {
+			// make sure that we update our state on disk
+			saveIgnoreState();
+		} catch (TeamException ex) {
+			TeamPlugin.log(IStatus.WARNING, Policy.bind("TeamPlugin_setting_global_ignore_7"), ex); //$NON-NLS-1$
+		}
+	}
+}