scm-git.xml

<project name="scm-git" basedir="./" xmlns:antcontrib="antlib:net.sf.antcontrib">

	<include file="ant-util.xml" />
	<property name="use.jgit" value="true" />
	<macrodef name="git">
		<attribute name="command" />
		<attribute name="dir" default="${basedir}" />
		<attribute name="use-jgit" default="${use.jgit}" />
		<attribute name="verbose" default="true" />
		<element name="args" optional="true" />
		<sequential>
			<abspath path="@{dir}" property="__git.dir" />
			<antcontrib:var name="git.results" unset="true" />
			<antcontrib:if>
				<or>
					<equals arg1="@{command}" arg2="archive" />
					<equals arg1="@{command}" arg2="pull" />
					<equals arg1="@{use-jgit}" arg2="false" />
				</or>
				<then>
					<echo message="Using system Git - command: @{command}" />
					<antcontrib:trycatch>
					<try>
						<exec executable="git" dir="${__git.dir}" outputproperty="git.results" failifexecutionfails="true" failonerror="true">
							<arg value="@{command}" />
							<args />
						</exec>
					</try>
					<catch>
						<fail message="${git.results}"/>
					</catch>
					</antcontrib:trycatch>
				</then>
				<else>
					<dependency artifactId="jgit-cli" groupId="cfdistro.lib" version="2.0.0.0" dest="${cfdistro.lib.dir}" type="jar" unzip="false"/>
					<args2property property="gitcmdline"><args /></args2property>
					<echo message="JGit - command: @{command} ${gitcmdline} (${__git.dir})" /><!-- <echoxml><elem /></echoxml> -->
					<antcontrib:trycatch property="foo" reference="bar">
						<try>
						<java classname="org.eclipse.jgit.pgm.Main" classpathref="build.lib.path" fork="true" dir="${__git.dir}" outputproperty="git.results" failonerror="true">
							<arg value="@{command}" />
							<args />
			            </java>
						</try>
						<catch>
							<property name="baz" refid="bar" />
							<fail message="error occurred : ${git.results} ${baz}" />
						</catch>
					</antcontrib:trycatch>

					<antcontrib:propertyregex override="yes" property="jgit.exception" input="${git.results}" 
						regexp=".*?(org.eclipse.jgit.api.errors.JGitInternalException)+.*?" select="\1" />
					<antcontrib:if>
						<equals arg1="${jgit.exception}" arg2="org.eclipse.jgit.api.errors.JGitInternalException" />
						<then><fail message="${git.results}"/></then>
					</antcontrib:if>
				</else>
			</antcontrib:if>
			<antcontrib:if>
				<equals arg1="@{verbose}" arg2="true" />
				<then>
					<echo message="${git.results}" />
				</then>
			</antcontrib:if>
		</sequential>
	</macrodef>

	<macrodef name="git-local-branchname">
		<attribute name="branch" />
		<attribute name="remote" />
		<attribute name="property" />
		<sequential>
			<antcontrib:if>
				<contains string="@{branch}" substring="/" casesensitive="false" />
				<then><antcontrib:var name="@{property}" value="@{branch}" /></then>
				<else><antcontrib:var name="@{property}" value="@{remote}/@{branch}" /></else>
			</antcontrib:if>
		</sequential>
	</macrodef>

	<macrodef name="git-export">
		<attribute name="repository" />
		<attribute name="dest" />
		<attribute name="path" default="/" />
		<attribute name="tag" default="HEAD" />
		<sequential>
			<mkdir dir="@{dest}" />
			<antcontrib:if>
				<or>
					<contains string="@{repository}" substring="github" casesensitive="false" />
				</or>
				<then>
					<antcontrib:var name="git.temp" unset="true" />
					<property name="git.temp" location="${temp.dir}/git-temp" />
					<echo message="no .git dir, let us try to get one- this may take a bit..." />
					<delete dir="${git.temp}"/>
					<mkdir dir="${git.temp}"/>
                    <git-checkout uri="@{repository}" gitdir="${git.temp}" remote="origin" branch="@{tag}" />
					<move todir="@{dest}">
					    <fileset dir="${git.temp}/@{path}"/>
					</move>
					<!--
					<copy todir="@{dest}">
						<fileset dir="${git.temp}">
				            <include name="@{path}"/>
						</fileset>
						<regexpmapper handledirsep="yes"
						from="@{path}(.*)"
						to="\1" />
					</copy>
					-->
					<!--
					<delete dir="${git.temp}"/>
					-->
				</then>
				<else>
					<git command="archive" dir="@{dest}">
						<args>
							<!-- <arg value="-a" /> -->
							<arg value="--format" />
							<arg value="zip" />
							<arg value="--output" />
							<arg value="src.zip" />
							<arg value="--remote" />
							<arg value="@{repository}" />
							<arg value="@{tag}" />
							<arg value="-0" />
						</args>
					</git>
					<unzip src="@{dest}/src.zip" dest="@{dest}">
				        <patternset>
				            <include name="@{path}"/>
				        </patternset>
						<regexpmapper handledirsep="yes"
						from="@{path}(.*)"
						to="\1" />
					</unzip>
					<delete file="@{dest}/src.zip"/>
				</else>
			</antcontrib:if>
		</sequential>
	</macrodef>

	<macrodef name="git-currentbranch">
		<attribute name="dir" />
		<sequential>
			<git command="branch" dir="@{dir}" />
			<antcontrib:propertyregex override="yes" property="git.current.branch" input="${git.results}" 
				regexp=".*?\*\s(.*)?\s" select="\1" />
			<echo message="******** current branch: ${git.current.branch}"/>
		</sequential>
	</macrodef>

	<macrodef name="git-checkout">
		<attribute name="uri" default="" />
		<attribute name="gitdir" />
		<attribute name="remote" default="origin" />
		<attribute name="branch" default="master" />
		<attribute name="pristine" default="false"/>
		<attribute name="use-jgit" default="${use.jgit}" />
		<sequential>
			<abspath path="@{gitdir}" property="__git.checkout.dir" />
			<git-local-branchname property="_git.branch" branch="@{branch}" remote="@{remote}" />
			<antcontrib:if>
				<or>
					<available file="${__git.checkout.dir}/HEAD"/>
					<available file="${__git.checkout.dir}/.git"/>
				</or>
				<then>
					<antcontrib:if>
						<equals arg1="@{use-jgit}" arg2="true"/>
						<then><!-- jgit-checkout will fetch for us --></then>
						<else>
							<git command="fetch" dir="${__git.checkout.dir}" use-jgit="@{use-jgit}">
								<args><arg value="@{remote}" /></args>
							</git>
						</else>
					</antcontrib:if>
				</then>
				<else>
					<antcontrib:if>
						<available file="${__git.checkout.dir}"/>
						<then>
							<delete dir="${temp.dir}/git-temp" />
							<mkdir dir="${temp.dir}/git-temp" />
							<git command="clone" dir="${temp.dir}" use-jgit="@{use-jgit}">
								<args>
									<arg value="@{uri}" />
									<arg value="git-temp" />
									<arg value="--origin=@{remote}" />
								</args>
							</git>
							<move file="${temp.dir}/git-temp/.git" toDir="${__git.checkout.dir}"/>
						</then>
						<else>
							<mkdir dir="${__git.checkout.dir}" />
							<git command="clone" dir="${__git.checkout.dir}" use-jgit="@{use-jgit}">
								<args>
									<arg value="@{uri}" />
									<arg value="${__git.checkout.dir}" />
									<arg value="--origin=@{remote}" />
								</args>
							</git>
						</else>
					</antcontrib:if>
				</else>
			</antcontrib:if>
			<antcontrib:if>
				<equals arg1="@{use-jgit}" arg2="true"/>
				<then>
					<jgit-checkout gitdir="${__git.checkout.dir}" remote="@{remote}" branch="${_git.branch}" uri="@{uri}" pristine="@{pristine}" />
				</then>
				<else>
					<git command="checkout" dir="${__git.checkout.dir}" use-jgit="@{use-jgit}">
						<args>
							<arg value="-f" />
							<arg value="${_git.branch}" />
						</args>
					</git>
					<antcontrib:if>
						<equals arg1="@{pristine}" arg2="true"/>
						<then>
							<git command="clean" dir="${__git.checkout.dir}" use-jgit="@{use-jgit}">
								<args>
									<arg value="-xdf" />
								</args>
							</git>
						</then>
					</antcontrib:if>
				</else>
			</antcontrib:if>
		</sequential>
	</macrodef>

	<macrodef name="git-clone-pull">
		<attribute name="repository" />
		<attribute name="dest" />
		<sequential>
			<git command="clone">
				<args>
					<arg value="@{repository}" />
					<arg value="@{dest}" />
				</args>
			</git>
			<git command="pull" dir="@{dest}" />
		</sequential>
	</macrodef>

	
	<target name="test.commithash">
		<git-reset-hard repository="/workspace/cfdistro/src/cfdistro/testing/temp/testproject/src" />
	</target>
	
	<scriptdef name="git-commit-hash" language="javascript" classpathref="build.lib.path">
		<attribute name="repository" />
		<attribute name="property" />
		<attribute name="remote"/>
		<attribute name="branch" />
	    <![CDATA[
		try{ load("nashorn:mozilla_compat.js"); } catch (e) {}; //java8
		if (typeof println == 'undefined') this.println = print;  //java8
		importClass(org.eclipse.jgit.api.Git);
		importClass(org.eclipse.jgit.storage.file.FileRepositoryBuilder);
		importClass(java.io.File);
	    var gitdir = new File(attributes.get( "repository" ));
	    var remote = attributes.get( "remote" ) ? attributes.get( "remote" ) : "";
	    var branch = attributes.get( "branch" ) ? attributes.get( "branch" ) : "master";
	    var property = attributes.get( "property" );
        var repository = new FileRepositoryBuilder().findGitDir(gitdir).build();
        var git = new Git(repository);
        var log = git.log();
		if(remote != "") {
			var ref = repository.getRefDatabase().getRef("refs/remotes/" + remote + "/" + branch);
		} else {
			var ref = repository.getRefDatabase().getRef("refs/heads/" + branch);
		}
		if(ref != null) {
		    try{
			    log.add(ref.getObjectId());
		    } catch (er) {
                ref = repository.peel(ref);
		        log.add(ref.getPeeledObjectId());
		    }
			log.setMaxCount(1);
			var commit = log.call().next();
	        if (commit != null) {
    		    //println(commit.getFullMessage());
    		    println(commit.getName());
				project.setProperty(property, commit.getName());
	        }
		} else {
			println("Could not find branch: " + branch);
		}
		repository.close();
	    ]]> 
	</scriptdef>
	
	<scriptdef name="jgit-checkout" language="javascript" classpathref="build.lib.path">
		<attribute name="uri" />
		<attribute name="gitdir" />
		<attribute name="remote" />
		<attribute name="branch" />
		<attribute name="pristine" />
	    <![CDATA[
		try{ load("nashorn:mozilla_compat.js"); } catch (e) {}; //java8
		if (typeof println == 'undefined') this.println = print;  //java8
		importClass(org.eclipse.jgit.api.Git);
		importClass(org.eclipse.jgit.storage.file.FileRepositoryBuilder);
		importClass(org.eclipse.jgit.api.CreateBranchCommand);
		importClass(org.eclipse.jgit.api.ResetCommand);
		importClass(org.eclipse.jgit.api.MergeResult);
		importClass(org.eclipse.jgit.lib.Constants);
		importClass(org.eclipse.jgit.revwalk.RevWalk);
		importClass(org.eclipse.jgit.transport.RefSpec);
		importClass(java.io.File);
	    var gitdir = new File(attributes.get( "gitdir" ));
	    var uri = attributes.get( "uri" ) ? attributes.get( "uri" ) : "";
	    var remote = attributes.get( "remote" ) ? attributes.get( "remote" ) : "origin";
	    var branch = attributes.get( "branch" ) ? attributes.get( "branch" ) : "master";
	    var pristine = attributes.get( "pristine" ) ? attributes.get( "pristine" ) : "false";
		var createBranch = true;
        var repository = new FileRepositoryBuilder().findGitDir(gitdir).build();
        var git = new Git(repository);
		if(uri.length > 0) {
			println(remote+" is at " + uri);
			var config = git.getRepository().getConfig();
			config.setString("remote", remote, "url", uri);
			config.setString("remote", remote, "fetch", "+refs/heads/*:refs/remotes/"+remote+"/*");
		// +refs/tags/*
			config.save();
		}
		var specs=new java.util.ArrayList();
		specs.add(new RefSpec("+refs/heads/*:refs/remotes/"+remote+"/*"));
	    specs.add(new RefSpec("+refs/tags/*:refs/tags/*"));
	    specs.add(new RefSpec("+refs/notes/*:refs/notes/*"));
		println("Fetching " + branch + " from " + remote + " " + uri);
		git.fetch().setRemote(remote).setRefSpecs(specs).call();
		var branches = git.branchList().call().iterator();
		while (branches.hasNext()){
			var branchObj = branches.next();
			if(branchObj.getName() == "refs/heads/" + branch) {
				createBranch = false;
			}
		}
		if(createBranch) {
			println(branch + " will be created locally");
		} else {
			println(branch + " exists locally");
		}
		println("checking out " + branch);
        var tags = git.tagList().call().iterator();
		if(branch.contains("/")){
			var startPoint = branch; 
		} else {
			var startPoint = remote + "/" + branch;
		}
        while (tags.hasNext()){
            var tagObj = tags.next();
		print(tagObj.getName());
            if(tagObj.getName() == "refs/tags/" + branch
                || tagObj.getName() == "refs/tags/" + branch.split("/")[1]) {
                startPoint = tagObj.getName();
                println("reference: " + startPoint);
            }
        }

		try {
			git.checkout().
				setForce(true).
		        setCreateBranch(createBranch).
		 		setUpstreamMode(org.eclipse.jgit.api.CreateBranchCommand.SetupUpstreamMode.TRACK).
		        setName(branch).
		        setStartPoint(startPoint).
		        call();
        } catch (e) {
			paths = e.javaException.getConflictingPaths().iterator();
            while (paths.hasNext()) {
				var path = paths.next();
                var conflict = new File(repository.getWorkTree(), path);
                println("[WARNING] deleting conflicting path " + conflict);
                if (!conflict["delete"]()) { // call delete like this for odd windows bug
                    if (conflict.exists()) {
                        println("[WARNING] conflicting path " + conflict + " not deleted");
                    }
                }
            }
			git.checkout().
				setForce(true).
		        setCreateBranch(false).
		        setName(branch).
		        setStartPoint(startPoint).
		        call();
		}
		var HEAD = repository.resolve(org.eclipse.jgit.lib.Constants.HEAD);
		var walk = new RevWalk(repository);
		walk.markStart(walk.parseCommit(HEAD));
		var commit = walk.iterator().next();
		println("HEAD is now at "+HEAD.getName().substring(0,7) + " " + commit.getShortMessage());
		if(pristine == "true") {
			println("making pristine - removing all untracked files ("+gitdir+")");
			var cleaned = git.clean().setCleanDirectories(true).setIgnore(false).call().iterator();
			while (cleaned.hasNext()){
	        	println("Removing " + cleaned.next());
			}
		}
		repository.close()
	    ]]> 
	</scriptdef>
	
	<scriptdef name="git-reset-hard" language="javascript" classpathref="build.lib.path">
		<attribute name="repository" />
		<attribute name="remote"/>
		<attribute name="branch" />
	    <![CDATA[
		try{ load("nashorn:mozilla_compat.js"); } catch (e) {}; //java8
		importClass(org.eclipse.jgit.api.Git);
		importClass(org.eclipse.jgit.storage.file.FileRepositoryBuilder);
		importClass(org.eclipse.jgit.api.ResetCommand);
		importClass(org.eclipse.jgit.api.ResetCommand.ResetType);
		importClass(org.eclipse.jgit.lib.Constants);
		importClass(java.io.File);
	    var gitdir = new File(attributes.get( "repository" ));
	    var remote = attributes.get( "remote" ) ? attributes.get( "remote" ) : "origin";
	    var branch = attributes.get( "branch" ) ? attributes.get( "branch" ) : "master";
	    var property = attributes.get( "property" );
        var repository = new FileRepositoryBuilder().findGitDir(gitdir).build();
        var git = new Git(repository);
		var reset = git.reset();
		if (typeof println == 'undefined') this.println = print;  //java8
		if(remote != "") {
			var ref = repository.getRefDatabase().getRef("refs/remotes/" + remote + "/" + branch);
		} else {
			var ref = repository.getRefDatabase().getRef("refs/heads/" + branch);
		}
		var hardClazz = new FileRepositoryBuilder().getClass().getClassLoader().loadClass("org.eclipse.jgit.api.ResetCommand$ResetType");
		var hard = hardClazz.getDeclaredField("HARD").get(hardClazz);
		reset.setMode(hard);
		reset.setRef(org.eclipse.jgit.lib.Constants.HEAD);
		//reset.setRef(ref);
		reset.call();
		println("reset " + gitdir + " hard");
/*
		log.add(ref.getObjectId());
		log.setMaxCount(1);
		var commit = log.call().next();
        if (commit != null) {
			project.setProperty(property, commit.getName());
			println(commit.getName() + " ("+ remote + "/" + branch + ")");
        }
*/		
		repository.close();
	    ]]> 
	</scriptdef>
	
	<macrodef name="git-commit-hash2">
		<attribute name="repository" />
		<attribute name="property" />
		<attribute name="remote" default="origin" />
		<attribute name="branch" default="master" />
		<sequential>
			<java jar="/Users/valliant/cfdistro/lib/jgit-cli.jar" classpathref="build.lib.path" fork="true" dir="@{repository}" 
				failonerror="true" clonevm="true">
				<arg value="--git-dir" /> 
				<arg value="@{repository}" /> 
				<arg line="log origin/master HEAD^..HEAD " />
            </java>
			<!--
			<git command="log" dir="@{repository}"><args><arg value="@{remote}/@{branch}"/><arg value="HEAD^..HEAD"/></args></git>
            -->
			<antcontrib:propertyregex override="yes" property="@{property}" input="${git.results}" regexp=".*commit\s(.\w+).*" select="\1" />
		</sequential>
	</macrodef>

	<target name="jgit.help">
		<git command="branch">
			<args>
				<arg value="-h" />
			</args>
		</git>
	</target>

	<target name="src.import.git" depends="exists.src.xml">
		<xmltask sourcebuffer="src.buff">
			<call path="src/sources/src[@type='git']">
				<param name="dest" path="@dest" default="NONE" />
				<param name="type" path="@type" default="NONE" />
				<param name="uri" path="@uri" default="NONE" />
				<param name="path" path="@path" default="" />
				<param name="tag" path="@tag" default="HEAD" />
				<actions>
					<echo message="importing @{uri} @{tag} to src: ${src.dir}/@{dest}" />
					<git-export repository="@{uri}" dest="${src.dir}/@{dest}" path="@{path}" tag="@{tag}"/>
				</actions>
			</call>
		</xmltask>
	</target>

	<target name="git.public.repo">
		<property name="git.repo.dir" value="../../${distro.name}.git" />
		<mkdir dir="${git.repo.dir}" />
		<git command="init" dir="${git.repo.dir}">
			<args>
				<arg value="--bare" />
			</args>
		</git>
		<git command="config" dir="${git.repo.dir}">
			<args>
				<arg value="core.worktree" />
				<arg value="../${distro.name}" />
			</args>
		</git>
		<git command="config" dir="${git.repo.dir}">
			<args>
				<arg value="core.bare" />
				<arg value="false" />
			</args>
		</git>
		<git command="config" dir="${git.repo.dir}">
			<args>
				<arg value="receive.denycurrentbranch" />
				<arg value="ignore" />
			</args>
		</git>
		<echo file="${git.repo.dir}/hooks/post-receive" message="#!/bin/sh/git checkout -f"/>
	</target>
	
	<target name="project.update.git" depends="exists.src.xml">
		<property name="temp.dir.absolute" location="${temp.dir}" />
		<antcontrib:var name="temp.dir" unset="true" />
		<property name="temp.dir" location="${temp.dir.absolute}" />				
		<property name="project.update.force" value="false" />				
		<xmltask sourcebuffer="src.buff">
			<call path="src/project/src[@type='git']">
				<param name="dest" path="@dest" default="NONE" />
				<param name="type" path="@type" default="NONE" />
				<param name="uri" path="@uri" default="NONE" />
				<param name="branch" path="@branch" default="master" />
				<param name="remote" path="@remote" default="origin" />
				<param name="sshkey" path="@sshkey" default="NONE" />
				<actions>
					<git-local-branchname property="_git.branch" branch="@{branch}" remote="@{remote}" />
					<abspath path="@{dest}" property="__git.dir" />
					<antcontrib:if>
						<equals arg1="${project.overwrite}" arg2="true" />
						<then>
							<echo message="$${project.overwrite} is true, we're resetting it all to pristine condition." />
							<git-checkout uri="@{uri}" gitdir="${__git.dir}" remote="@{remote}" branch="${_git.branch}" pristine="true" />
						</then>
						<else>
							<git-has-modifications dir="${__git.dir}" remote="@{remote}" branch="@{branch}" property="git.hasmods" />
							<antcontrib:if>
								<and>
									<equals arg1="${git.hasmods}" arg2="true"/>
									<equals arg1="${scm.autobranch}" arg2="true"/>
								</and>
								<then>
									<antcontrib:var name="NOW_BRANCH" unset="true" />
									<antcontrib:var name="revisions.remote.differ" value="true" />
									<tstamp><format property="NOW_BRANCH" pattern="yyyyMMdd_HHmmss"/></tstamp>
									<echo message="Detected local modifications, stashing sources in autobranch${NOW_BRANCH}" />
									<git command="checkout" dir="@{dest}">
										<args>
											<arg line="-b autobranch${NOW_BRANCH}" />
										</args>
									</git>
									<git command="add" dir="@{dest}">
										<args><arg line="." /></args>
									</git>
									<git command="commit" dir="@{dest}">
										<args><arg line="-a -m 'autocommit'" /></args>
									</git>
									<git-checkout uri="@{uri}" gitdir="@{dest}" remote="@{remote}" branch="${_git.branch}" />
								</then>
								<else>
									<git-checkout uri="@{uri}" gitdir="@{dest}" remote="@{remote}" branch="${_git.branch}" />
								</else>
							</antcontrib:if>
						</else>
					</antcontrib:if>
				</actions>
			</call>
		</xmltask>
	</target>
	
	<target name="project.diff.git">
		<property name="temp.dir.absolute" location="${temp.dir}" />
		<antcontrib:var name="temp.dir" unset="true" />
		<property name="branch" value="master" />				
		<property name="temp.dir" location="${temp.dir.absolute}" />				
		<property name="project.update.force" value="false" />
		<antcontrib:runtarget target="exists.src.xml" />				
		<xmltask sourcebuffer="src.buff">
		<call path="src/project/src[@type='git']">
			<param name="dest" path="@dest" default="NONE" />
			<param name="type" path="@type" default="NONE" />
			<param name="uri" path="@uri" default="NONE" />
			<param name="branch" path="@branch" default="${branch}" />
			<param name="sshkey" path="@sshkey" default="NONE" />
			<actions>
				<git-local-branchname property="_git.branch" branch="@{branch}" remote="@{remote}" />
				<echo message="Diffing @{dest} with ${_git.branch}"/>
				<git command="diff" dir="@{dest}/">
					<args>
						<arg value="${_git.branch}" />
					</args>
				</git>
				<echo message="${git.results}"/>
			</actions>
		</call>
		</xmltask>
	</target>
	
	<target name="project.checkout.git">
		<antcontrib:runtarget target="exists.src.xml" />				
		<xmltask sourcebuffer="src.buff">
			<call path="src/project/src[@type='git']">
				<param name="dest" path="@dest" />
				<param name="uri" path="@uri" />
				<param name="remote" path="@remote" default="origin" />
				<param name="branch" path="@branch" default="master" />
				<actions>
					<git-local-branchname property="_git.branch" branch="@{branch}" remote="@{remote}" />
					<git-checkout uri="@{uri}" gitdir="@{dest}" remote="@{remote}" branch="${_git.branch}" />
				</actions>
			</call>
		</xmltask>
	</target>
	
	<target name="check.project.for.newrevision.git">
		<!-- check for local commits -->
		<xmltask sourcebuffer="src.buff">
			<call path="src/project/src[@type='git']">
				<param name="dest" path="@dest" default="NONE" />
				<param name="type" path="@type" default="NONE" />
				<param name="uri" path="@uri" default="NONE" />
				<param name="remote" path="@remote" default="origin" />
				<param name="branch" path="@branch" default="master" />
				<actions>
                    <git-local-branchname property="_git.branch" branch="@{branch}" remote="@{remote}" />
					<antcontrib:var name="revisions.are.same" value="true"/>
					<antcontrib:var name="desthash" unset="true"/>
					<antcontrib:var name="pre.fetch.commit.hash" unset="true"/>
					<abspath path="@{dest}" property="__git.dir" />
					<safestring value="@{dest}" property="desthash"/>
					<echo message="DestHash: ${desthash}"/>
					<git-commit-hash repository="${__git.dir}" remote="" branch="${_git.branch}" property="pre.fetch.commit.hash" />
					<propertyfile file="${basedir}/scm.cache" comment="source control management cache">
						<entry key="${desthash}.last.commit.hash" default="${pre.fetch.commit.hash}" />
						<entry key="${desthash}.current.commit.hash" value="${pre.fetch.commit.hash}" />
					</propertyfile>
					<property file="${basedir}/scm.cache" />
					<antcontrib:propertycopy name="desthash.last.commit.hash" from="${desthash}.last.commit.hash" override="true"/>
					<antcontrib:propertycopy name="desthash.current.commit.hash" from="${desthash}.current.commit.hash" override="true"/>
					<!-- <echo>${desthash.last.commit.hash}" arg2="${desthash.current.commit.hash}</echo> -->
					<antcontrib:if>
						<equals arg1="${desthash.last.commit.hash}" arg2="${desthash.current.commit.hash}" />
						<then>
							<echo message="Local revision is unchanged" />
						</then>
						<else>
							<property name="revisions.local.differ" value="true" />
							<antcontrib:var name="revisions.are.same" value="false"/>
							<echo message="Local revision differs" />
						</else>
					</antcontrib:if> 
					<!-- check for remote commits (defaults to origin) -->
					<antcontrib:trycatch reference="fetcherr">
					<try>
						<git command="fetch" dir="@{dest}">
							<args><arg value="@{remote}" /></args>
						</git>
					</try>
					<catch>
						<property name="fetcherr" refid="fetcherr" />
						<echo message="${fetcherr}"/>
					</catch>
					</antcontrib:trycatch>
					<git-commit-hash repository="${__git.dir}" remote="" branch="${_git.branch}" property="post.fetch.commit.hash" />
					<antcontrib:if>
						<equals arg1="${pre.fetch.commit.hash}" arg2="${post.fetch.commit.hash}" />
						<then>
							<echo message="Remote revision is the same" />
						</then>
						<else>
							<antcontrib:var name="revisions.are.same" value="false"/>
							<property name="revisions.remote.differ" value="true" />
							<echo message="Remote revision differs" />
						</else>
					</antcontrib:if>
					<!-- update hash now.  This process only fires once, even if the build fails (prevent endless build loop) -->
					<propertyfile file="${basedir}/scm.cache" comment="source control management cache">
						<entry key="${desthash}.last.commit.hash" value="${desthash.current.commit.hash}" />
						<entry key="${desthash}.current.commit.hash" value="${desthash.current.commit.hash}" />
					</propertyfile>
				</actions>
			</call>
		</xmltask>
		<echoproperties prefix="revisions"/>
	</target>

	<macrodef name="args2property">
		<attribute name="property" default="false" />
		<attribute name="namespacePolicy" default="ignore" />
		<element name="xml" implicit="true" optional="true" />
		<sequential>
			<antcontrib:var unset="true" name="@{property}" />
			<tempfile property="__xml_file.temp" prefix="args2props" />
			<echoxml file="${__xml_file.temp}" namespacePolicy="@{namespacePolicy}" >
				<placeholderbrah>
				<xml />
				</placeholderbrah>
			</echoxml>
			<ant-set-log-level level="0"/>
			<taskdef-dependency name="xmltask" classname="com.oopsconsultancy.xmltask.ant.XmlTask" artifactId="xmltask-v1-16-1" groupId="cfdistro.lib" version="1.0.0.0" />
			<xmltask source="${__xml_file.temp}">
				<copy path="placeholderbrah/arg/@value" attrValue="true" property="@{property}" append="true"/>
			</xmltask>
			<delete file="${__xml_file.temp}" />
			<ant-set-log-level level="2"/>
			<!-- default to nothing if no args -->
			<property name="@{property}" value="" />
		</sequential>
	</macrodef>
	
	<macrodef name="git-has-modifications">
		<attribute name="dir" />
		<attribute name="property" />
		<attribute name="remote" default="origin" />
		<attribute name="branch" default="master" />
		<sequential>
			<antcontrib:trycatch reference="fetcherr">
			<try>
				<git command="diff" dir="@{dir}/">
					<args>
						<arg value="--name-status" />
						<arg value="@{remote}/@{branch}" />
					</args>
				</git>
				<antcontrib:propertyregex override="yes" property="git.hasmodifications" input="${git.results}" 
					regexp="(^[M|A])\s+.*" select="\1" />
				<antcontrib:if>
					<or>
					<equals arg1="${git.hasmodifications}" arg2="M" />
					<equals arg1="${git.hasmodifications}" arg2="A" />
					</or>
					<then><antcontrib:var name="@{property}" value="true"/></then>
					<else><antcontrib:var name="@{property}" value="false"/></else>
				</antcontrib:if>
			</try>
			<catch>
				<property name="fetcherr" refid="fetcherr" />
				<echo message="checking for modifications failed, setting @{property} to true : ${fetcherr}"/>
				<antcontrib:var name="@{property}" value="true"/>
			</catch>
			</antcontrib:trycatch>
		</sequential>
	</macrodef>
	
	<macrodef name="diff-with-git">
		<attribute name="source" />
		<attribute name="temp-dir" default="${temp.dir}/git-diff-temp" />
		<attribute name="uri" />
		<attribute name="patchfile" default="${basedir}/patch-for-git.txt" />
		<attribute name="tag" default="HEAD" />
		<sequential>
			<delete dir="@{temp-dir}" />
			<mkdir dir="@{temp-dir}" />
            <git-checkout uri="@{uri}" gitdir="@{temp-dir}" remote="origin" branch="@{tag}" />
			<copy todir="@{temp-dir}" verbose="false" overwrite="true">
				<fileset dir="@{source}" />
			</copy>
			<git command="diff" dir="@{temp-dir}/" />
			<echo file="@{patchfile}" message="${git.results}" />
		</sequential>
	</macrodef>
	
    <macrodef name="git-fetch-from-remote">
        <sequential>
        	<load-src-xml />
    		<xmltask sourcebuffer="src.buff">
    			<call path="src/project/src[@type='git']">
    				<param name="dest" path="@dest" default="NONE" />
    				<param name="type" path="@type" default="NONE" />
    				<param name="uri" path="@uri" default="NONE" />
    				<param name="branch" path="@branch" default="master" />
    				<param name="remote" path="@remote" default="origin" />
    				<actions>
						<!--  get branches -->
    					<abspath path="@{dest}" property="__git.dir" />
						<git command="fetch" dir="${__git.dir}">
							<args>
								<arg value="@{remote}" />
								<arg value="+refs/heads/*:refs/remotes/@{remote}/*" />
							</args>
						</git>
						<!--  get tags -->
						<git command="fetch" dir="${__git.dir}">
							<args>
								<arg value="@{remote}" />
								<arg value="+refs/tags/*:refs/remotes/@{remote}/*" />
							</args>
						</git>
						<git command="fetch" dir="@{dest}">
							<args><arg value="@{remote}" /></args>
						</git>
					</actions>
				</call>
    		</xmltask>
        </sequential>
    </macrodef>
    
	<target name="exists.src.xml">
		<antcall target="cfdistro.exists.src.xml" />
	</target>
	
	
</project>