albacore 1.0.0 → 2.0.0.rc.1

data/lib/albacore/support/updateattributes.rb

@@ -1,13 +0,0 @@
-module UpdateAttributes
-  def update_attributes(attrs)
-    attrs.each do |key, value|
-      setter = "#{key}="
-      send(setter, value) if respond_to?(setter)
-      @logger.warn "#{key} is not a settable attribute on #{self.class}" unless respond_to?(setter)
-    end
-  end
-
-  def <<(attrs)
-    update_attributes attrs
-  end
-end

data/lib/albacore/support/yamlconfig.rb

@@ -1,18 +0,0 @@
-require 'yaml'
-
-module YAMLConfig  
-  def initialize
-    super()
-  end
-  
-  def load_config_by_task_name(task_name)
-    task_config = "#{task_name}.yml"
-    task_config = File.join(Albacore.configure.yaml_config_folder, task_config) unless Albacore.configure.yaml_config_folder.nil?
-    configure(task_config) if File.exists?(task_config)
-  end
-  
-  def configure(yml_file)
-    config = YAML::load(File.open(yml_file))
-    update_attributes config
-  end  
-end

data/lib/albacore/unzip.rb

@@ -1,42 +0,0 @@
-require "albacore/albacoretask"
-require "albacore/config/unzipconfig"
-require "zip"
-require "zip/filesystem"
-
-class Unzip
-  include Albacore::Task
-  include Configuration::Unzip
-  
-  attr_reader   :force
-  
-  attr_accessor :destination, 
-                :file
-
-  def initialize
-    super()
-    update_attributes(unzip.to_hash)
-  end
-    
-  def execute()
-    unless @file
-      fail_with_message("unzip requires #file")
-      return
-    end
-  
-    Zip::File.open(@file) do |zip|
-      zip.each do |file|
-        path = File.join(@destination, file.name)
-        dir = File.dirname(path)
-        
-        FileUtils.mkdir_p(dir)
-        File.delete(path) if (@force && File.file?(path))
-        
-        zip.extract(file, path) unless File.exist?(path)
-      end
-    end
-  end
-  
-  def force
-    @force = true
-  end
-end

data/lib/albacore/xbuild.rb

@@ -1,41 +0,0 @@
-require "albacore/albacoretask"
-require "albacore/config/xbuildconfig"
-
-class XBuild
-  TaskName = :xbuild
-
-  include Albacore::Task
-  include Albacore::RunCommand
-  include Configuration::XBuild
-  
-  attr_accessor :solution, 
-                :verbosity
-  
-  attr_array    :targets
-  
-  attr_hash     :properties
-  
-  def initialize
-    super()
-    update_attributes(xbuild.to_hash)
-  end
-  
-  def execute
-    unless @solution
-      fail_with_message("xbuild requires #solution")
-      return
-    end
-    
-    result = run_command("xbuild", build_parameters)
-    fail_with_message("XBuild failed, see the build log for more details.") unless result
-  end
-  
-  def build_parameters
-    p = []
-    p << "\"#{solution}\""
-    p << "/verbosity:#{@verbosity}" if @verbosity
-    p << @properties.map { |key, value| "/p:#{key}\=\"#{value}\"" } if @properties
-    p << "/target:#{@targets.join(";")}" if @targets
-    p
-  end
-end

data/lib/albacore/xunit.rb

@@ -1,44 +0,0 @@
-require "albacore/albacoretask"
-require "albacore/config/xunitconfig"
-
-class XUnit
-  TaskName = :xunit
-
-  include Albacore::Task
-  include Albacore::RunCommand
-  include Configuration::XUnit
-
-  attr_accessor :assembly
-  
-  attr_hash     :results_path
-                
-  def initialize()
-    super()
-    update_attributes(xunit.to_hash)
-  end
-
-  def execute()    		
-    unless @assembly
-      fail_with_message("xunit requires #assembly")
-      return
-    end
-    
-    result = run_command("xunit", build_parameters)
-    fail_with_message("XUnit failed, see build log for details.") unless result
-  end
-  
-  def build_parameters
-    p = []  
-    p << "\"#{@assembly}\""
-    p << "/#{@results_path.first.first} \"#{@results_path.first.last}\"" if @results_path
-    p
-  end
-  
-  def build_command_line
-    c = []
-    c << @command
-    c << build_parameters
-    c << @parameters
-    c
-  end
-end

data/lib/albacore/zipdirectory.rb

@@ -1,106 +0,0 @@
-require "albacore/albacoretask"
-require "albacore/config/zipdirectoryconfig"
-require "zip"
-
-class ZipDirectory
-  TaskName = :zip
-
-  include Albacore::Task
-  include Configuration::Zip
-  
-  attr_reader   :flatten
-    
-  attr_accessor :output_path
-  
-  attr_array    :dirs, 
-                :files, 
-                :exclusions
-
-  def initialize
-    @dirs = []
-    @files = []
-    @exclusions = []
-
-    super()
-    update_attributes(zip.to_hash)
-  end
-    
-  def execute()
-    unless @output_path
-      fail_with_message("zip requires #output_path")
-      return
-    end
-
-    FileUtils.rm_rf(@output_path)
-
-    exclusions = Exclusions.new(@dirs)
-    @exclusions.each { |ex| exclusions.expand!(ex) }
-    
-    archive = Archive.new(output_path, exclusions, flatten)
-    @dirs.each { |path| archive.dir(path) }
-    @files.each { |path| archive.file(path) }
-    archive.close()
-  end
-  
-  def flatten
-    @flatten = true
-  end
-end
-
-class Archive
-  def initialize(archive_path, exclusions, flatten)
-    @archive = Zip::File.open(archive_path, Zip::File::CREATE)
-    @exclusions = exclusions
-    @flatten = flatten
-  end
-
-  def dir(dir)
-    pattern = File.join(dir, "**/*")
-    Dir[pattern].each do |file|
-      next if @exclusions.exclude?(file)
-
-      name = @flatten ? file.sub(File.join(dir, "/"), "") : file
-      @archive.add(name, file)
-    end
-  end
-
-  def file(file)
-    return if @exclusions.exclude?(file)
-
-    name = @flatten ? file.split("/").last : file
-    @archive.add(name, file)
-  end
-
-  def close()
-    @archive.close()
-  end
-end
-
-class Exclusions
-  def initialize(dirs)
-    @dirs = dirs
-    @exclusions = []
-  end
-
-  def expand!(ex)
-    if ex.is_a?(Regexp)
-      @exclusions << ex 
-      return
-    end
-
-    @dirs.each do |dir|
-      Dir.chdir(dir) do
-        matches = Dir.glob(ex)
-        matches = matches.map { |path| File.join(dir, path) } unless matches[0] == ex
-        @exclusions += (matches.empty? ? [ex] : matches)
-      end
-    end
-  end
-
-  def exclude?(path)
-    @exclusions.any? do |ex|
-      return path =~ ex if ex.is_a?(Regexp)
-      return path == ex
-    end
-  end
-end

data/spec/albacoremodel_spec.rb

@@ -1,52 +0,0 @@
-require "spec_helper"
-
-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/aspnetcompiler_spec.rb

@@ -1,84 +0,0 @@
-require "spec_helper"
-
-describe AspNetCompiler do
-  subject(:task) do
-    task = AspNetCompiler.new()
-    task.extend(SystemPatch)
-    task.command = "aspnetcompiler"
-    task.physical_path = "physical/path"
-    task.target_path = "target/path"
-    task.clean
-    task.debug
-    task.force
-    task.fixed_names
-    task.delay_sign
-    task.updateable
-    task.no_logo
-    task
-  end
-
-  let(:cmd) { task.system_command }
-
-  context "when overriding all values" do
-    before :each do
-      task.virtual_path = "virtual/path"
-      task.execute
-    end
-
-    it "should use the command" do
-      cmd.should include("aspnetcompiler")
-    end
-
-    it "should use the physical path" do
-      cmd.should include("-p \"physical/path\"") if Albacore::Support::Platform.linux?
-      cmd.should include("-p \"physical\\path\"") if !Albacore::Support::Platform.linux?
-    end
-
-    it "should use the target path" do
-      cmd.should include("\"target/path\"") if Albacore::Support::Platform.linux?
-      cmd.should include("\"target\\path\"") if !Albacore::Support::Platform.linux?
-    end
-
-    it "should use default virtual path" do
-      cmd.should include("-v virtual/path")
-    end
-
-    it "should be clean" do 
-      cmd.should include("-c")
-    end
-
-    it "should show no logo" do
-      cmd.should include("-nologo")
-    end
-
-    it "should delay sign" do 
-      cmd.should include("-delaysign")
-    end
-
-    it "should use fixed names" do 
-      cmd.should include("-fixednames")
-    end
-
-    it "should be updateable" do 
-      cmd.should include("-u")
-    end
-
-    it "should force" do 
-      cmd.should include("-f")
-    end
-
-    it "should debug" do 
-      cmd.should include("-d")
-    end
-  end
-
-  context "when relying on defaults" do
-    before :each do
-      task.execute
-    end
-
-    it "should use the default virtual path" do
-      cmd.should include("-v /")
-    end
-  end
-end

data/spec/assemblyinfo_spec.rb

@@ -1,209 +0,0 @@
-require "fileutils"
-require "spec_helper"
-require "tempfile"
-
-describe AssemblyInfo do
-  let(:input_path) { File.expand_path("spec/assemblyinfo/AssemblyInfo.cs") }
-  let(:output_path) { Tempfile.new("AssemblyInfo") }
-  let(:content) { File.read(output_path) }
-  
-  subject(:task) do
-    task = AssemblyInfo.new()
-    task.output_file = output_path
-    task.version = "1.0.0"
-    task.file_version = "1.0.0"
-    task.informational_version = "1.0.0"
-    task.title = "title"
-    task.description = "description"
-    task.copyright = "copyright"
-    task.company_name = "company"
-    task.product_name = "product"
-    task.trademark = "trademark"
-    task.com_visible
-    task.com_guid = "00000000-0000-0000-0000-000000000000"
-    task.initial_comments = ["//comment"]
-    task.namespaces = ["Foo.Bar"]
-    task.custom_data = ["whatever"]
-    task.custom_attributes = {
-      :String => "string", 
-      :Null => nil,
-      :Literal => false, 
-      :Multiple => ["string", true, 0],
-      :Named => {:one => "string", :two => true, :three => 0},
-      :Mixed => ["string", {:two => true}]
-    } 
-    task
-  end
-
-  after :each do
-    FileUtils.rm_rf(output_path)
-  end
-
-  context "when using the default engine (csharp)" do
-    before :each do
-      task.execute
-    end
-
-    it "should write the comments first" do
-      content.should include("//comment")
-    end
-
-    it "should write the custom namespaces" do
-      content.should include("using Foo.Bar;")
-    end
-
-    it "should write the required namespaces" do
-      content.should include("using System.Reflection;")
-      content.should include("using System.Runtime.InteropServices;")
-    end
-
-    it "should write the title" do
-      content.should include("[assembly: AssemblyTitle(\"title\")]")
-    end
-
-    it "should write the description" do
-      content.should include("[assembly: AssemblyDescription(\"description\")]")
-    end
-
-    it "should write the company" do
-      content.should include("[assembly: AssemblyCompany(\"company\")]")
-    end
-
-    it "should write the product" do
-      content.should include("[assembly: AssemblyProduct(\"product\")]")
-    end
-
-    it "should write the copyright" do
-      content.should include("[assembly: AssemblyCopyright(\"copyright\")]")
-    end
-
-    it "should write the trademark" do
-      content.should include("[assembly: AssemblyTrademark(\"trademark\")]")
-    end
-
-    it "should be COM visible" do
-      content.should include("[assembly: ComVisible(true)]")
-    end
-
-    it "should write the COM guid" do
-      content.should include("[assembly: Guid(\"00000000-0000-0000-0000-000000000000\")]")
-    end
-
-    it "should write the version" do
-      content.should include("[assembly: AssemblyVersion(\"1.0.0\")]")
-    end
-
-    it "should write the file version" do
-      content.should include("[assembly: AssemblyFileVersion(\"1.0.0\")]")
-    end
-
-    it "should write the informational version" do
-      content.should include("[assembly: AssemblyInformationalVersion(\"1.0.0\")]")
-    end
-
-    it "should write the custom string attribute" do
-      content.should include("[assembly: String(\"string\")]")
-    end
-
-    it "should write the custom null attribute" do
-      content.should include("[assembly: Null()]")
-    end
-
-    it "should write the custom literal attribute" do
-      content.should include("[assembly: Literal(false)]")
-    end
-
-    it "should write the custom multi-value attribute" do
-      content.should include("[assembly: Multiple(\"string\", true, 0)]")
-    end
-
-    it "should write the custom multi-value-named attribute" do
-      content.should include("[assembly: Named(one = \"string\", two = true, three = 0)]")
-    end
-
-    it "should write the custom mixed-multi-value attribute" do
-      content.should include("[assembly: Mixed(\"string\", two = true)]")
-    end
-
-    it "should write the custom data" do
-      content.should include("whatever")
-    end
-  end
-
-  context "when starting from an input file" do
-    before :each do
-      task.input_file = input_path
-      task.title = nil #=> so it isn't overwritten
-      task.execute
-    end
-
-    it "should not lose existing comments" do
-      content.should include("// General Information about an assembly is controlled through the following")
-    end
-
-    it "should not lose existing namespaces" do
-      content.should include("using System.Runtime.InteropServices;")
-    end
-
-    it "should not lose existing attributes" do
-      content.should include("[assembly: AssemblyTitle(\"TestSolution\")]")
-    end
-
-    it "should overwrite customized properties" do
-      content.should include("[assembly: AssemblyVersion(\"1.0.0\")]")
-    end
-  end
-
-  context "when using the fsharp engine" do
-    before :each do
-      task.lang_engine = FSharpEngine.new()
-      task.execute
-    end
-
-    it "should contain a module definition" do
-      content.should include("module AssemblyInfo")
-    end
-
-    it "should contain the module definition ending" do
-      content.should include("()")
-    end
-
-    it "should use open for namespaces" do
-      content.should include("open System.Reflection")
-    end
-
-    it "should use angle brackets for attributes" do
-      content.should include("[<assembly: AssemblyTitle(\"title\")>]")
-    end
-  end
-
-  context "when using the vbnet engine" do
-    before :each do
-      task.lang_engine = VbNetEngine.new()
-      task.execute
-    end
-
-    it "should use imports for namespaces" do
-      content.should include("Imports System.Reflection")
-    end
-
-    it "should use angle brackets for attributes" do
-      content.should include("<assembly: AssemblyTitle(\"title\")>")
-    end
-  end
-
-  context "when using the cpp cli engine" do
-    before :each do
-      task.lang_engine = CppCliEngine.new()
-      task.execute
-    end
-
-    it "should use using for namespaces" do
-      content.should include("using namespace System::Reflection;")
-    end
-
-    it "should use square brackets for attributes" do
-      content.should include("[assembly: AssemblyTitle(\"title\")]")
-    end
-  end
-end