| /******************************************************************************* |
| * Copyright (c) 2000, 2011 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.egit.internal.relengtools; |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.StringTokenizer; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.egit.core.GitTag; |
| |
| /** |
| * This class provides access to information stored in RelEng map files |
| */ |
| public class MapEntry { |
| public static final GitTag DEFAULT = new GitTag("master"); |
| |
| private static final String HEAD = "HEAD"; |
| |
| private static final String KEY_TAG = "tag"; //$NON-NLS-1$ |
| |
| private static final String KEY_PATH = "path"; //$NON-NLS-1$ |
| |
| private static final String REPO = "repo"; |
| |
| private static final String EMPTY_STRING = ""; //$NON-NLS-1$ |
| |
| private boolean valid = false; |
| |
| private String type = EMPTY_STRING; |
| |
| private String id = EMPTY_STRING; |
| |
| private OrderedMap arguments = new OrderedMap(); |
| |
| private String version; |
| |
| public static void main(String[] args) { |
| // For testing only |
| |
| final String[] strings = { |
| "", |
| " ", |
| "type", |
| "type@", |
| "type@id", |
| "type@id=", |
| "type@id=tag,", |
| "type@id=tag, connectString", |
| "type@id=tag, connectString,", |
| "type@id=tag, connectString,password", |
| "type@id=tag, connectString,password,", |
| "type@id=tag, connectString,password,moduleName", |
| "type@id=tag, connectString,,moduleName", |
| "!*************** FEATURE CONTRIBUTION ******************************************************", |
| "@", |
| "=", |
| ",,,", |
| "@=,,,,", |
| "type@id,version=CVS,tag=myTag,cvsRoot=myCvsRoot,password=password,path=myPath", }; |
| |
| for (int i = 0; i < strings.length; i++) { |
| final String string = strings[i]; |
| final MapEntry anEntry = new MapEntry(string); |
| |
| System.out |
| .println("-----------------------------------------------"); |
| System.out.println("input: " + string); |
| System.out.println("map string: " + anEntry.getMapString()); |
| // System.out.println(anEntry.getReferenceString()); |
| anEntry.display(); |
| } |
| |
| } |
| |
| private void display() { |
| // For testing only |
| System.out.println("Is Valid: " + isValid()); |
| System.out.println("Type: " + getType()); |
| System.out.println("Project Name: " + getId()); |
| System.out.println("Tag: " + getTagName()); |
| if (version != null) |
| System.out.println("Version: " + version); |
| System.out.println("Connect: " + getRepo()); |
| System.out.println("Path: " + getPath()); |
| } |
| |
| public MapEntry(String entryLine) { |
| init(entryLine); |
| } |
| |
| /** |
| * Parse a map file entry line |
| * |
| * @param entryLine |
| */ |
| private void init(String entryLine) { |
| valid = false; |
| |
| // check for commented out entry |
| if (entryLine.startsWith("#") || entryLine.startsWith("!")) |
| return; |
| |
| // Type |
| int start = 0; |
| int end = entryLine.indexOf('@'); |
| if (end == -1) |
| return; |
| type = entryLine.substring(start, end).trim(); |
| |
| // Project Name |
| start = end + 1; |
| end = entryLine.indexOf('=', start); |
| if (end == -1) |
| return; |
| id = entryLine.substring(start, end).trim(); |
| // we have a version that we have to strip off |
| final int comma = id.indexOf(','); |
| if (comma != -1) { |
| version = id.substring(comma + 1); |
| id = id.substring(0, comma); |
| } |
| |
| final String[] args = getArrayFromStringWithBlank( |
| entryLine.substring(end + 1), ","); |
| this.arguments = populate(args); |
| if (this.arguments == null) |
| return; |
| final String tag = (String) arguments.get(KEY_TAG); |
| final String repo = (String) arguments.get(REPO); |
| if (tag == null || tag.length() == 0 || repo == null |
| || repo.length() == 0) |
| return; |
| valid = true; |
| } |
| |
| /* |
| * Build a table from the given array. We only understand GIT map entries of |
| * the format "GIT,key=value[,key=value]* |
| */ |
| private OrderedMap populate(String[] entries) { |
| if (entries.length <= 1 || !"GIT".equalsIgnoreCase(entries[0])) { |
| // not a GIT entry, ignore |
| return null; |
| } |
| |
| final OrderedMap result = new OrderedMap(); |
| for (int i = 1; i < entries.length; i++) { |
| final String entry = entries[i]; |
| final int index = entry.indexOf('='); |
| if (index == -1) { |
| // bad entry |
| return null; |
| } |
| final String key = entry.substring(0, index); |
| final String value = entry.substring(index + 1); |
| result.put(key, value); |
| } |
| return result; |
| } |
| |
| /** |
| * Convert a list of tokens into an array. The list separator has to be |
| * specified. The specificity of this method is that it returns an empty |
| * element when to same separators are following each others. For example |
| * the string a,,b returns the following array [a, ,b] |
| * |
| */ |
| public static String[] getArrayFromStringWithBlank(String list, |
| String separator) { |
| if (list == null || list.trim().length() == 0) |
| return new String[0]; |
| final List result = new ArrayList(); |
| boolean previousWasSeparator = true; |
| for (final StringTokenizer tokens = new StringTokenizer(list, |
| separator, true); tokens.hasMoreTokens();) { |
| final String token = tokens.nextToken().trim(); |
| if (token.equals(separator)) { |
| if (previousWasSeparator) |
| result.add(""); //$NON-NLS-1$ |
| previousWasSeparator = true; |
| } else { |
| result.add(token); |
| previousWasSeparator = false; |
| } |
| } |
| return (String[]) result.toArray(new String[result.size()]); |
| } |
| |
| public String getTagName() { |
| final String value = (String) arguments.get(KEY_TAG); |
| return value == null || HEAD.equals(value) ? EMPTY_STRING : value; |
| } |
| |
| public GitTag getTag() { |
| if (getTagName().equals(HEAD) || getTagName().equals("")) |
| return DEFAULT; |
| return new GitTag(getTagName()); |
| } |
| |
| public String getId() { |
| return id; |
| } |
| |
| private String internalGetCVSModule() { |
| final String module = (String) arguments.get(KEY_PATH); |
| return module == null ? id : module; |
| } |
| |
| public String getPath() { |
| final String value = (String) arguments.get(KEY_PATH); |
| return value == null ? EMPTY_STRING : value; |
| } |
| |
| public String getRepo() { |
| final String value = (String) arguments.get(REPO); |
| return value == null ? EMPTY_STRING : value; |
| } |
| |
| public String getType() { |
| return type; |
| } |
| |
| public boolean isValid() { |
| return valid; |
| } |
| |
| public String getReferenceString() { |
| if (!isValid()) |
| return null; |
| // This is the format used by the CVS IProjectSerializer |
| final String projectName = new Path(internalGetCVSModule()) |
| .lastSegment(); |
| return "1.0," + getRepo() + "," + internalGetCVSModule() + "," |
| + projectName + "," + getTagName(); |
| } |
| |
| public String getMapString() { |
| final StringBuffer result = new StringBuffer(); |
| result.append(getType()); |
| result.append('@'); |
| result.append(getId()); |
| if (version != null) { |
| result.append(','); |
| result.append(version); |
| } |
| result.append('='); |
| result.append("GIT"); |
| for (final Iterator iter = arguments.keys().iterator(); iter.hasNext();) { |
| final String key = (String) iter.next(); |
| final String value = (String) arguments.get(key); |
| if (value != null && value.length() > 0) |
| result.append(',' + key + '=' + value); |
| } |
| return result.toString(); |
| } |
| |
| /* |
| * Return the version specified for this entry. Can be null. |
| */ |
| public String getVersion() { |
| return version; |
| } |
| |
| public void setId(String projectID) { |
| this.id = projectID; |
| } |
| |
| public void setCVSModule(String path) { |
| arguments.put(KEY_PATH, path); |
| } |
| |
| public void setRepo(String repo) { |
| arguments.put(REPO, repo); |
| } |
| |
| public void setTagName(String tagName) { |
| arguments.put(KEY_TAG, tagName); |
| } |
| |
| public void setType(String type) { |
| this.type = type; |
| } |
| |
| public void setValid(boolean valid) { |
| this.valid = valid; |
| } |
| |
| @Override |
| public String toString() { |
| return "Entry: " + getMapString(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see java.lang.Object#equals(java.lang.Object) |
| */ |
| @Override |
| public boolean equals(Object obj) { |
| if (obj instanceof MapEntry) { |
| return ((MapEntry) obj).getMapString().equals(getMapString()); |
| } |
| return super.equals(obj); |
| } |
| |
| /** |
| * Return <code>true</code> if the entry is mapped to the given project and |
| * <code>false</code> otherwise. |
| */ |
| public boolean isMappedTo(IProject project) { |
| // RepositoryProvider provider = |
| // RepositoryProvider.getProvider(project); |
| if (id.equals(project.getName())) { |
| return true; |
| } |
| return false; |
| } |
| |
| } |