RubyGems - albacore - Versions diffs - 0.3.6 → 0.6.2.rc1 - Mend

albacore 0.3.6 → 0.6.2.rc1

Files changed (643) hide show

data/lib/albacore/xunittestrunner.rb DELETED

@@ -1,56 +0,0 @@
-require 'albacore/albacoretask'
-class XUnitTestRunner
-  TaskName = :xunit
-  include Albacore::Task
-  include Albacore::RunCommand
-  attr_accessor :html_output, :skip_test_fail
-  attr_array :options,:assembly,:assemblies
-  def initialize(command=nil)
-    @options=[]
-    super()
-    update_attributes Albacore.configuration.xunit.to_hash
-    @command = command unless command.nil?
-  end
-  def skip_test_failures
-    @skip_test_fail = true
-  end
-  def get_command_line
-    command_params = []
-    command_params << @command
-    command_params << get_command_parameters
-    commandline = command_params.join(" ")
-    @logger.debug "Build XUnit Test Runner Command Line: " + commandline
-    commandline
-  end
-  def get_command_parameters
-    command_params = []
-    command_params << @options.join(" ") unless @options.nil?
-    command_params << build_html_output unless @html_output.nil?
-    command_params
-  end
-  def execute()
-    @assemblies = [] if @assemblies.nil?
-    @assemblies << @assembly unless @assembly.nil?
-    fail_with_message 'At least one assembly is required for assemblies attr' if @assemblies.length==0
-    failure_message = 'XUnit Failed. See Build Log For Detail'
-    @assemblies.each do |assm|
-      command_params = get_command_parameters.collect{ |p| p % File.basename(assm) }
-      command_params.insert(0,assm)
-      result = run_command "XUnit", command_params.join(" ")
-      fail_with_message failure_message if !result && (!@skip_test_fail || $?.exitstatus > 1)
-    end
-  end
-  def build_html_output
-    fail_with_message 'Directory is required for html_output' if !File.directory?(File.expand_path(@html_output))
-    "/html \"#{File.join(File.expand_path(@html_output),"%s.html")}\""
-  end
-end

data/lib/albacore/zipdirectory.rb DELETED

@@ -1,106 +0,0 @@
-require 'albacore/albacoretask'
-require 'zip/zip'
-require 'zip/zipfilesystem'
-include Zip
-class ZipDirectory
-  TaskName = :zip
-  include Albacore::Task
-  attr_accessor :output_path, :output_file
-  attr_accessor :flatten_zip
-  attr_array :directories_to_zip, :additional_files, :exclusions
-  def initialize
-    @flatten_zip = true
-    @exclusions = []
-    super()
-    update_attributes Albacore.configuration.zip.to_hash
-  end
-  def execute()
-    fail_with_message 'Output File cannot be empty' if @output_file.nil?
-    return if @output_file.nil?
-    clean_directories_names
-    remove zip_name
-    ZipFile.open(zip_name, 'w')  do |zipfile|
-      zip_directory(zipfile)
-      zip_additional(zipfile)
-    end
-  end
-  def clean_directories_names
-    return if @directories_to_zip.nil?
-    @directories_to_zip.each { |d| d.sub!(%r[/$],'')}
-  end
-  def remove(filename)
-    FileUtils.rm filename, :force=>true
-  end
-  def reject_file(f)
-    f == zip_name || is_excluded(f)
-  end
-  def is_excluded(f)
-    expanded_exclusions.any? do |e|
-      return true if e.respond_to? '~' and f =~ e
-      e == f
-    end
-  end
-  def expanded_exclusions
-    return @expanded_exclusions unless @expanded_exclusions.nil?
-    regexp_exclusions, string_exclusions = @exclusions.partition {|x| x.respond_to? '~' }
-    @expanded_exclusions = [].concat(regexp_exclusions)
-    @directories_to_zip.each do |dir|
-      Dir.chdir(dir) do
-        string_exclusions.each do |ex|
-          exclusions = Dir.glob(ex)
-          exclusions = exclusions.map {|x| File.join(dir, x) } unless exclusions[0] == ex
-          exclusions << ex if exclusions.empty?
-          @expanded_exclusions += exclusions
-        end
-      end
-    end
-    @expanded_exclusions
-  end
-  def zip_name()
-    @output_path = set_output_path
-    File.join(@output_path, @output_file)
-  end
-  def set_output_path()
-    path = ''
-    path = @directories_to_zip.first unless @directories_to_zip.nil?
-    path = @output_path unless @output_path.nil?
-    return path
-  end
-  def zip_directory(zipfile)
-    return if @directories_to_zip.nil?
-    @directories_to_zip.each do |d|
-      Dir["#{d}/**/**"].reject{|f| reject_file(f)}.each do |file_path|
-        file_name = file_path
-        file_name = file_path.sub(d + '/','') if @flatten_zip
-        zipfile.add(file_name, file_path)
-      end
-    end
-  end
-  def zip_additional(zipfile)
-    return if @additional_files.nil?
-    @additional_files = Array.[](@additional_files).flatten
-    @additional_files.reject{|f| reject_file(f)}.each do |file_path|
-      file_name = file_path.split('/').last if @flatten_zip
-      zipfile.add(file_name, file_path)
-    end
-  end
-end

data/lib/version.rb DELETED

@@ -1,3 +0,0 @@
-module Albacore
-  VERSION = '0.3.6'
-end

data/samples/Rakefile DELETED

@@ -1,154 +0,0 @@
-$: << File.expand_path('../lib', __FILE__)
-require 'albacore'
-namespace :albacore do
-  Albacore.configure do |config|
-    config.yaml_config_folder = "spec/support/yamlconfig"
-    config.log_level = :verbose
-  end
-  desc "Run a complete Albacore build sample"
-  task :sample => ['albacore:assemblyinfo',
-                   'albacore:assemblyinfo_modify',
-                   'albacore:msbuild',
-                   'albacore:ncoverconsole',
-                   'albacore:ncoverreport',
-                   'albacore:mspec',
-                   'albacore:nunit',
-                   'albacore:xunit',
-                   'albacore:mstest',
-                   'albacore:fluentmigrator']
-  desc "Run a sample MSBuild with YAML autoconfig"
-  msbuild :msbuild
-  desc "Run a sample assembly info generator"
-  assemblyinfo do |asm|
-    asm.version = "0.1.2.3"
-    asm.company_name = "a test company"
-    asm.product_name = "a product name goes here"
-    asm.title = "my assembly title"
-    asm.description = "this is the assembly description"
-    asm.copyright = "copyright some year, by some legal entity"
-    asm.custom_attributes :SomeAttribute => "some value goes here", :AnotherAttribute => "with some data"
-    asm.output_file = "spec/support/AssemblyInfo/AssemblyInfo.cs"
-  end
-  desc "Run a sample assembly info modifier"
-  assemblyinfo :assemblyinfo_modify do|asm|
-    # modify existing
-    asm.version = "0.1.2.3"
-    asm.company_name = "a test company"
-    # new attribute
-    asm.file_version = "4.5.6.7"
-    asm.input_file = "spec/support/AssemblyInfo/AssemblyInfoInput.test"
-    asm.output_file = "spec/support/AssemblyInfo/AssemblyInfoOutput.cs"
-  end
-  desc "Run a sample NCover Console code coverage"
-  ncoverconsole do |ncc|
-    @xml_coverage = "spec/support/CodeCoverage/test-coverage.xml"
-    File.delete(@xml_coverage) if File.exist?(@xml_coverage)
-    ncc.log_level = :verbose
-    ncc.command = "spec/support/Tools/NCover-v3.3/NCover.Console.exe"
-    ncc.output :xml => @xml_coverage
-    ncc.working_directory = "spec/support/CodeCoverage/nunit"
-    nunit = NUnitTestRunner.new("spec/support/Tools/NUnit-v2.5/nunit-console-x86.exe")
-    nunit.log_level = :verbose
-    nunit.assemblies "assemblies/TestSolution.Tests.dll"
-    nunit.options '/noshadow'
-    ncc.testrunner = nunit
-  end
-  desc "Run a sample NCover Report to check code coverage"
-  ncoverreport :ncoverreport => :ncoverconsole do |ncr|
-    @xml_coverage = "spec/support/CodeCoverage/test-coverage.xml"
-    ncr.command = "spec/support/Tools/NCover-v3.3/NCover.Reporting.exe"
-    ncr.coverage_files @xml_coverage
-    fullcoveragereport = NCover::FullCoverageReport.new
-    fullcoveragereport.output_path = "spec/support/CodeCoverage/report/output"
-    ncr.reports fullcoveragereport
-    ncr.required_coverage(
-    	NCover::BranchCoverage.new(:minimum => 10),
-    	NCover::CyclomaticComplexity.new(:maximum => 1)
-    )
-  end
-  desc "Run ZipDirectory example"
-  zip do |zip|
-    zip.output_path = File.dirname(__FILE__)
-    zip.directories_to_zip = "lib", "spec"
-    zip.additional_files "README.markdown"
-    zip.output_file = 'albacore_example.zip'
-  end
-  desc "Run UnZip example"
-  unzip do |zip|
-    zip.unzip_path = File.join File.dirname(__FILE__), 'temp'
-    zip.zip_file = 'albacore_example.zip'
-  end
-  desc "MSpec Test Runner Example"
-  mspec do |mspec|
-    mspec.command = "spec/support/Tools/Machine.Specification-v0.2/Machine.Specifications.ConsoleRunner.exe"
-    mspec.assemblies "spec/support/CodeCoverage/mspec/assemblies/TestSolution.MSpecTests.dll"
-  end
-  desc "NUnit Test Runner Example"
-  nunit do |nunit|
-    nunit.command = "spec/support/Tools/NUnit-v2.5/nunit-console.exe"
-    nunit.assemblies "spec/support/CodeCoverage/nunit/assemblies/TestSolution.Tests.dll"
-  end
-  desc "MSTest Test Runner Example"
-  mstest do |mstest|
-    mstest.command = "spec/support/Tools/MSTest-2010/mstest.exe"
-    mstest.assemblies "spec/support/CodeCoverage/mstest/TestSolution.MsTestTests.dll"
-  end
-  desc "MSDeploy Example"
-  msdeploy do |msdeploy|
-    msdeploy.deploy_package = "spec/support/TestSolution/TestSolution.MSDeploy/TestSolution.MSDeploy/obj/Debug/Package"
-    msdeploy.noop = true
-  end
-  desc "XUnit Test Runner Example"
-  xunit do |xunit|
-    xunit.command = "spec/support/Tools/XUnit-v1.5/xunit.console.exe"
-    xunit.assembly = "spec/support/CodeCoverage/xunit/assemblies/TestSolution.XUnitTests.dll"
-  end
-  desc "Exec Task Example"
-  exec do |exec|
-    exec.command = 'hostname'
-  end
-  desc "Mono \ xBuild Example"
-  mono do |xbuild|
-    xbuild.properties :configuration => :release, :platform => 'Any CPU'
-    xbuild.targets :clean, :build
-    xbuild.solution = "spec/support/TestSolution/TestSolution.sln"
-  end
-  desc "FluentMigrator Test Runner Example"
-  fluentmigrator do |migrator|
-    db_file = "#{ENV['TEMP']}/fluentmigrator.sqlite3"
-    File.delete(db_file) if File.exist?(db_file)
-    migrator.command = "spec/support/Tools/FluentMigrator-0.9/Migrate.exe"
-    migrator.target = "spec/support/FluentMigrator/TestSolution.FluentMigrator.dll"
-    migrator.provider = "sqlite"
-    migrator.connection = "Data Source=#{db_file};"
-  end
-end

data/spec/README.md DELETED

@@ -1,9 +0,0 @@
-# Zup, specs?
-A description of what's in this folder and what needs to be done.
-## Albacore Model
-A test for `Albacore::Task` included methods, `attr_array`, `attr_accessor` and `attr_hash`.

data/spec/albacoremodel_spec.rb DELETED

@@ -1,53 +0,0 @@
-require 'spec_helper'
-require 'albacore/albacoretask'
-class ModelTest
-  include Albacore::Task
-  attr_accessor :foo, :bar
-  attr_hash :a_hash
-  attr_array :a_array
-end
-class NamedTaskExample
-  TaskName = [:namedtask, :anothername]
-  include Albacore::Task
-end
-describe "when updating object attributes with a valid set of hash keys" do
-  before :each do
-    @model = ModelTest.new
-    @model << {:foo => "test", :bar => "whatever"}
-  end
-  it "should set the attributes correctly" do
-    @model.foo.should == "test"
-    @model.bar.should == "whatever"
-  end
-end
-describe "when updating an object attributes with an invalid hash key" do
-  before :each do
-    @model = ModelTest.new
-    str = StringIO.new
-    @model.log_device = str
-    @model << {:something => "broken"}
-    @log = str.string
-  end
-  it "should warn about the attribute not being found" do
-    @log.should include("something is not a settable attribute on ModelTest")
-  end
-end
-describe "when an class includes albacoretask" do
-  it "should create a rake task for that class" do
-    respond_to?(:modeltest).should be_true
-  end
-end
-describe "when an albacoretask class specifies task names" do
-  it "should create a task with the specified names" do
-    respond_to?(:namedtask).should be_true
-    respond_to?(:anothername).should be_true
-  end
-end

data/spec/assemblyinfo_contexts.rb DELETED

@@ -1,52 +0,0 @@
-require 'spec_helper'
-require 'support/assemblyinfotester'
-require 'albacore/assemblyinfo'
-shared_context "StringIO logging" do
-  before :all do
-    @strio = StringIO.new
-  end
-  def logwith_strio task, level = :diagnostic
-    task.log_device = @strio
-    task.log_level = level
-  end
-end
-shared_context "asminfo task" do
-  include_context "StringIO logging"
-  before :all do
-    @tester = AssemblyInfoTester.new
-    @asm = AssemblyInfo.new
-    logwith_strio @asm
-  end
-end
-shared_context "language engines" do
-  include_context "asminfo task"
-  before :all do
-    @asm.namespaces 'My.Name.Space', 'Another.Namespace.GoesHere'
-  end
-  def using_engine engine
-    @tester.lang_engine = @asm.lang_engine = engine
-  end
-end
-shared_context "specifying custom attributes" do
-  include_context "asminfo task"
-  before :all do
-    @asm.custom_attributes :CustomAttribute => "custom attribute data",
-                           :AnotherAttribute => "more data here"
-  end
-  subject { @tester.build_and_read_assemblyinfo_file @asm }
-end

data/spec/assemblyinfo_spec.rb DELETED

@@ -1,459 +0,0 @@
-require 'spec_helper'
-require 'support/assemblyinfotester'
-require 'albacore/assemblyinfo'
-require 'assemblyinfo_contexts'
-# have a look in the above file to see what spec types are in this file
-describe AssemblyInfo, "when generating an assembly info file" do
-  include_context "asminfo task"
-  before :all do
-    @tester.build_and_read_assemblyinfo_file @asm
-  end
-  subject { @strio.string }
-  it "should log the name of the output file" do
-    subject.downcase.should include(@tester.assemblyinfo_file.downcase)
-  end
-end
-describe AssemblyInfo, "when generating an assembly info file in verbose mode" do
-  include_context "asminfo task"
-  before :all do
-    @asm.version = @tester.version
-    logwith_strio @asm, :verbose
-    @tester.build_and_read_assemblyinfo_file @asm
-  end
-  subject { @strio.string }
-  it "should log the name of the output file" do
-    subject.downcase.should include(@tester.assemblyinfo_file.downcase)
-  end
-end
-describe AssemblyInfo, "when generating an assembly info file without an output file specified" do
-  include_context "asminfo task"
-  before :all do
-    @asm.extend(FailPatch)
-    @asm.execute
-  end
-  subject { @strio.string }
-  it "should log an error message saying the output file is required" do
-    subject.should include("output_file cannot be nil")
-  end
-end
-{ :no => { :engine => nil,              :lang => "no",         :start_token => "[",  :end_token => "]"},
-  :cs => { :engine => CSharpEngine.new, :lang => "the C#",     :start_token => "[",  :end_token => "]" },
-  :vb => { :engine => VbNetEngine.new,  :lang => "the VB.Net", :start_token => "<",  :end_token => ">", :assignment => ":=" },
-  :fs => { :engine => FSharpEngine.new, :lang => "the F#",     :start_token => "[<", :end_token => ">]" },
-  :cpp=> { :engine => CppCliEngine.new, :lang => "the C++",    :start_token => "[",  :end_token => "]" }
-}.each do |key, settings|
-  s = settings[:start_token]
-  e = settings[:end_token]
-  a = settings[:assignment] || '='
-  describe AssemblyInfo, "when specifying a custom attribute with no data and using #{settings[:lang]} language specification" do
-    include_context "asminfo task"
-    before :all do
-      @tester.lang_engine = @asm.lang_engine = settings[:engine]
-      @asm.custom_attributes :NoArgsAttribute => nil
-    end
-    subject { @tester.build_and_read_assemblyinfo_file @asm }
-    it "should.execute the attribute with an empty argument list" do
-      subject.scan(%Q|#{s}assembly: NoArgsAttribute()#{e}|).length.should == 1
-    end
-  end
-  describe AssemblyInfo, "when specifying an attribute with non-string data and using #{settings[:lang]} language specification" do
-    include_context "asminfo task"
-    before :all do
-      @tester.lang_engine = @asm.lang_engine = settings[:engine]
-      @asm.custom_attributes :NonStringAttribute => true
-    end
-    subject { @tester.build_and_read_assemblyinfo_file @asm }
-    it "should.execute the attribute data without quotes" do
-      subject.scan(%Q|#{s}assembly: NonStringAttribute(true)#{e}|).length.should == 1
-    end
-  end
-  describe AssemblyInfo, "when specifying an attribute with multiple parameters and using #{settings[:lang]} language specification" do
-    include_context "asminfo task"
-    before :all do
-      @tester.lang_engine = @asm.lang_engine = settings[:engine]
-      @asm.custom_attributes :MultipleParameterAttribute => [true, 1, "abc"]
-    end
-    subject { @tester.build_and_read_assemblyinfo_file @asm }
-    it "should create the attribute correctly" do
-      subject.scan(%Q|#{s}assembly: MultipleParameterAttribute(true, 1, "abc")#{e}|).length.should == 1
-    end
-  end
-  describe AssemblyInfo, "when specifying an attribute with named parameters and using #{settings[:lang]} language specification" do
-    include_context "asminfo task"
-    before :all do
-      @tester.lang_engine = @asm.lang_engine = settings[:engine]
-      @asm.custom_attributes :NamedParameterAttribute => {:arg1 => "abc", :arg2 => false}
-    end
-    subject { @tester.build_and_read_assemblyinfo_file @asm }
-    it "should create the attribute correctly" do
-      subject.scan(%Q|#{s}assembly: NamedParameterAttribute(arg1 #{a} "abc", arg2 #{a} false)#{e}|).length.should == 1
-    end
-  end
-  describe AssemblyInfo, "when specifying an attribute with multiple and named parameters and using #{settings[:lang]} language specification" do
-    include_context "asminfo task"
-    before :all do
-      @tester.lang_engine = @asm.lang_engine = settings[:engine]
-      @asm.custom_attributes :UberParameterAttribute => [true, 1, "abc", {:arg1 => "abc", :arg2 => false}]
-    end
-    subject { @tester.build_and_read_assemblyinfo_file @asm }
-    it "should create the attribute correctly" do
-      subject.scan(%Q|#{s}assembly: UberParameterAttribute(true, 1, "abc", arg1 #{a} "abc", arg2 #{a} false)#{e}|).length.should == 1
-    end
-  end
-end
-describe FSharpEngine, "when generating assembly info" do
-  include_context "language engines"
-  before :all do
-    using_engine FSharpEngine.new
-  end
-  subject { @tester.build_and_read_assemblyinfo_file @asm }
-  it "should output a module definition" do
-    subject.scan('module AssemblyInfo').length.should == 1
-  end
-  it "should output '()' at the bottom" do
-    subject.scan('()').length.should == 1
-  end
-end
-describe FSharpEngine, "when setting language attribute" do
-  include_context "language engines"
-  before :all do
-    @tester.language = @asm.language = "F#"
-  end
-  subject { @tester.build_and_read_assemblyinfo_file @asm }
-  it "should use the system.reflection namespace" do
-    subject.scan(%Q|open System.Reflection|).length.should == 1
-  end
-  it "should not contain the assembly title" do
-    subject.scan(%Q|[assembly: AssemblyTitle("#{@tester.title}")]|).should be_empty
-  end
-  it "should output a module definition" do
-    subject.scan('module AssemblyInfo').length.should == 1
-  end
-  it "should output '()' at the bottom" do
-    subject.scan('()').length.should == 1
-  end
-end
-{ :no => { :engine => nil,              :lang => "no", :start_token => "[", :end_token => "]",     :using => "using " },
-  :cs => { :engine => CSharpEngine.new, :lang => "the C#", :start_token => "[", :end_token => "]",     :using => "using " },
-  :vb => { :engine => VbNetEngine.new,  :lang => "the VB.Net", :start_token => "<", :end_token => ">", :using => "Imports ", :statement_terminator => "" },
-  :fs => { :engine => FSharpEngine.new, :lang => "the F#", :start_token => "[<", :end_token => ">]",   :using => "open ", :statement_terminator => "" },
-  :cpp=> { :engine => CppCliEngine.new, :lang => "the C++", :start_token => "[", :end_token => "]",    :using => "using namespace ", :nsdelim => "::" }
-}.each do |key, settings|
-  describe AssemblyInfo, "when generating an assembly info file with the built in attributes and #{settings[:lang]} language specified" do
-    include_context "language engines"
-    before :all do
-      @asm.product_name = @tester.product_name
-      @asm.version = @tester.version
-      @asm.title = @tester.title
-      @asm.description = @tester.description
-      @asm.copyright = @tester.copyright
-      @asm.com_visible = @tester.com_visible
-      @asm.com_guid = @tester.com_guid
-      @asm.file_version = @tester.file_version
-      @asm.informational_version = @tester.informational_version
-      @asm.trademark = @tester.trademark
-      @asm.company_name = @tester.company_name
-      using_engine settings[:engine] unless settings[:engine].nil?
-    end
-    let(:s) { settings[:start_token] }
-    let(:e) { settings[:end_token] }
-    let(:using) { settings[:using] }
-    let(:d) { settings[:nsdelim] || '.' }
-    let(:t) { settings[:statement_terminator] || ';'}
-    subject { @tester.build_and_read_assemblyinfo_file @asm }
-    it "should use the system.reflection namespace" do
-      subject.scan(%Q|#{using}System#{d}Reflection#{t}|).length.should == 1
-    end
-    it "should use the system.runtime.interopservices namespace" do
-      subject.scan(%Q|#{using}System#{d}Runtime#{d}InteropServices#{t}|).length.should == 1
-    end
-    it "should use custom namespaces" do
-      subject.scan(%Q|#{using}My#{d}Name#{d}Space#{t}|).length.should == 1
-    end
-    it "shold be using the other custom namespace, too" do
-      subject.scan(%Q|#{using}Another#{d}Namespace#{d}GoesHere#{t}|).length.should == 1
-    end
-    it "should contain the specified version information" do
-      subject.scan(%Q|#{s}assembly: AssemblyVersion("#{@tester.version}")#{e}|).length.should == 1
-    end
-    it "should contain the assembly title" do
-      subject.scan(%Q|#{s}assembly: AssemblyTitle("#{@tester.title}")#{e}|).length.should == 1
-    end
-    it "should contain the assembly description" do
-      subject.scan(%Q|#{s}assembly: AssemblyDescription("#{@tester.description}")#{e}|).length.should == 1
-    end
-    it "should contain the copyright information" do
-      subject.scan(%Q|#{s}assembly: AssemblyCopyright("#{@tester.copyright}")#{e}|).length.should == 1
-    end
-    it "should contain the com visible information" do
-      subject.scan(%Q|#{s}assembly: ComVisible(#{@tester.com_visible})#{e}|).length.should == 1
-      subject.scan(%Q|#{s}assembly: Guid("#{@tester.com_guid}")#{e}|).length.should == 1
-    end
-    it "should contain the company name information" do
-      subject.scan(%Q|#{s}assembly: AssemblyCompany("#{@tester.company_name}")#{e}|).length.should == 1
-    end
-    it "should contain the product information" do
-      subject.scan(%Q|#{s}assembly: AssemblyProduct("#{@tester.product_name}")#{e}|).length.should == 1
-    end
-    it "should contain the file version information" do
-      subject.scan(%Q|#{s}assembly: AssemblyFileVersion("#{@tester.file_version}")#{e}|).length.should == 1
-    end
-    it "should contain the trademark information" do
-      subject.scan(%Q|#{s}assembly: AssemblyTrademark("#{@tester.trademark}")#{e}|).length.should == 1
-    end
-    it "should contain the informational version information" do
-      subject.scan(%Q|#{s}assembly: AssemblyInformationalVersion("#{@tester.informational_version}")#{e}|).length.should == 1
-    end
-  end
-end
-describe AssemblyInfo, "when generating an assembly info file with no attributes provided" do
-  include_context "asminfo task"
-  subject do
-    @tester.build_and_read_assemblyinfo_file @asm
-  end
-  it "should not contain the specified version information" do
-    subject.scan(%Q|[assembly: AssemblyVersion("#{@tester.version}")]|).should be_empty
-  end
-  it "should not contain the assembly title" do
-    subject.scan(%Q|[assembly: AssemblyTitle("#{@tester.title}")]|).should be_empty
-  end
-  it "should not contain the assembly description" do
-    subject.scan(%Q|[assembly: AssemblyDescription("#{@tester.description}")]|).should be_empty
-  end
-  it "should not contain the copyright information" do
-    subject.scan(%Q|[assembly: AssemblyCopyright("#{@tester.copyright}")]|).should be_empty
-  end
-  it "should not contain the com visible information" do
-    subject.scan(%Q|[assembly: ComVisible(#{@tester.com_visible})]|).should be_empty
-    subject.scan(%Q|[assembly: Guid("#{@tester.com_guid}")]|).should be_empty
-  end
-  it "should not contain the company name information" do
-    subject.scan(%Q|[assembly: AssemblyCompany("#{@tester.company_name}")]|).should be_empty
-  end
-  it "should not contain the product information" do
-    subject.scan(%Q|[assembly: AssemblyProduct("#{@tester.product_name}")]|).should be_empty
-  end
-  it "should not contain the file version information" do
-    subject.scan(%Q|[assembly: AssemblyFileVersion("#{@tester.file_version}")]|).should be_empty
-  end
-  it "should not contain the trademark information" do
-    subject.scan(%Q|[assembly: AssemblyTrademark("#{@tester.trademark}")]|).should be_empty
-  end
-  it "should not contain the informational version information" do
-    subject.scan(%Q|[assembly: AssemblyInformationalVersion("#{@tester.informational_version}")]|).should be_empty
-  end
-end
-describe AssemblyInfo, "when configuring the assembly info generator with a yaml file" do
-  before :all do
-    @asm = AssemblyInfo.new
-    @asm.configure(AssemblyInfoTester.new.yaml_file)
-  end
-  it "should set the values for the provided attributes" do
-    @asm.version.should == "0.0.1"
-    @asm.company_name.should == "some company name"
-  end
-end
-describe AssemblyInfo, "when assembly info configuration is provided" do
-  let :asm do
-    Albacore.configure do |config|
-      config.assemblyinfo do |asm|
-        asm.company_name = "foo"
-        asm.version = "bar"
-      end
-    end
-    AssemblyInfo.new
-  end
-  it "should use the supplied info" do
-    asm.company_name.should == "foo"
-    asm.version.should == "bar"
-  end
-end
-describe AssemblyInfo, "when specifying custom data" do
-  include_context "asminfo task"
-  before :all do
-    @asm.custom_data "// foo", "// bar"
-  end
-  subject{ @tester.build_and_read_assemblyinfo_file @asm }
-  it "should write data unmodified to the output" do
-    subject.scan('// foo').length.should == 1
-    subject.scan('// bar').length.should == 1
-  end
-end
-describe AssemblyInfo, "when an input file is provided" do
-  include_context "asminfo task"
-  before :all do
-     @asm.version = @tester.version
-     @asm.file_version = @tester.file_version
-     @asm.namespaces "My.Custom.Namespace"
-     @asm.custom_attributes :CustomAttribute => nil
-     @asm.custom_data "// foo", "// baz"
-     # make it use existing file
-     @tester.use_input_file
-  end
-  subject { @tester.build_and_read_assemblyinfo_file @asm }
-  it "should contain correct version attribute" do
-    subject.scan(%Q|[assembly: AssemblyVersion("#{@tester.version}")]|).length.should == 1
-  end
-  it "shoud leave comment untouched" do
-    subject.scan(%Q|// A comment we want to see maintained|).length.should == 1
-  end
-  it "should introduce a new fileversion attribute" do
-    subject.scan(%Q|[assembly: AssemblyFileVersion("#{@tester.file_version}")]|).length.should == 1
-  end
-  it "should still leave custom data that's already in there intact" do
-    subject.scan(%Q|// foo|).length.should == 1
-  end
-  it "should add custom data that's still missing" do
-    subject.scan(%Q|// baz|).length.should == 1
-  end
-  it "should add namespaces to the top of the file" do
-    # Top of file is assumed to be before the first attribute. Comments are ignored.
-    s = subject.split($/)
-    first_attr_line = s.index { |l| l =~ /^\[/ }
-    s.index(%Q|using My.Custom.Namespace;|).should be < first_attr_line
-    s.index(%Q|using System.Reflection;|).should be < first_attr_line
-    s.index(%Q|using System.Runtime.InteropServices;|).should be < first_attr_line
-  end
-  it "should not duplicate namespaces" do
-    subject.scan(%Q|using My.Custom.Namespace;|).length.should == 1
-    subject.scan(%Q|using System.Reflection;|).length.should == 1
-    subject.scan(%Q|using System.Runtime.InteropServices;|).length.should == 1
-  end
-  it "should update existing custom attributes" do
-    subject.scan(%Q|[assembly: CustomAttribute()]|).length.should == 1
-    subject.scan(%Q|[assembly: CustomAttribute(12345)]|).length.should == 0
-  end
-end
-describe AssemblyInfo, "when an input file is provided with no attributes" do
-  include_context "asminfo task"
-  before :all do
-    @asm.company_name = nil
-    @asm.version = nil
-    # make it use existing file
-    @tester.use_input_file
-  end
-  subject { @tester.build_and_read_assemblyinfo_file @asm }
-  # will give a false-positive if input file has no blank lines at the bottom
-  it "should output one blank line at the bottom" do
-    subject.scan(/[^\n]\n\z/).length.should == 1
-  end
-end