2.4/build-tools/ant-gwt/src/com/google/gwt/ant/taskdefs/SvnInfo.java - gwt - Git at Google

 /*
  * Copyright 2008 Google Inc.
  *
  * 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.
  */
 package com.google.gwt.ant.taskdefs;

 import org.apache.tools.ant.BuildException;
 import org.apache.tools.ant.Task;

 import java.io.File;
 import java.io.IOException;
 import java.io.LineNumberReader;
 import java.io.StringReader;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 /**
  * A Svn interface task, because the initial solution of <exec> and
  * <propertyregex> is unhappy in ant 1.6.5, and while that's old, it's not quite
  * "too old" for us to care.
  */
 public class SvnInfo extends Task {

   /**
    * Structured svn info.
    */
   static class Info {
     /**
      * The relative path of this svn working copy within the root of the remote
      * repository. That is, if the root is "http://example.com/svn" and the
      * working copy URL is "http://example.com/svn/tags/w00t", this will be set
      * to "tags/w00t".
      */
     public final String branch;

     /**
      * The revision of this working copy. Initially set to the value parsed from
      * "svn info" given a more detailed value via "svnversion".
      */
     public String revision;

     public Info(String branch, String revision) {
       this.branch = branch;
       this.revision = revision;
     }
   }

   /**
    * A regex that matches a URL.
    */
   static final String URL_REGEX = "\\w+://\\S*";

   /**
    * A pattern that matches the URL line in svn info output.  Note that it
    * <i>also</i> matches Repository Root; to support i18n subversion clients,
    * we're positionally dependent that URL will be the first match, and
    * Repository Root the second.
    */
   private static final Pattern BRANCH_PATTERN = Pattern.compile("[^:]*:\\s*("
       + URL_REGEX + ")\\s*");

   /**
    * A pattern that matches the Revision line in svn info output.  <i>Also</i>
    * matches Last Changed Rev; we're positionally dependent (revision is
    * earlier) to support internationalized svn client output.
    */
   private static final Pattern REVISION_PATTERN = Pattern.compile("[^:]*:\\s*(\\d+)\\s*");

   /**
    * A pattern that matches the Repository Root line in svn info output.
    */
   private static final Pattern ROOT_PATTERN = Pattern.compile("[^:]*:\\s*("
       + URL_REGEX + "/svn)\\s*");

   /**
    * Returns true if this git working copy matches the specified svn revision,
    * and also has no local modifications.
    */
   static boolean doesGitWorkingCopyMatchSvnRevision(File dir, String svnRevision) {
     String workingRev = getGitWorkingRev(dir);
     String targetRev = getGitRevForSvnRev(dir, svnRevision);
     if (!workingRev.equals(targetRev)) {
       return false;
     }
     String status = getGitStatus(dir);
     return status.contains("nothing to commit (working directory clean)");
   }

   /**
    * Returns the git commit number matching the specified svn revision.
    */
   static String getGitRevForSvnRev(File dir, String svnRevision) {
     String output = CommandRunner.getCommandOutput(dir, "git", "svn",
         "find-rev", "r" + svnRevision);
     output = output.trim();
     if (output.length() == 0) {
       throw new BuildException("git svn find-rev didn't give any answer");
     }
     return output;
   }

   /**
    * Runs "git status" and returns the result.
    */
   static String getGitStatus(File dir) {
     // git status returns 1 for a status code, so just don't check it.
     String output = CommandRunner.getCommandOutput(false, dir, "git", "status");
     if (output.length() == 0) {
       throw new BuildException("git status didn't give any answer");
     }
     return output;
   }

   /**
    * Runs "git svn info", returning the output as a string.
    */
   static String getGitSvnInfo(File dir) {
     String output = CommandRunner.getCommandOutput(dir, "git", "svn", "info");
     if (output.length() == 0) {
       throw new BuildException("git svn info didn't give any answer");
     }
     return output;
   }

   /**
    * Returns the current git commit number of the working copy.
    */
   static String getGitWorkingRev(File dir) {
     String output = CommandRunner.getCommandOutput(dir, "git", "rev-list",
         "--max-count=1", "HEAD");
     output = output.trim();
     if (output.length() == 0) {
       throw new BuildException("git rev-list didn't give any answer");
     }
     return output;
   }

   /**
    * Runs "svn info", returning the output as a string.
    */
   static String getSvnInfo(File dir) {
     String output = CommandRunner.getCommandOutput(dir, "svn", "info");
     if (output.length() == 0) {
       throw new BuildException("svn info didn't give any answer");
     }
     return output;
   }

   /**
    * Runs "svnversion", returning the output as a string.
    */
   static String getSvnVersion(File dir) {
     String output = CommandRunner.getCommandOutput(dir, "svnversion", ".");
     output = output.trim();
     if (output.length() == 0) {
       throw new BuildException("svnversion didn't give any answer");
     }
     return output;
   }

   /**
    * Determine if this directory is a part of a .git repository.
    *
    * @param dir working directory to start looking for the repository.
    * @return <code>true</code> if a .git repo is found. Returns
    *         <code>false</false> if a .git repo cannot be found, or if
    *         this directory is part of a subversion repository.
    */
   static boolean looksLikeGit(File dir) {
     if (looksLikeSvn(dir)) {
       return false;
     }
     File gitDir = findGitDir(dir);

     if (gitDir != null && gitDir.isDirectory()) {
       return new File(gitDir, "svn").isDirectory();
     }
     return false;
   }

   /**
    * Returns <code>true</code> if the specified directory looks like an svn
    * working copy.
    */
   static boolean looksLikeSvn(File dir) {
     return new File(dir, ".svn").isDirectory();
   }

   /**
    * Parses the output of running "svn info".
    */
   static Info parseInfo(String svnInfo) {
     String rootUrl = null;
     String branchUrl = null;
     String revision = null;
     LineNumberReader lnr = new LineNumberReader(new StringReader(svnInfo));
     try {
       for (String line = lnr.readLine(); line != null; line = lnr.readLine()) {
         Matcher m;
         if ((m = ROOT_PATTERN.matcher(line)) != null && m.matches()) {
           rootUrl = m.group(1);
         } else if ((m = BRANCH_PATTERN.matcher(line)) != null && m.matches()) {
           if (branchUrl == null) {
             branchUrl = m.group(1);
           } // else skip the 2nd and later matches
         } else if ((m = REVISION_PATTERN.matcher(line)) != null && m.matches()) {
           if (revision == null) {
             revision = m.group(1);
           } // else skip the 2nd and later matches
         }
       }
     } catch (IOException e) {
       throw new BuildException("Should never happen", e);
     }

     if (rootUrl == null) {
       throw new BuildException("svn info didn't get root URL: " + svnInfo);
     }
     if (branchUrl == null) {
       throw new BuildException("svn info didn't get branch URL: " + svnInfo);
     }
     if (revision == null) {
       throw new BuildException("svn info didn't get revision: " + svnInfo);
     }
     rootUrl = removeTrailingSlash(rootUrl);
     branchUrl = removeTrailingSlash(branchUrl);
     if (!branchUrl.startsWith(rootUrl)) {
       throw new BuildException("branch URL (" + branchUrl + ") and root URL ("
           + rootUrl + ") did not match");
     }

     String branch;
     if (branchUrl.length() == rootUrl.length()) {
       branch = "";
     } else {
       branch = branchUrl.substring(rootUrl.length() + 1);
     }
     return new Info(branch, revision);
   }

   static String removeTrailingSlash(String url) {
     if (url.endsWith("/")) {
       return url.substring(0, url.length() - 1);
     }
     return url;
   }

   /**
    * Find the GIT working directory.
    *
    * First checks for the presence of the env variable GIT_DIR, then, looks up
    * the the tree for a directory named '.git'.
    *
    * @param dir Current working directory
    * @return An object representing the .git directory. Returns
    *         <code>null</code> if none can be found.
    */
   private static File findGitDir(File dir) {
     String gitDirPath = System.getenv("GIT_DIR");
     if (gitDirPath != null) {
       File gitDir = new File(gitDirPath).getAbsoluteFile();
       if (gitDir.isDirectory()) {
         return gitDir;
       }
     }

     dir = dir.getAbsoluteFile();
     while (dir != null) {
       File gitDir = new File(dir, ".git");
       if (gitDir.isDirectory()) {
         return gitDir;
       }
       dir = dir.getParentFile();
     }
     return null;
   }

   private String fileprop;

   private String outprop;

   private String workdir;

   public SvnInfo() {
     super();
   }

   @Override
   public void execute() throws BuildException {
     if (outprop == null) {
       throw new BuildException(
           "<svninfo> task requires an outputproperty attribute");
     }
     if (workdir == null) {
       workdir = getProject().getProperty("basedir");
     }
     File workDirFile = new File(workdir);
     if (!workDirFile.isDirectory()) {
       throw new BuildException(workdir + " is not a directory");
     }

     if (getProject().getProperty(outprop) == null) {
       Info info;
       if (looksLikeSvn(workDirFile)) {
         info = parseInfo(getSvnInfo(workDirFile));

         // Use svnversion to get a more exact revision string.
         info.revision = getSvnVersion(workDirFile);
       } else if (looksLikeGit(workDirFile)) {
         info = parseInfo(getGitSvnInfo(workDirFile));

         // Add a 'M' tag if this working copy is not pristine.
         if (!doesGitWorkingCopyMatchSvnRevision(workDirFile, info.revision)) {
           info.revision += "M";
         }
       } else {
         info = new Info("unknown", "unknown");
       }
       getProject().setNewProperty(outprop, info.branch + "@" + info.revision);
     } else {
       String propval = getProject().getProperty(outprop);
       if (!propval.matches("[^@]+@[0-9]+")) {
         throw new BuildException(
           "predefined " + outprop +
               "should look like branch-spec@revison-number");
       }
     }
     if (fileprop != null) {
       String outpropval = getProject().getProperty(outprop);
       int atIndex = outpropval.indexOf('@');
       String branch = outpropval.substring(0, atIndex);
       String revision = outpropval.substring(atIndex + 1);

       getProject().setNewProperty(fileprop,
           branch.replace('/', '-') + "-" + revision.replace(':', '-'));
     }
   }

   /**
    * Establishes the directory used as the SVN workspace to fetch version
    * information.
    *
    * @param srcdir workspace directory name
    */
   public void setDirectory(String srcdir) {
     workdir = srcdir;
   }

   /**
    * Establishes the property containing the SVN output string, branch@rev.
    *
    * @param propname Name of a property
    */
   public void setOutputFileProperty(String propname) {
     fileprop = propname;
   }

   /**
    * Establishes the property containing the SVN output string, branch@rev.
    *
    * @param propname Name of a property
    */
   public void setOutputProperty(String propname) {
     outprop = propname;
   }
 }
	/*
	* Copyright 2008 Google Inc.
	*
	* 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.
	*/
	package com.google.gwt.ant.taskdefs;

	import org.apache.tools.ant.BuildException;
	import org.apache.tools.ant.Task;

	import java.io.File;
	import java.io.IOException;
	import java.io.LineNumberReader;
	import java.io.StringReader;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	/**
	* A Svn interface task, because the initial solution of <exec> and
	* <propertyregex> is unhappy in ant 1.6.5, and while that's old, it's not quite
	* "too old" for us to care.
	*/
	public class SvnInfo extends Task {

	/**
	* Structured svn info.
	*/
	static class Info {
	/**
	* The relative path of this svn working copy within the root of the remote
	* repository. That is, if the root is "http://example.com/svn" and the
	* working copy URL is "http://example.com/svn/tags/w00t", this will be set
	* to "tags/w00t".
	*/
	public final String branch;

	/**
	* The revision of this working copy. Initially set to the value parsed from
	* "svn info" given a more detailed value via "svnversion".
	*/
	public String revision;

	public Info(String branch, String revision) {
	this.branch = branch;
	this.revision = revision;
	}
	}

	/**
	* A regex that matches a URL.
	*/
	static final String URL_REGEX = "\\w+://\\S*";

	/**
	* A pattern that matches the URL line in svn info output. Note that it
	* <i>also</i> matches Repository Root; to support i18n subversion clients,
	* we're positionally dependent that URL will be the first match, and
	* Repository Root the second.
	*/
	private static final Pattern BRANCH_PATTERN = Pattern.compile("[^:]:\\s("
	+ URL_REGEX + ")\\s*");

	/**
	* A pattern that matches the Revision line in svn info output. <i>Also</i>
	* matches Last Changed Rev; we're positionally dependent (revision is
	* earlier) to support internationalized svn client output.
	*/
	private static final Pattern REVISION_PATTERN = Pattern.compile("[^:]:\\s(\\d+)\\s*");

	/**
	* A pattern that matches the Repository Root line in svn info output.
	*/
	private static final Pattern ROOT_PATTERN = Pattern.compile("[^:]:\\s("
	+ URL_REGEX + "/svn)\\s*");

	/**
	* Returns true if this git working copy matches the specified svn revision,
	* and also has no local modifications.
	*/
	static boolean doesGitWorkingCopyMatchSvnRevision(File dir, String svnRevision) {
	String workingRev = getGitWorkingRev(dir);
	String targetRev = getGitRevForSvnRev(dir, svnRevision);
	if (!workingRev.equals(targetRev)) {
	return false;
	}
	String status = getGitStatus(dir);
	return status.contains("nothing to commit (working directory clean)");
	}

	/**
	* Returns the git commit number matching the specified svn revision.
	*/
	static String getGitRevForSvnRev(File dir, String svnRevision) {
	String output = CommandRunner.getCommandOutput(dir, "git", "svn",
	"find-rev", "r" + svnRevision);
	output = output.trim();
	if (output.length() == 0) {
	throw new BuildException("git svn find-rev didn't give any answer");
	}
	return output;
	}

	/**
	* Runs "git status" and returns the result.
	*/
	static String getGitStatus(File dir) {
	// git status returns 1 for a status code, so just don't check it.
	String output = CommandRunner.getCommandOutput(false, dir, "git", "status");
	if (output.length() == 0) {
	throw new BuildException("git status didn't give any answer");
	}
	return output;
	}

	/**
	* Runs "git svn info", returning the output as a string.
	*/
	static String getGitSvnInfo(File dir) {
	String output = CommandRunner.getCommandOutput(dir, "git", "svn", "info");
	if (output.length() == 0) {
	throw new BuildException("git svn info didn't give any answer");
	}
	return output;
	}

	/**
	* Returns the current git commit number of the working copy.
	*/
	static String getGitWorkingRev(File dir) {
	String output = CommandRunner.getCommandOutput(dir, "git", "rev-list",
	"--max-count=1", "HEAD");
	output = output.trim();
	if (output.length() == 0) {
	throw new BuildException("git rev-list didn't give any answer");
	}
	return output;
	}

	/**
	* Runs "svn info", returning the output as a string.
	*/
	static String getSvnInfo(File dir) {
	String output = CommandRunner.getCommandOutput(dir, "svn", "info");
	if (output.length() == 0) {
	throw new BuildException("svn info didn't give any answer");
	}
	return output;
	}

	/**
	* Runs "svnversion", returning the output as a string.
	*/
	static String getSvnVersion(File dir) {
	String output = CommandRunner.getCommandOutput(dir, "svnversion", ".");
	output = output.trim();
	if (output.length() == 0) {
	throw new BuildException("svnversion didn't give any answer");
	}
	return output;
	}

	/**
	* Determine if this directory is a part of a .git repository.
	*
	* @param dir working directory to start looking for the repository.
	* @return <code>true</code> if a .git repo is found. Returns
	* <code>false</false> if a .git repo cannot be found, or if
	* this directory is part of a subversion repository.
	*/
	static boolean looksLikeGit(File dir) {
	if (looksLikeSvn(dir)) {
	return false;
	}
	File gitDir = findGitDir(dir);

	if (gitDir != null && gitDir.isDirectory()) {
	return new File(gitDir, "svn").isDirectory();
	}
	return false;
	}

	/**
	* Returns <code>true</code> if the specified directory looks like an svn
	* working copy.
	*/
	static boolean looksLikeSvn(File dir) {
	return new File(dir, ".svn").isDirectory();
	}

	/**
	* Parses the output of running "svn info".
	*/
	static Info parseInfo(String svnInfo) {
	String rootUrl = null;
	String branchUrl = null;
	String revision = null;
	LineNumberReader lnr = new LineNumberReader(new StringReader(svnInfo));
	try {
	for (String line = lnr.readLine(); line != null; line = lnr.readLine()) {
	Matcher m;
	if ((m = ROOT_PATTERN.matcher(line)) != null && m.matches()) {
	rootUrl = m.group(1);
	} else if ((m = BRANCH_PATTERN.matcher(line)) != null && m.matches()) {
	if (branchUrl == null) {
	branchUrl = m.group(1);
	} // else skip the 2nd and later matches
	} else if ((m = REVISION_PATTERN.matcher(line)) != null && m.matches()) {
	if (revision == null) {
	revision = m.group(1);
	} // else skip the 2nd and later matches
	}
	}
	} catch (IOException e) {
	throw new BuildException("Should never happen", e);
	}

	if (rootUrl == null) {
	throw new BuildException("svn info didn't get root URL: " + svnInfo);
	}
	if (branchUrl == null) {
	throw new BuildException("svn info didn't get branch URL: " + svnInfo);
	}
	if (revision == null) {
	throw new BuildException("svn info didn't get revision: " + svnInfo);
	}
	rootUrl = removeTrailingSlash(rootUrl);
	branchUrl = removeTrailingSlash(branchUrl);
	if (!branchUrl.startsWith(rootUrl)) {
	throw new BuildException("branch URL (" + branchUrl + ") and root URL ("
	+ rootUrl + ") did not match");
	}

	String branch;
	if (branchUrl.length() == rootUrl.length()) {
	branch = "";
	} else {
	branch = branchUrl.substring(rootUrl.length() + 1);
	}
	return new Info(branch, revision);
	}

	static String removeTrailingSlash(String url) {
	if (url.endsWith("/")) {
	return url.substring(0, url.length() - 1);
	}
	return url;
	}

	/**
	* Find the GIT working directory.
	*
	* First checks for the presence of the env variable GIT_DIR, then, looks up
	* the the tree for a directory named '.git'.
	*
	* @param dir Current working directory
	* @return An object representing the .git directory. Returns
	* <code>null</code> if none can be found.
	*/
	private static File findGitDir(File dir) {
	String gitDirPath = System.getenv("GIT_DIR");
	if (gitDirPath != null) {
	File gitDir = new File(gitDirPath).getAbsoluteFile();
	if (gitDir.isDirectory()) {
	return gitDir;
	}
	}

	dir = dir.getAbsoluteFile();
	while (dir != null) {
	File gitDir = new File(dir, ".git");
	if (gitDir.isDirectory()) {
	return gitDir;
	}
	dir = dir.getParentFile();
	}
	return null;
	}

	private String fileprop;

	private String outprop;

	private String workdir;

	public SvnInfo() {
	super();
	}

	@Override
	public void execute() throws BuildException {
	if (outprop == null) {
	throw new BuildException(
	"<svninfo> task requires an outputproperty attribute");
	}
	if (workdir == null) {
	workdir = getProject().getProperty("basedir");
	}
	File workDirFile = new File(workdir);
	if (!workDirFile.isDirectory()) {
	throw new BuildException(workdir + " is not a directory");
	}

	if (getProject().getProperty(outprop) == null) {
	Info info;
	if (looksLikeSvn(workDirFile)) {
	info = parseInfo(getSvnInfo(workDirFile));

	// Use svnversion to get a more exact revision string.
	info.revision = getSvnVersion(workDirFile);
	} else if (looksLikeGit(workDirFile)) {
	info = parseInfo(getGitSvnInfo(workDirFile));

	// Add a 'M' tag if this working copy is not pristine.
	if (!doesGitWorkingCopyMatchSvnRevision(workDirFile, info.revision)) {
	info.revision += "M";
	}
	} else {
	info = new Info("unknown", "unknown");
	}
	getProject().setNewProperty(outprop, info.branch + "@" + info.revision);
	} else {
	String propval = getProject().getProperty(outprop);
	if (!propval.matches("[^@]+@[0-9]+")) {
	throw new BuildException(
	"predefined " + outprop +
	"should look like branch-spec@revison-number");
	}
	}
	if (fileprop != null) {
	String outpropval = getProject().getProperty(outprop);
	int atIndex = outpropval.indexOf('@');
	String branch = outpropval.substring(0, atIndex);
	String revision = outpropval.substring(atIndex + 1);

	getProject().setNewProperty(fileprop,
	branch.replace('/', '-') + "-" + revision.replace(':', '-'));
	}
	}

	/**
	* Establishes the directory used as the SVN workspace to fetch version
	* information.
	*
	* @param srcdir workspace directory name
	*/
	public void setDirectory(String srcdir) {
	workdir = srcdir;
	}

	/**
	* Establishes the property containing the SVN output string, branch@rev.
	*
	* @param propname Name of a property
	*/
	public void setOutputFileProperty(String propname) {
	fileprop = propname;
	}

	/**
	* Establishes the property containing the SVN output string, branch@rev.
	*
	* @param propname Name of a property
	*/
	public void setOutputProperty(String propname) {
	outprop = propname;
	}
	}