rake-dotnet 0.0.1 → 0.0.2

data/History.txt

@@ -1,3 +1,48 @@
+=== 0.0.2 / 2009-03-21
+
+* Several major enhancements
+
+	* Versioner
+		* Figure out a 4-token version number, major.minor.build.revision, taking:
+			* major.minor from version.template.txt
+			* build from ENV['BUILD_NUMBER'] (used by TeamCity)
+			* revision from svn working copy that the build is occurring in
+	
+	* AssemblyInfoTask
+		* Create AssemblyInfo.cs file(s) based on supplied AssemblyInfo.template.cs file(s)
+		* Perform token replacement within AssemblyInfo.cs to watermark assemblies with:
+			* major.minor.build.revision version number (from RDNVERSION)
+			* Product Name (from PRODUCT_NAME)
+			* Company Name (from COMPANY_NAME)
+			* Build configuration (from CONFIGURATION)
+	
+	* MsBuildTask
+		* Perform compilation of msbuild project files
+	
+	* HarvestOutputTask
+		* Harvest output of projects to a directory to act as main dumping ground to then zip up for build-artifacts to enable CI-parallelisation later
+		
+	* HarvestWebApplicationTask
+		* Harvest web-applications (greedily) to a directory
+	
+	* XUnitTask
+		* Run xunit.net tests from assemblies with *Tests* in filename
+	
+	* FxCopTask
+		* Run fxcop against assemblies whose filenames contain PRODUCT_NAME
+	
+	* NCoverTask
+		* Run ncover.console against assemblies to generate coverage data
+		* Run ncover.reporting against coverage data to generate coverage reports
+			* Limited to simple case in this release
+	
+	* RDNPackageTask
+		* Package a directory as a zip file, named like {name}-{configuration}-v{version}.zip
+		* Uses 7-zip, instead of rake's built-in PackageTask, which would have required taking a dependency on cygwin (7-zip is lighter)
+		
+	* A demo solution as an example of usage
+		* See http://my-svn.assembla.com/svn/nrws/trunk/rake_dotnet/lib/Demo
+
 === 0.0.1 / 2009-03-09
 
 * 1 major enhancement

data/Manifest.txt

@@ -2,6 +2,5 @@ History.txt
 Manifest.txt
 README.txt
 Rakefile
-bin/rake_dotnet
 lib/rake_dotnet.rb
 test/test_rake_dotnet.rb

data/README.txt

@@ -20,6 +20,8 @@ Rake dotnet is a bunch of things that aim at doing the work of creating a featur
 * Build the project files to produce said DLLs (call msbuild against the project file(s))
 * Run XUnit.NET unit tests against said DLLs, and output reports (wrap xunit.console.exe)
 * Run FxCop against said DLLs, and output reports (wrap fxcopcmd.exe)
+* Run NCover against build output to generate coverage metrics
+* Run NCover against coverage to generate coverage reports
 * Harvest build output
 * Package build output as a zip file, naming it like {product-name}-{configuration}-v{version}.zip
 
@@ -28,12 +30,11 @@ Rake dotnet is a bunch of things that aim at doing the work of creating a featur
 (In no particular order)
 * rdoc documentation to supplement blog'd about
 * Support other test-runners - nunit, mbunit, gallio
-* Change harvest/package to take file-glob include/exclude parameters (as rake's PackageTask) - allow more flexible building of packages
 * Support code-coverage runner(s) - ncover 1.68, ncover 3, partcover
 * Support clone-detective...?
 * Support other source-controls to get build version number - git, mercurial, cvs(?), TFS
-* Support 7z compression for packaging to eliminate cygwin dependency (7zip is easier/cleaner to get & maintain)
 * Support changing the conventions to allow users to specify their own source structure
+* Provide an InstallPad for the 3rdparty bits
 
 == REQUIREMENTS:
 

data/Rakefile

@@ -2,9 +2,10 @@
 
 require 'rubygems'
 require 'hoe'
-require './lib/rake_dotnet.rb'
+require 'Pathname'
+require 'rake/clean'
 
-Hoe.new('rake-dotnet', Rake_dotnet::VERSION) do |p|
+Hoe.new('rake-dotnet', '0.0.2') do |p|
   p.author = 'Peter Mounce'
   p.description = 'Making a .NET build-automation dev\'s life easier, one angle-bracket at a time'
   p.email = 'pete@neverrunwithscissors.com'
@@ -15,5 +16,25 @@ Hoe.new('rake-dotnet', Rake_dotnet::VERSION) do |p|
   p.extra_deps = ['rake']
 end
 
+generated_library = File.join('lib','rake_dotnet.rb')
+CLOBBER.include generated_library
+file generated_library do |f|
+	text = ''
+	files = ['header.rb','defaults.rb','assemblyinfo.rb','fxcop.rb','harvester.rb','msbuild.rb','ncover.rb','package.rb','sevenzip.rb','svn.rb','version.rb','xunit.rb']
+	gl = File.open(generated_library, 'a')
+	files.each do |file|
+		text = File.read(File.join('lib', file))
+		gl.puts text
+		gl.puts
+		gl.puts
+	end
+	gl.close unless gl.closed?
+end
+
+task :generate_lib => generated_library
+
+task :check_manifest => generated_library
+
+task :test => generated_library
 
 # vim: syntax=Ruby

data/lib/rake_dotnet.rb

@@ -1,3 +1,923 @@
-class Rake_dotnet
-  VERSION = '0.0.1'
-end
+#!/usr/bin/env ruby
+
+#--
+
+# Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 by Peter Mounce (pete@neverrunwithscissors.com)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+#++
+#
+# = Rake DotNet -- A collection of custom tasks for .NET build automation
+#
+# This is the main file for Rake DotNet custom tasks.  Normally it is referenced
+# as a library via a require statement, but it can be distributed
+# independently as an application.
+
+require 'rake'
+require 'rake/tasklib'
+require 'rake/clean'
+require 'pathname'
+
+
+desc "Displays this message; a list of tasks"
+task :help do
+  taskHash = Hash[*(`rake.cmd -T`.split(/\n/).collect { |l| l.match(/rake (\S+)\s+\#\s(.+)/).to_a }.collect { |l| [l[1], l[2]] }).flatten] 
+ 
+  indent = "                          "
+  
+  puts "rake #{indent}#Runs the 'default' task"
+  
+  taskHash.each_pair do |key, value|
+    if key.nil?  
+      next
+    end
+    puts "rake #{key}#{indent.slice(0, indent.length - key.length)}##{value}"
+  end
+end
+
+def regexify(path)
+	path.gsub('/', '\/').gsub('.', '\.')
+end
+
+# Setting constants like this allows you to do things like 'rake compile CONFIGURATION=Release' to specify their values
+# By default, we assume that this Rakefile lives in {PRODUCT_ROOT}/build, and that this is the working directory
+PRODUCT_ROOT = ENV['PRODUCT_ROOT'] ? ENV['PRODUCT_ROOT'] : '..'
+SRC_DIR = File.join(PRODUCT_ROOT, 'src')
+TOOLS_DIR = ENV['TOOLS_DIR'] ? ENV['TOOLS_DIR'] : File.join(PRODUCT_ROOT, '..', '3rdparty')
+CONFIGURATION = ENV['CONFIGURATION'] ? ENV['CONFIGURATION'] : 'Debug'
+MSBUILD_VERBOSITY = ENV['MSBUILD_VERBOSITY'] ? ENV['MSBUILD_VERBOSITY'] : 'm'
+OUT_DIR = ENV['OUT_DIR'] ? ENV['OUT_DIR'] : 'out'
+
+# clean will remove intermediate files (like the output of msbuild; things in the src tree)
+# clobber will remove build-output files (which will all live under the build tree)
+CLEAN.exclude('**/core') # core files are a Ruby/*nix thing - dotNET developers are unlikely to generate them.
+CLEAN.include("#{SRC_DIR}/**/obj")
+CLEAN.include("#{SRC_DIR}/**/bin")
+CLEAN.include("#{SRC_DIR}/**/AssemblyInfo.cs")
+CLOBBER.include(OUT_DIR)
+
+
+module Rake
+	class AssemblyInfoTask < Rake::TaskLib
+		attr_accessor :name, :product_name, :configuration, :company_name, :version
+
+		# Create an AssemblyInfo file-task; define a task to run it whose name is :assembly_info
+		def initialize(name) # :yield: self
+			@name = name
+			yield self if block_given?
+			define
+		end
+
+		# Create the tasks defined by this task lib.
+		def define
+			file @name do
+				template_file = Pathname.new(template)
+				content = template_file.read
+				token_replacements.each do |key,value|
+					content = content.gsub(/(\$\{#{key}\})/, value.to_s)
+				end
+				of = Pathname.new(@name)
+				of.delete if of.exist?
+				of.open('w') { |f| f.puts content }
+			end
+			
+			desc 'Generate the AssemblyInfo.cs file from the template'
+			task :assembly_info => [@name]
+
+			self
+		end
+		
+		def template
+			@template_file ||= @name.sub(/\.cs/, '.template.cs')
+		end
+		
+		def token_replacements
+			r = {}
+			r[:built_on] = Time.now
+			r[:product] = product_name
+			r[:configuration] = configuration
+			r[:company] = company_name
+			r[:version] = version
+			return r
+		end
+		
+		def product_name
+			@product_name ||= 'NRWS rake_dotnet'
+		end
+		
+		def configuration
+			@configuration ||= 'Debug'
+		end
+		
+		def company_name
+			@company_name ||= 'NRWS'
+		end
+		
+		def version
+			@version ||= Versioner.new.get
+		end
+	end
+end
+
+
+module Rake
+	class FxCopTask < TaskLib
+		def initialize(params={})
+			@product_name = params[:product_name] || PRODUCT_NAME
+			@report_dir = params[:report_dir] || File.join(OUT_DIR, 'reports')
+			@name = params[:name] || File.join(@report_dir, @product_name + '.fxcop')
+			@suites_dir = params[:suites_dir] || File.join(OUT_DIR, 'bin')
+			@dll_list = FileList.new
+			@deps = params[:deps] || []
+			@fxcop_options = {:apply_out_xsl=>true, :out_xsl=>'CodeAnalysisReport.xsl'}.merge(params[:fxcop_options] || {})
+			if @fxcop_options[:apply_out_xsl].nil? || @fxcop_options[:apply_out_xsl] == false
+				@name += '.xml' 
+			else
+				@name += '.html'
+			end
+			@fxcop_options[:out_file] = @name if @fxcop_options[:out_file].nil?
+			
+			yield self if block_given?
+			define
+		end
+		
+		def define
+			@deps.each do |d|
+				task :fxcop => d
+			end
+			
+			directory @report_dir
+
+			file @name => [@report_dir] do |f|
+				runner = FxCop.new(@dll_list, @fxcop_options)
+				runner.run
+			end
+			
+			task :fxcop,[:globs] do |t, args|
+				args.with_defaults(:globs => "#{@suites_dir}/**/*#{@product_name}*.dll")
+				@dll_list = FileList.new(args.globs)
+				Rake::FileTask[@name].invoke
+			end
+			
+			self
+		end
+		
+		self
+	end
+end
+
+class FxCop
+	attr_accessor :dlls, :out_file, :out_xsl, :apply_out_xsl, :dependencies_path, :summary, :verbose, :echo_to_console, :xsl_echo_to_console, :ignore_autogen, :culture
+
+	def initialize(dlls, params={})
+		@dlls = dlls
+
+		@exe_dir = params[:fxcop_exe_dir] || File.join(TOOLS_DIR, 'fxcop')
+		@exe = params[:fxcop_exe] || File.join(@exe_dir, 'fxcopcmd.exe')
+
+		@apply_out_xsl = params[:apply_out_xsl]
+		@culture = params[:culture]
+		@dependencies_path = params[:dependencies_path]
+		@echo_to_console = params[:echo_to_console]
+		@ignore_autogen = params[:ignore_autogen] || true
+		@out_file = params[:out_file]
+		@out_xsl = File.join(@exe_dir, 'Xml', params[:out_xsl]) unless params[:out_xsl].nil?
+		@summary = params[:summary]
+		@verbose = params[:verbose]
+		@xsl_echo_to_console = params[:xsl_echo_to_console]
+		
+		yield self if block_given?
+	end
+	
+	def console
+		'/console' if @echo_to_console || @out_file.nil?
+	end
+
+	def files_to_analyse
+		list = ''
+		@dlls.each do |dll|
+			list += "/file:\"#{dll}\" "
+		end
+		list = list.chop
+	end
+
+	def out_file
+		"/out:\"#{@out_file}\"" if @out_file
+	end
+
+	def out_xsl
+		"/outxsl:\"#{@out_xsl}\"" if @out_xsl
+	end
+
+	def apply_out_xsl
+		"/applyoutxsl" if @apply_out_xsl
+	end
+	
+	def cmd
+		"\"#{@exe}\" #{files_to_analyse} #{console} #{out_file} #{out_xsl} #{apply_out_xsl}"
+	end
+
+	def run
+		sh cmd
+	end
+end
+
+
+module Rake
+	class HarvestOutputTask < TaskLib
+		def initialize(params={})
+			@src_path = params[:src_path] || File.join(PRODUCT_ROOT, 'src')
+			@target_path = params[:target_path] || File.join(OUT_DIR, 'bin')
+			@deps = params[:deps] || []
+			@configuration = params[:configuration] || 'Debug'
+			@glob = params[:glob] || "#{@src_path}/*"
+			
+			yield self if block_given?
+			define
+		end
+		
+		def define
+			directory @target_path
+			
+			desc "Harvest specified libraries (or all matching #{@glob}) to #{@target_path}"
+			task :harvest_output,[:to_harvest_list] => @target_path do |t, args|
+				list = FileList.new
+				@glob.each do |g|
+					list.include(g)
+				end
+				args.with_defaults(:to_harvest_list => list)
+				args.to_harvest_list.each do |entry|
+					pn = Pathname.new(entry)
+					if pn.directory?
+						output = FileList.new
+						#TODO: distinguish between web and class and console output
+						output.include("#{entry}/bin/#{@configuration}/**/*")
+						output.include("#{entry}/bin/**/*")
+						output.each do |o|
+							o_pn = Pathname.new(o)
+							unless (o_pn.directory?)
+								to_pn = Pathname.new("#{@target_path}/#{o_pn.basename}")
+								cp(o, to_pn) unless to_pn.exist?
+							end
+						end
+					end
+				end
+			end
+			
+			@deps.each do |d|
+				task :harvest => d
+			end
+			
+			self
+		end
+	end
+
+	class HarvestWebApplicationTask < TaskLib
+		def initialize(params={})
+			@src_path = params[:src_path] || File.join(PRODUCT_ROOT, 'src')
+			@target_path = params[:target_path] || OUT_DIR
+			@deps = params[:deps] || []
+			@glob = params[:glob] || '*Site*'
+			
+			yield self if block_given?
+			define
+		end
+		
+		def define
+			out_dir_regex = regexify(@target_path)
+			
+			rule(/#{out_dir_regex}\/[\w\.-_ ]*Site[\w\.-_ ]*\//) do |r|
+				web_app_name = r.name.match(/#{out_dir_regex}\/([\w\.-_ ]*Site[\w\.-_ ]*)\//)[1]
+				src = File.join(@src_path, web_app_name)
+				svn = SvnExport.new(src, r.name)
+				svn.export
+				cp_r(File.join(src, 'bin'), r.name)
+			end
+			
+			desc "Harvest specified web-applications (or all matching #{@src_path}/#{@glob}) to #{@target_path}"
+			task :harvest_webapps,[:web_app_list] => @target_path do |t, args|
+				list = FileList.new("#{@src_path}/#{@glob}")
+				args.with_defaults(:web_app_list => list)
+				args.web_app_list.each do |w| 
+					pn = Pathname.new(w)
+					out = File.join(@target_path, pn.basename) + '/'
+					Rake::FileTask[out].invoke
+				end
+			end
+			
+			@deps.each do |d|
+				task :harvest_webapps => d
+			end
+			
+			self
+		end
+	end
+end
+
+class Harvester
+	attr_accessor :files, :target
+	
+	def initialize
+		@files = Hash.new
+	end
+	
+	def add(glob)
+		toAdd = Dir.glob(glob)
+		toAdd.each do |a|
+			pn = Pathname.new(a)
+			@files[pn.basename.to_s] = pn
+		end
+	end
+	
+	def harvest(target)
+		mkdir_p(target) unless File.exist?(target)
+		@files.sort.each do |k, v|
+			cp(v, target)
+		end
+	end
+	
+	def list
+		@files.sort.each do |k, v| 
+			puts k + ' -> ' + v
+		end
+	end
+end
+
+
+module Rake
+	class MsBuildTask < TaskLib
+		attr_accessor :src_dir, :verbosity, :working_dir
+	
+		def initialize(params={})
+			@configuration = params[:configuration] || CONFIGURATION
+			@src_dir = params[:src_dir] || File.join(PRODUCT_ROOT, 'src')
+			@verbosity = params[:verbosity] || 'm'
+			@working_dir = params[:working_dir] || '.'
+			@deps = params[:deps] || []
+			
+			yield self if block_given?
+			define
+		end
+		
+		def define
+			# most project types put output into bin/{configuration}
+			rule(/#{src_dir_regex}\/[\w\.]+\/bin\/#{@configuration}\/[\w\.]+\.(?:dll|exe)/) do |r|
+				pn = Pathname.new(r.name)
+				name = pn.basename.to_s.sub('.dll', '')
+				project = File.join(@src_dir, name, name + '.csproj')
+				mb = MsBuild.new(project, {:Configuration => @configuration}, ['Build'], verbosity, @working_dir)
+				mb.run
+			end
+			
+			# web application projects put output into /bin
+			rule(/#{src_dir_regex}\/[\w\.]+\/bin\/[\w\.]+\.dll/) do |r|
+				pn = Pathname.new(r.name)
+				name = pn.basename.to_s.sub('.dll', '')
+				project = File.join(@src_dir, name, name + '.csproj')
+				mb = MsBuild.new(project, {:Configuration => @configuration}, ['Build'], verbosity, @working_dir)
+				mb.run
+			end
+
+			desc "Compile the specified projects (give relative paths) (otherwise, all matching src/**/*.*proj)"
+			task :compile,[:projects] do |t, args|
+				project_list = FileList.new("#{src_dir}/**/*.*proj")
+				args.with_defaults(:projects => project_list)
+				args.projects.each do |p|
+					pn = Pathname.new(p)
+					# TODO: Figure out which type of project we are so we can invoke the correct rule, with the correct output extension
+					dll = File.join(pn.dirname, 'bin', @configuration, pn.basename.sub(pn.extname, '.dll'))
+					Rake::FileTask[dll].invoke
+				end
+			end
+
+			@deps.each do |d|
+				task :compile => d
+			end
+			
+			self
+		end
+		
+		def src_dir_regex
+			regexify(@src_dir)
+		end
+		
+		def figure_out_project_type(project_pathname)
+			# TODO.
+		end
+	end
+end
+
+class MsBuild
+	attr_accessor :project, :properties, :targets, :verbosity
+	
+	def initialize(project='default.proj', properties={}, targets=[], verbosity='n', working_dir=nil)
+		@project = project
+		@properties = properties
+		@targets = targets
+		@verbosity = verbosity
+		@working_dir = working_dir
+		@exe = '"' + File.join(ENV['windir'].dup, 'Microsoft.NET', 'Framework', 'v3.5', 'msbuild.exe') + '"'
+	end
+	
+	def cmd
+		"#{@exe} #{project} /maxcpucount /v:#{@verbosity} /property:BuildInParallel=true /p:#{properties} /t:#{targets}"
+	end
+	
+	def run
+		if @working_dir
+			chdir(@working_dir) do
+				sh cmd
+			end
+		end
+	end
+	
+	def project
+		"\"#{@project}\""
+	end
+	
+	def targets
+		@targets.join(';')
+	end
+	
+	def properties
+		p = []
+		@properties.each {|key, value| p.push("#{key}=#{value}") }
+		p.join(';')
+	end
+end
+
+
+module Rake
+	class NCoverTask < TaskLib
+		def initialize(params={})
+		
+			@product_name = params[:product_name] || PRODUCT_NAME
+			@bin_dir = params[:bin_dir] || File.join(OUT_DIR, 'bin')
+			@report_dir = params[:report_dir] || File.join(OUT_DIR, 'reports')
+			@deps = params[:deps] || []
+			tool_defaults = {:arch => 'x86'}
+			@ncover_options = tool_defaults.merge(params[:ncover_options] || {})
+			@ncover_reporting_options = tool_defaults.merge(params[:ncover_reporting_options] || {})
+
+			yield self if block_given?
+			define
+		end
+		
+		def define
+			@deps.each do |d|
+				task :ncover_profile => d
+			end
+			
+			directory @report_dir
+			
+			reports_dir_regex = regexify(@report_dir)
+			rule(/#{reports_dir_regex}\/.*\.coverage\.xml/) do |r|
+				dll_to_execute = r.name.sub(/#{@report_dir}\/(.*)\.coverage\.xml/, "#{@bin_dir}/\\1.dll")
+				nc = NCover.new(@report_dir, dll_to_execute, @ncover_options)
+				nc.run
+			end
+			
+			desc "Generate ncover coverage XML, one file per test-suite that exercises your product"
+			task :ncover_profile,[:dlls_to_run] => [@report_dir] do |t, args|
+				dlls_to_run_list = FileList.new
+				dlls_to_run_list.include("#{@bin_dir}/**/*#{@product_name}*Tests*.dll")
+				dlls_to_run_list.include("#{@bin_dir}/**/*#{@product_name}*Tests*.exe")
+				args.with_defaults(:dlls_to_run => dlls_to_run_list)
+				args.dlls_to_run.each do |d|
+					dll_to_run = Pathname.new(d)
+					cf_name = dll_to_run.basename.sub(dll_to_run.extname, '.coverage.xml')
+					coverage_file = File.join(@report_dir, cf_name)
+					Rake::FileTask[coverage_file].invoke
+				end
+				
+			end
+						
+			ncover_summary_report_html = File.join(@report_dir, 'merged.MethodSourceCodeClassMethod.coverage-report.html')
+			file ncover_summary_report_html do
+				# ncover lets us use *.coverage.xml to merge together files
+				include = [File.join(@report_dir, '*.coverage.xml')]
+				@ncover_reporting_options[:name] = 'merged'
+				ncr = NCoverReporting.new(@report_dir, include, @ncover_reporting_options)
+				ncr.run
+			end
+			
+			desc "Generate ncover coverage summary HTML report, on all coverage files, merged together"
+			task :ncover_summary => [:ncover_profile, ncover_summary_report_html]
+			
+			task :clean_coverage do
+				rm_rf 'out/reports/*coverage-report*'
+			end
+			
+			self
+		end
+		
+		self
+	end
+end
+
+class NCover
+	def initialize(report_dir, dll_to_execute, params)
+		params ||= {}
+		arch = params[:arch] || 'x86'
+		@exe = params[:ncover_exe] || File.join(TOOLS_DIR, 'ncover', arch, 'ncover.console.exe')
+		@dll_to_execute = dll_to_execute
+		ofname = File.split(dll_to_execute)[1].sub(/(\.dll)/, '') + '.coverage.xml'
+		@output_file = File.join(report_dir, ofname)
+		@exclude_assemblies_regex = params[:exclude_assemblies_regex] || '.*Tests.*'
+		@build_id = params[:build_id] || RDNVERSION
+	end
+	
+	def cmdToRun
+		x = XUnit.new(@dll_to_execute, {})
+		x.cmd
+	end
+	
+	def bi
+		"//bi #{@build_id.to_s}"
+	end
+	
+	def eas
+		"//eas #{@exclude_assemblies_regex}"
+	end
+	
+	def cmd
+		"\"#{@exe}\" #{cmdToRun} //x #{@output_file} #{eas} #{bi}"
+	end
+	
+	def run
+		sh cmd
+	end
+end
+
+class NCoverReporting
+	def initialize(report_dir, coverage_files, params)
+		@report_dir = report_dir
+		@coverage_files = coverage_files || []
+
+		params ||= {}
+		arch = params[:arch] || 'x86'
+		@exe = params[:ncover_reporting_exe] || File.join(TOOLS_DIR, 'ncover', arch, 'ncover.reporting.exe')
+
+		# required
+		@name = params[:name] || 'CoverageReport'
+		@report = params[:report] || 'MethodSourceCodeClassMethod'
+		@format = params[:report_format] || 'html' # can be xml or html
+		@output_path = File.join(@report_dir, @name + '.' + @report + '.' + @format)
+		
+		# optional
+		@build_id = params[:build_id] || RDNVERSION
+		@so = params[:sort] || 'CoveragePercentageAscending'
+	end
+	
+	def coverage_files
+		list = ''
+		@coverage_files.each do |cf|
+			list += "\"#{cf}\" "
+		end
+		list
+	end
+	
+	def bi
+		"//bi #{@build_id.to_s}"
+	end
+	
+	def r
+		"//r #{@report}"
+	end
+	
+	def op
+		"//op \"#{@output_path}\""
+	end
+	
+	def so
+		"//so #{@so}"
+	end
+		
+	def cmd
+		"\"#{@exe}\" #{coverage_files} #{bi} #{r} #{op} #{so}"
+	end
+	
+	def run
+		sh cmd
+	end
+end
+
+
+module Rake
+	class RDNPackageTask < TaskLib
+		attr_accessor :targets
+	
+		def initialize(name, version, params={})
+			@name = name
+			@version = version
+			@out_dir = params[:out_dir] || OUT_DIR
+			@deps = params[:deps] || []
+			@configuration = params[:configuration] || CONFIGURATION
+			globs = params[:globs] || []
+			@targets = FileList.new globs
+			
+			yield self if block_given?
+			define
+		end
+		
+		def define
+			pkg = File.join(@out_dir, 'pkg')
+			pkg_root = renamed(File.join(pkg, @name))
+			
+			directory pkg
+			directory pkg_root
+			
+			package_file = pkg_root + '.zip'
+			package_file_regex = regexify(package_file)
+			
+			@deps.each do |d|
+				file package_file => d
+				task :package => d
+			end
+			
+			rule(/#{package_file_regex}/) do |r|
+				@targets.each do |t|
+					f = Pathname.new(t)
+					if f.directory?
+						mv "#{t}/*", pkg_root
+					else
+						mv t, pkg_root
+					end
+				end
+				snipped = pkg_root.sub(pkg + '/', '')
+				chdir pkg do
+					sz = SevenZip.new('../../'+package_file, snipped, {:sevenzip=>File.join('..','..',TOOLS_DIR, '7zip', '7z.exe')})
+					sz.run_add
+				end
+			end
+			
+			directory @out_dir
+			
+			desc "Generate zip'd packages for all package-tasks"
+			task :package => [@out_dir, pkg, pkg_root, package_file]
+			
+			desc "Delete all packages"
+			task :clobber_package do
+				rm_rf pkg
+			end
+			
+			task :clobber => :clobber_package
+			
+			desc "Delete all packages and recreate them"
+			task :repackage => [:clobber_package, :package]
+			
+			self
+		end
+		
+		def renamed(target)
+			"#{target}-#{@configuration}-v#{@version}"
+		end
+	end
+end
+
+
+class SevenZip
+	def initialize(archive_name, file_names, opts={})
+		@exe = opts[:sevenzip] || File.join(TOOLS_DIR, '7zip', '7z.exe')
+		@archive_name = archive_name
+		@file_names = file_names
+		
+		yield self if block_given?
+	end
+	
+	def cmd_add
+		"#{exe} a #{switches} #{archive_name} #{file_names}"
+	end
+	
+	def run_add
+		sh cmd_add
+	end
+	
+	def archive_name
+		"\"#{@archive_name}\""
+	end
+	
+	def file_names
+		if @file_names.is_a? String
+			"\"#{@file_names}\""
+		elsif @file_names.is_a? Array
+			list = ''
+			@file_names.each do |fn|
+				list += "\"#{fn}\" "
+			end 
+			list.chop
+		end
+	end
+	
+	def exe
+		"\"#{@exe}\""
+	end
+	
+	def switches
+	
+	end
+end
+
+
+class Svn
+	attr_accessor :svn
+
+	def initialize(opts={})
+		@svn = opts[:svn] || File.join(TOOLS_DIR, 'svn', 'bin', 'svn.exe')
+		yield self if block_given?
+	end
+	
+	def exe
+		"\"#{@svn}\""
+	end
+end
+
+class SvnExport < Svn
+	def initialize(src, dest, opts={})
+		super(opts)
+		@src = src
+		@dest = dest
+	end
+	
+	def cmd
+		"#{exe} export #{src} #{dest}"
+	end
+	
+	def export
+		sh cmd
+	end
+	
+	def src
+		"\"#{@src}\""
+	end
+	
+	def dest
+		"\"#{@dest}\""
+	end	
+end
+
+class SvnInfo < Svn
+	attr_accessor :svn
+	
+	def initialize(opts)
+		super(opts)
+		@path = opts[:path] || '.'
+		yield self if block_given?
+	end
+	
+	def cmd
+		"#{exe} info #{path}"
+	end
+
+	def revision
+		out = `#{cmd}`
+		out.match(/Revision: (\d+)/)[1]
+	end
+	
+	def path
+		"\"#{@path}\""
+	end
+end
+
+
+class Versioner
+	def initialize(template_file=nil)
+		tf = template_file || 'version.template.txt'
+		template_file = Pathname.new(tf)
+		@maj_min = template_file.read.chomp
+		@build = ENV['BUILD_NUMBER'] || 0
+		@svn_info = SvnInfo.new(:path => '.')
+	end
+	
+	def get
+		"#{@maj_min}.#{@build}.#{@svn_info.revision}"
+	end
+end
+
+
+
+
+module Rake
+	class XUnitTask < TaskLib
+		attr_accessor :suites_dir, :reports_dir, :options
+
+		def initialize(params={}) # :yield: self
+			@suites_dir = params[:suites_dir] || File.join(OUT_DIR, 'bin')
+			@reports_dir = params[:reports_dir] || File.join(OUT_DIR, 'reports')
+			@options = params[:options] || {}
+			@deps = params[:deps] || []
+			
+			yield self if block_given?
+			define
+		end
+
+		# Create the tasks defined by this task lib.
+		def define
+			@deps.each do |d|
+				task :xunit => d
+			end
+			
+			rule(/#{@reports_dir}\/.*Tests.*\//) do |r|
+				suite = r.name.match(/.*\/(.*Tests)\//)[1]
+				testsDll = File.join(@suites_dir, suite + '.dll')
+				out_dir = File.join(@reports_dir, suite)
+				unless File.exist?(out_dir) && uptodate?(testsDll, out_dir)
+					mkdir_p(out_dir) unless File.exist?(out_dir)
+					x = XUnit.new(testsDll, out_dir, nil, options=@options)
+					x.run
+				end
+			end
+
+			directory @reports_dir
+			
+			desc "Generate test reports (which ones, depends on the content of XUNIT_OPTS) inside of each directory specified, where each directory matches a test-suite name (give relative paths) (otherwise, all matching #{@suites_dir}/*Tests.*.dll) and write reports to #{@reports_dir}"
+			task :xunit,[:reports] => [@reports_dir] do |t, args|
+				reports_list = FileList.new("#{@suites_dir}/**/*Tests*.dll").pathmap("#{@reports_dir}/%n/")
+				args.with_defaults(:reports => reports_list)
+				args.reports.each do |r|
+					Rake::FileTask[r].invoke
+				end
+			end
+			
+			task :xunit_clobber do
+				rm_rf(@reports_dir)
+			end
+			
+			self
+		end
+	end
+end
+
+class XUnit
+	attr_accessor :xunit, :testDll, :reports_dir, :options
+	
+	def initialize(testDll, reports_dir, xunit=nil, options={})
+		@xunit = xunit || File.join(TOOLS_DIR, 'xunit', 'xunit.console.exe')
+		@testDll = testDll
+		@reports_dir = reports_dir
+		@options = options
+	end
+	
+	def run
+		sh cmd
+	end
+	
+	def cmd
+		cmd = "#{exe} #{testDll} #{html} #{xml} #{nunit} #{wait} #{noshadow} #{teamcity}"
+	end
+	
+	def exe
+		"\"#{@xunit}\""
+	end
+	
+	def suite
+		@testDll.match(/.*\/([\w\.]+)\.dll/)[1]
+	end
+	
+	def testDll
+		"\"#{@testDll}\""
+	end
+	
+	def html
+		"/html #{@reports_dir}/#{suite}.test-results.html" if @options.has_key?(:html)
+	end
+	
+	def xml
+		"/xml #{@reports_dir}/#{suite}.test-results.xml" if @options.has_key?(:xml)
+	end
+	
+	def nunit
+		"/nunit #{@reports_dir}/#{suite}.test-results.nunit.xml" if @options.has_key?(:nunit)
+	end
+
+	def wait
+		'/wait' if @options.has_key?(:wait)
+	end
+	
+	def noshadow
+		'/noshadow' if @options.has_key?(:noshadow)
+	end
+	
+	def teamcity
+		'/teamcity' if @options.has_key?(:teamcity)
+	end
+end
+
+

data/test/test_rake_dotnet.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+require 'lib/rake_dotnet.rb'
+
+class SvnTest < Test::Unit::TestCase
+	def test_initialize_with_no_opts
+		svn = Svn.new
+		
+		assert_equal "\"#{TOOLS_DIR}/svn/bin/svn.exe\"", svn.exe
+	end
+	
+	def test_initialize_with_path
+		svn = Svn.new :svn => 'foo/bar/svn.exe'
+		
+		assert_equal "\"foo/bar/svn.exe\"", svn.exe
+	end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rake-dotnet
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Peter MouncePeter Mounce
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-09 00:00:00 +00:00
+date: 2009-03-26 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,12 +30,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.9.0
+        version: 1.11.0
     version: 
 description: Making a .NET build-automation dev's life easier, one angle-bracket at a time
 email: pete@neverrunwithscissors.compete@neverrunwithscissors.com
-executables: 
-- rake_dotnet
+executables: []
+
 extensions: []
 
 extra_rdoc_files: 
@@ -47,7 +47,6 @@ files:
 - Manifest.txt
 - README.txt
 - Rakefile
-- bin/rake_dotnet
 - lib/rake_dotnet.rb
 - test/test_rake_dotnet.rb
 has_rdoc: true