SharpArch.build

<?xml version="1.0" ?>
<!--EXTERNAL_PROPERTIES: build.number -->
<!--EXTERNAL_PROPERTIES: build.vcs.number.1 -->
<project name="SharpArch" default="build-and-package" xmlns="http://nant.sf.net/schemas/nant.xsd">
	<property name="nant.settings.currentframework" value="net-4.0" />
	<property name="project.config" value="debug" />
	<property name="company.name" value="Codai, LLC"/>

	<!-- Version -->
	<property name="version.major" value="1"/>
	<property name="version.minor" value="9"/>
	<property name="version.build" value="5"/>
	<property name="version.revision" value="0" />
	<property name="project.fullversion" value="${version.major}.${version.minor}.${version.build}" dynamic="true" />

  <!-- Directories and files -->
	<property name="build.dir" value="build" />
	<property name="solution.dir" value="src\${project::get-name()}"/>
	<property name="solution.file" value="${solution.dir}\${project::get-name()}.sln"/>
	<property name="results.dir" value="${build.dir}\results" />
	<property name="docs.dir" value="docs" />
	<property name="lib.dir" value="bin" />
	<property name="tools.dir" value="tools" />
	<property name="ilmerge.dir" value="${tools.dir}\ILMerge" />
	<property name="log.file" value="${docs.dir}\merge.log" />

	<!-- Assemblies -->
	<property name="main.assembly.name" value="${build.dir}\SharpArch.dll" />
	<property name="key.file" value="${solution.dir}\${project::get-name()}.Core\${project::get-name()}.snk" />
	<property name="temp.assembly.name" value="${build.dir}\SharpArch.Core.dll" />
	<property name="test.assembly" value="${project::get-name()}.Tests.dll" />	

	<!-- User targets -->
	<target name="build-and-package" depends="build, package"></target>
	<target name="build-and-merge-to-bin" depends="build, move-to-bin"></target>
	<target name="build" depends="compile, test">
		<script language="C#" prefix="custom" >
			<references>
				<include name="System.dll" />
				<include name="NAnt.Core.dll" />
			</references>
			<imports>
				<import namespace="System" />
				<import namespace="System.Collections" />
				<import namespace="System.Collections.Specialized" />
				<import namespace="NAnt.Core.Types" />
				<import namespace="NAnt.Core.Util" />
				<import namespace="NAnt.Core.Tasks" />
			</imports>
			
			<code>
				<![CDATA[
					[TaskName("ilmerge")]
					public class ILMergeTask : ExternalProgramBase 
					{
					private FileSet m_assemblies;
					private string m_logFile;
					private string m_keyFile;
					private string m_outputFile;
					private string m_primaryFile;
					private bool internalize;
					
					[TaskAttribute("internalize")]
					[BooleanValidator()]
					public virtual bool Internalize
					{
					get { return internalize;}
					set { internalize = value;}
					}
					
					
					[TaskAttribute("program", Required = true)]
					[StringValidator(AllowEmpty = false)]
					public override string ExeName
					{
					get { return base.ExeName; }
					set { base.ExeName = value; }
					}
					
					
					public override string ProgramArguments
					{
					get { return string.Empty; }
					}
					
					[BuildElement("assemblies", Required=true)]
					public virtual FileSet InputAssemblies
					{
					get
					{
					return this.m_assemblies;
					}
					set
					{
					this.m_assemblies = value;
					}
					}
					
					[TaskAttribute("logfile")]
					public virtual string LogFile
					{
					get
					{
					if (this.m_logFile == null)
					{
					return null;
					}
					return this.Project.GetFullPath(this.m_logFile);
					}
					set
					{
					this.m_logFile = StringUtils.ConvertEmptyToNull(value);
					}
					}

					[TaskAttribute("keyfile")]
					public virtual string KeyFile
					{
					get
					{
					if (this.m_keyFile == null)
					{
                    return null;
					}
					return this.Project.GetFullPath(this.m_keyFile);
					}
					set
					{
					this.m_keyFile = StringUtils.ConvertEmptyToNull(value);
					}
					}
					
					[TaskAttribute("primary", Required=true), StringValidator(AllowEmpty=false)]
					public virtual string PrimaryFile
					{
					get
					{
					if (this.m_primaryFile == null)
					{
					return null;
					}
					return this.Project.GetFullPath(this.m_primaryFile);
					}
					set
					{
					this.m_primaryFile = StringUtils.ConvertEmptyToNull(value);
					}
					}                 
					
					[TaskAttribute("outputfile", Required=true), StringValidator(AllowEmpty=false)]
					public virtual string OutputFile
					{
					get
					{
					if (this.m_outputFile == null)
					{
					return null;
					}
					return this.Project.GetFullPath(this.m_outputFile);
					}
					set
					{
					this.m_outputFile = StringUtils.ConvertEmptyToNull(value);
					}
					}                 
					
					
					protected override void ExecuteTask()
					{
					try
					{
					Log(Level.Info, "Executing ILMerge.exe");
					Log(Level.Info, string.Format("/out:\"{0}\"", m_outputFile));
					Log(Level.Info, string.Format("/log:\"{0}\"", m_logFile));
					//Log(Level.Info, string.Format("/keyfile:\"{0}\"", m_keyFile));
					Arguments.Add(new Argument(string.Format("/out:\"{0}\"", m_outputFile)));
					
					Log(Level.Info, string.Format("assembly[{0}]: {1}", "primary", m_primaryFile));
					Arguments.Add(new Argument(string.Format("\"{0}\"", m_primaryFile)));
					
					
					//Arguments.Add(new Argument(string.Format("/keyfile:\"{0}\"", m_keyFile)));
					
					for (int i = 0; i < m_assemblies.FileNames.Count; i++)
					{
					Log(Level.Info, string.Format("assembly[{0}]: {1}", i, m_assemblies.FileNames[i]));
					Arguments.Add(new Argument(string.Format("\"{0}\"", m_assemblies.FileNames[i])));
					}
					
					Arguments.Add(new Argument(string.Format("/log:\"{0}\"", m_logFile)));
					Arguments.Add(new Argument(@"/targetplatform:v4, C:\Windows\Microsoft.NET\Framework\v4.0.30319"));
					
					if (Internalize)
					{
					Log(Level.Info, "/internalize");
					Arguments.Add(new Argument("/internalize"));
					}
					
					base.FailOnError = false;
					base.ExecuteTask();
					}
					catch (Exception ex)
					{
					throw new BuildException(string.Format("Error executing ILMerge {0}", "test"), Location, ex);
					}
					}
					}
				]]>
			</code>
		</script>		
		
		<ilmerge outputfile="${main.assembly.name}"
			primary="${temp.assembly.name}"
			program="${ilmerge.dir}\ilmerge.exe"
			logfile="${log.file}"
			keyfile="${key.file}"
			internalize="false">
			<assemblies>
				<include name="${build.dir}\SharpArch.Core.NHibernateValidator.dll" />
				<include name="${build.dir}\SharpArch.Data.dll" />
				<include name="${build.dir}\SharpArch.Testing.dll" />
				<include name="${build.dir}\SharpArch.Testing.MbUnit.dll" />
				<include name="${build.dir}\SharpArch.Testing.NUnit.dll" />
				<include name="${build.dir}\SharpArch.Wcf.dll" />
				<include name="${build.dir}\SharpArch.WcfClient.Castle.dll" />
				<include name="${build.dir}\SharpArch.Web.Castle.dll" />
				<include name="${build.dir}\SharpArch.Web.dll" />
			</assemblies>
		</ilmerge>
	</target>

	<target name="clean" description="Delete Automated Build artifacts">
		<delete dir="${build.dir}" if="${directory::exists(build.dir)}"/>
	</target>

	<target name="version" description="Generate AssemblyInfo">
		<property name="version.build" value="${build.number}" if="${property::exists('build.number')}"/>
		<property name="version.revision" value="${build.vcs.number.1}" if="${property::exists('build.vcs.number.1')}" />

		<echo message="Marking build with version ${project.fullversion}" />
		<delete file="${solution.dir}/CommonAssemblyInfo.cs" failonerror="false"/>
		<asminfo output="${solution.dir}/CommonAssemblyInfo.cs" language="CSharp">
			<imports>
				<import namespace="System.Reflection" />
				<import namespace="System.Runtime.InteropServices" />
			</imports>
			<attributes>
				<attribute type="ComVisibleAttribute" value="false" />
				<attribute type="AssemblyVersionAttribute" value="${project.fullversion}" />
				<attribute type="AssemblyFileVersionAttribute" value="${project.fullversion}" />
				<attribute type="AssemblyInformationalVersionAttribute" value="${project.fullversion}" />
				<attribute type="AssemblyCopyrightAttribute" value="Copyright © ${company.name} ${datetime::get-year(datetime::now())}" />
				<attribute type="AssemblyCompanyAttribute" value="${company.name}" />
				<attribute type="AssemblyConfigurationAttribute" value="${project.config}" />
				<attribute type="AssemblyTrademarkAttribute" value="" />
				<attribute type="AssemblyCultureAttribute" value="" />
			</attributes>
			<references>
				<include name="System.dll" />
			</references>
		</asminfo>
	</target>

	<target name="compile" description="Compiles the solution" depends="clean, version">
		<exec program="${framework::get-framework-directory(framework::get-target-framework())}\msbuild.exe"
				  commandline='${solution.file} /t:Clean /p:Configuration=${project.config} /p:Platform="Any CPU" /v:q'
					workingdir="." />
		<exec program="${framework::get-framework-directory(framework::get-target-framework())}\msbuild.exe"
				  commandline='${solution.file} /t:Rebuild /p:Configuration=${project.config} /p:Platform="Any CPU" /v:q'
					workingdir="." />
	</target>

	<target name="move-for-test" depends="compile">
		<copy todir="${build.dir}" flatten="true">
			<fileset basedir="${solution.dir}">
				<include name="/**/bin/${project.config}/**" />
			</fileset>
		</copy>
	</target>
	
	<target name="move-to-bin" depends="compile">
		<copy todir="bin" overwrite="true">
			<fileset basedir="${build.dir}">
				<include name="SharpArch.dll" />
				<include name="SharpArch.pdb" />
			</fileset>
		</copy>
	</target>

	<target name="test" depends="move-for-test">
    <mkdir dir="${results.dir}" />
    <exec program="${lib.dir}\nunit\nunit-console-x86.exe">
      <arg file="${build.dir}/${test.assembly}" />
      <arg value="/xml=${results.dir}\TestResult.xml" />
      <arg value="/nologo" />
      <arg value="/nodots" />
    </exec>
	</target>

	<target name="package" depends="compile">
		<zip zipfile="${build.dir}\${project::get-name()}-bin-${project.config}-${project.fullversion}.zip">
			<fileset basedir="${build.dir}" prefix="bin">
				<include name="*.*" />
			</fileset>
			<fileset basedir="${docs.dir}" prefix="doc">
				<include name="*.*" />
			</fileset>
		</zip>

		<zip zipfile="${build.dir}\${project::get-name()}-source-${project.fullversion}.zip">
			<fileset basedir=".">
				<include name="*.*" />
				<include name="src/**/*.*" />
				<include name="bin/**/*.*" />
				<exclude name="**/*.user" />
				<exclude name="**/*.cache" />
				<exclude name="**/*.suo" />
				<exclude name="src/**/bin/**" />
				<exclude name="**/obj/**" />
				<exclude name="**/_ReSharper.*/**" />
			</fileset>
		</zip>

		<zip zipfile="${build.dir}\${project::get-name()}-VSTemplate-${project.config}-${project.fullversion}.zip">
			<fileset basedir=".">
				<include name="VisualStudioTemplate/**/*.*" />
			</fileset>
		</zip>
	</target>
	
	

	
</project>