albacore 1.0.0.rc.2 → 1.0.0.rc.3

data/lib/albacore/unzip.rb

@@ -1,34 +1,42 @@
-require 'albacore/albacoretask'
-require 'zip'
-require 'zip/filesystem'
-include Zip
-
-class Unzip
-  include Albacore::Task
-  
-  attr_accessor :destination, :file
-
-  def initialize
-    super()
-    update_attributes Albacore.configuration.unzip.to_hash
-  end
-    
-  def execute()
-    fail_with_message 'Zip File cannot be empty' if @file.nil?
-    return if @file.nil?
-  
-    Zip::File.open(@file) do |zip_f|
-      zip_f.each do |f|
-        out_path = File.join(@destination, f.name)
-        FileUtils.mkdir_p(File.dirname(out_path))
-
-        File.delete(out_path) if @force and File.file?(out_path)
-        zip_f.extract(f, out_path) unless File.exist?(out_path)
-      end
-    end
-  end
-  
-  def force
-    @force = true
-  end
-end
+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/version.rb

@@ -1,3 +1,3 @@
 module Albacore
-  VERSION = "1.0.0.rc.2"
+  VERSION = "1.0.0.rc.3"
 end

data/lib/albacore/xbuild.rb

@@ -1,54 +1,41 @@
-require 'albacore/albacoretask'
+require "albacore/albacoretask"
+require "albacore/config/xbuildconfig"
 
 class XBuild
-  TaskName = [:xbuild, :mono]
+  TaskName = :xbuild
+
   include Albacore::Task
   include Albacore::RunCommand
+  include Configuration::XBuild
+  
+  attr_accessor :solution, 
+                :verbosity
   
-  attr_accessor :solution, :verbosity
-  attr_array :targets
-  attr_hash :properties
+  attr_array    :targets
+  
+  attr_hash     :properties
   
   def initialize
-    @command = 'xbuild'
     super()
-    update_attributes Albacore.configuration.xbuild.to_hash
+    update_attributes(xbuild.to_hash)
   end
   
   def execute
-    build_solution(@solution)
-  end
-  
-  def build_solution(solution)
-    check_solution solution
-    
-    command_parameters = []
-    command_parameters << "\"#{solution}\""
-    command_parameters << "\"/verbosity:#{@verbosity}\"" if @verbosity != nil
-    command_parameters << build_properties if @properties != nil
-    command_parameters << "\"/target:#{build_targets}\"" if @targets != nil
-    
-    result = run_command "xBuild", command_parameters.join(" ")
+    unless @solution
+      fail_with_message("xbuild requires #solution")
+      return
+    end
     
-    failure_message = 'xBuild Failed. See Build Log For Detail'
-    fail_with_message failure_message if !result
-  end
-  
-  def check_solution(file)
-    return if file
-    msg = 'solution cannot be nil'
-    fail_with_message msg
+    result = run_command("xbuild", build_parameters)
+    fail_with_message("XBuild failed, see the build log for more details.") unless result
   end
   
-  def build_targets
-    @targets.join ";"
-  end
-
-  def build_properties
-    option_text = []
-    @properties.each do |key, value|
-      option_text << "/p:#{key}\=\"#{value}\""
-    end
-    option_text.join(" ")
+  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

@@ -0,0 +1,44 @@
+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,107 +1,106 @@
-require 'albacore/albacoretask'
-require 'zip'
-require 'zip/filesystem'
-
-class ZipDirectory
-  TaskName = :zip
-  include Albacore::Task
-  
-  attr_accessor :output_path, :output_file
-  attr_reader :flatten_zip
-  attr_array :directories_to_zip, :additional_files, :exclusions
-
-  def initialize
-    @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
-
-    Zip::File.open(zip_name, 'w')  do |zipfile|
-      zip_directory(zipfile)
-      zip_additional(zipfile)
-    end
-  end
-  
-  def flatten_zip
-    @flatten_zip = true
-  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 = @flatten_zip ? file_path.sub(d + '/','') : file_path
-        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 = @flatten_zip ? file_path.split('/').last : file_path
-      zipfile.add(file_name, file_path)
-    end
-  end
-end
+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,53 +1,52 @@
-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
+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