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

data/lib/albacore/ncoverconsole.rb

@@ -1,68 +1,56 @@
-require 'albacore/albacoretask'
+require "albacore/albacoretask"
+require "albacore/config/ncoverconsoleconfig"
 
 class NCoverConsole
+  TaskName = :ncoverconsole
+
   include Albacore::Task
   include Albacore::RunCommand
+  include Configuration::NCoverConsole
+
+  attr_reader   :register
   
-  attr_accessor :testrunner
-  attr_array :cover_assemblies, :exclude_assemblies, :coverage, :exclude_attributes
-  attr_hash :output
+  attr_accessor :test_runner
+
+  attr_array    :include_assemblies, 
+                :exclude_assemblies, 
+                :include_attributes,
+                :exclude_attributes,
+                :coverage
+
+  attr_hash     :output
   
   def initialize
-    @register_dll = true
-    @output = {}
-    @cover_assemblies = []
-    @exclude_assemblies = []
-    @exclude_attributes = []
-    @coverage = []
+    @register = true
+    
     super()
-    update_attributes Albacore.configuration.ncoverconsole.to_hash
-  end
-  
-  def no_registration
-    @register_dll = false
+    update_attributes(ncoverconsole.to_hash)
   end
   
   def execute
-    return unless check_for_testrunner
-    
-    command_parameters = []
-    command_parameters << "//reg" if @register_dll
-    command_parameters << build_output_options(@output) unless @output.nil?
-    command_parameters << build_parameter_list("assemblies", @cover_assemblies) unless @cover_assemblies.empty?
-    command_parameters << build_parameter_list("exclude-assemblies", @exclude_assemblies) unless @exclude_assemblies.empty?
-    command_parameters << build_parameter_list("exclude-attributes", @exclude_attributes) unless @exclude_attributes.empty?
-    command_parameters << build_coverage_list(@coverage) unless @coverage.empty?
-    command_parameters << @testrunner.get_command_line
-    
-    result = run_command "NCover.Console", command_parameters.join(" ")
-    
-    failure_msg = 'Code Coverage Analysis Failed. See Build Log For Detail.'
-    fail_with_message failure_msg if !result
-  end
-  
-  def check_for_testrunner
-    return true if (!@testrunner.nil?)
-    msg = 'testrunner cannot be nil.'
-    @logger.info msg
-    fail
-    return false
-  end
-  
-  def build_output_options(output)
-    options = []
-    output.each do |key, value|
-      options << "//#{key} #{value}"
+    unless @test_runner
+      fail_with_message("ncoverconsole requires #test_runner")
+      return
     end
-    options.join(" ")
+    
+    result = run_command("ncoverconsole", build_parameters)
+    fail_with_message("NCover Console failed, see the build log for more details.") unless result
   end
   
-  def build_parameter_list(param_name, list)
-    list = list.map{|asm| "\"#{asm}\""}.join(';')
-    "//#{param_name} #{list}"
+  def build_parameters
+    p = []
+    p << "//reg" if @register
+    p << @output.map { |key, value| "//#{key} \"#{value}\"" } if @output
+    p << "//include-assemblies \"#{@include_assemblies.join(";")}\"" if @include_assemblies
+    p << "//exclude-assemblies \"#{@exclude_assemblies.join(";")}\"" if @exclude_assemblies
+    p << "//include-attributes \"#{@include_attributes.join(";")}\"" if @include_attributes
+    p << "//exclude-attributes \"#{@exclude_attributes.join(";")}\"" if @exclude_attributes
+    p << "//coverage-type \"#{@coverage.join(", ")}\"" if @coverage
+    p << @test_runner.build_command_line
+    p
   end
   
-  def build_coverage_list(coverage)
-    "//coverage-type \"#{coverage.join(', ')}\""
+  def no_registration
+    @register = false
   end
 end

data/lib/albacore/ncoverreport.rb

@@ -1,62 +1,40 @@
-Dir.glob(File.join(File.expand_path(File.dirname(__FILE__)), 'ncoverreports/*.rb')).each {|f| require f }
-require 'albacore/albacoretask'
+require "albacore/albacoretask"
+require "albacore/ncoverreports"
+require "albacore/config/ncoverreportconfig"
 
 class NCoverReport
+  TaskName = :ncoverreport
+
   include Albacore::Task
   include Albacore::RunCommand
+  include Configuration::NCoverReport
   
-  attr_array :coverage_files, :reports, :required_coverage, :filters
+  attr_array :coverage_files, 
+             :reports, 
+             :required_coverage, 
+             :filters
   
   def initialize
-    @coverage_files = []
-    @reports = []
-    @required_coverage = []
-    @filters = []
     super()
-    update_attributes Albacore.configuration.ncoverreport.to_hash
+    update_attributes(ncoverreport.to_hash)
   end
   
   def execute
-    return unless check_command
-    
-    command_parameters = []
-    command_parameters << build_coverage_files unless @coverage_files.empty?
-    command_parameters << build_reports unless @reports.empty?
-    command_parameters << build_required_coverage unless @required_coverage.empty?
-    command_parameters << build_filters unless @filters.empty?
-    
-    result = run_command "NCover.Reporting", command_parameters.join(" ")
+    unless @command
+      fail_with_message("ncoverreport requires #command")
+      return
+    end
     
-    failure_msg = 'Code Coverage Reporting Failed. See Build Log For Detail.'
-    fail_with_message failure_msg if !result
+    result = run_command("ncoverreport", build_parameters)
+    fail_with_message("NCover Report failed, see the build log for more details.") unless result
   end
   
-  def check_command
-    return true if @command
-    fail_with_message 'NCoverReport.command cannot be nil.'
-    return false
-  end
-  
-  def build_filters
-    @filters.map{|f| "//cf #{f.get_filter_options}"}.join(" ")
-  end
-  
-  def build_coverage_files
-    @coverage_files.map{|f| "\"#{f}\""}.join(" ")
-  end
-  
-  def build_reports
-    @reports.map{|r|
-      report = "//or #{r.report_type}"
-      report << ":#{r.report_format}" unless r.report_format.nil?
-      report << ":\"#{r.output_path}\"" unless r.output_path.nil?
-      report
-    }.join(" ")
-  end
-
-  def build_required_coverage
-    @required_coverage.map{|c|
-      coverage = "//mc #{c.get_coverage_options}"
-    }.join(" ")
+  def build_parameters
+    p = []
+    p << @coverage_files.map { |file| "\"#{file}\"" } if @coverage_files
+    p << @reports.map { |report| "//or #{report.get_report_options}" } if @reports
+    p << @required_coverage.map { |coverage| "//mc #{coverage.get_coverage_options}" } if @required_coverage
+    p << @filters.map { |filter| "//cf #{filter.get_filter_options}" } if @filters
+    p
   end
 end

data/lib/albacore/ncoverreports.rb

@@ -0,0 +1,16 @@
+require "albacore/ncoverreports/reportbase"
+require "albacore/ncoverreports/fullcoveragereport"
+require "albacore/ncoverreports/summaryreport"
+
+require "albacore/ncoverreports/codecoveragebase"
+require "albacore/ncoverreports/branchcoverage"
+require "albacore/ncoverreports/methodcoverage"
+require "albacore/ncoverreports/symbolcoverage"
+require "albacore/ncoverreports/cyclomaticcomplexity"
+
+require "albacore/ncoverreports/reportfilterbase"
+require "albacore/ncoverreports/assemblyfilter"
+require "albacore/ncoverreports/classfilter"
+require "albacore/ncoverreports/documentfilter"
+require "albacore/ncoverreports/methodfilter"
+require "albacore/ncoverreports/namespacefilter"

data/lib/albacore/ncoverreports/codecoveragebase.rb

@@ -4,21 +4,23 @@ module NCover
   class CodeCoverageBase
     include UpdateAttributes
     
-    attr_accessor :coverage_type, :minimum, :item_type 
+    attr_accessor :coverage_type, 
+                  :minimum, 
+                  :item_type 
     
     def initialize(coverage_type, params={})
       @coverage_type = coverage_type
       @minimum = 0
       @item_type = :View
-      update_attributes(params) unless params.nil?
+      update_attributes(params) if params
       super()
     end
     
     def get_coverage_options
-      options = "#{@coverage_type}"
-      options << ":#{@minimum}" unless @minimum.nil?
-      options << ":#{@item_type}" unless @item_type.nil?
-      options
+      o = "#{@coverage_type}"
+      o << ":#{@minimum}" if @minimum
+      o << ":#{@item_type}" if @item_type
+      o
     end
   end
 end  

data/lib/albacore/ncoverreports/cyclomaticcomplexity.rb

@@ -9,14 +9,14 @@ module NCover
     def initialize(params={})
       @maximum = 100
       @item_type = :View
-      update_attributes(params) unless params.nil?
+      update_attributes(params) if params
       super()
     end
     
     def get_coverage_options
       options = "CyclomaticComplexity"
-      options << ":#{maximum}" unless maximum.nil?
-      options << ":#{item_type}" unless item_type.nil?
+      options << ":#{@maximum}" if @maximum
+      options << ":#{@item_type}" if @item_type
       options
     end
   end

data/lib/albacore/ncoverreports/fullcoveragereport.rb

@@ -1,13 +1,9 @@
 module NCover
-  class FullCoverageReport
-    attr_accessor :output_path
-    
-    def report_type
-      :FullCoverageReport
-    end
-    
-    def report_format
-      :Html
+  class FullCoverageReport < NCover::ReportBase
+    def initialize(params = {})
+      @report_type = :FullCoverageReport
+      @report_format = :Html
+      super(params)
     end
   end
 end

data/lib/albacore/ncoverreports/reportbase.rb

@@ -0,0 +1,23 @@
+require "albacore/support/updateattributes"
+
+module NCover
+  class ReportBase
+    include UpdateAttributes
+    
+    attr_accessor :output_path, 
+                  :report_format, 
+                  :report_type
+    
+    def initialize(params = {})
+      update_attributes(params) if params
+      super()
+    end
+    
+    def get_report_options()
+      o = "#{@report_type}"
+      o << ":#{@report_format}" if @report_format
+      o << ":\"#{@output_path}\"" if @output_path
+      o
+    end
+  end
+end

data/lib/albacore/ncoverreports/reportfilterbase.rb

@@ -4,23 +4,26 @@ module NCover
   class ReportFilterBase
     include UpdateAttributes
     
-    attr_accessor :filter, :filter_type, :item_type, :is_regex
+    attr_accessor :filter,
+                  :filter_type,
+                  :item_type, 
+                  :is_regex
     
     def initialize(item_type, params={})
       @filter = ""
       @item_type = item_type
       @is_regex = false
       @filter_type = :exclude
-      update_attributes(params) unless params.nil?
+      update_attributes(params) if params
       super()
     end
   
     def get_filter_options
-      filter = "\"#{@filter}\""
-      filter << ":#{@item_type}"
-      filter << ":#{@is_regex}"
-      filter << ":#{(@filter_type == :include)}"
-      filter
+      f = "\"#{@filter}\""
+      f << ":#{@item_type}"
+      f << ":#{@is_regex}"
+      f << ":#{@filter_type == :include}"
+      f
     end
   end
 end  

data/lib/albacore/ncoverreports/summaryreport.rb

@@ -1,18 +1,9 @@
 module NCover
-  class SummaryReport
-    attr_accessor :output_path
-    
-    def initialize
-      @report_format = :Xml
-      super()
-    end
-    
-    def report_type
-      :Summary
-    end
-    
-    def report_format
-      :Html
+  class SummaryReport < NCover::ReportBase
+    def initialize(params = {})
+      @report_type = :Summary
+      @report_format = :Html
+      super(params)
     end
   end
 end

data/lib/albacore/ndepend.rb

@@ -1,33 +1,33 @@
-require 'albacore/albacoretask'
+require "albacore/albacoretask"
+require "albacore/config/ndependconfig"
 
 class NDepend
+  TaskName = :ndepend
+
   include Albacore::Task
   include Albacore::RunCommand
+  include Configuration::NDepend
 
   attr_accessor :project_file
 
   def initialize()
     super()
-    update_attributes Albacore.configuration.ndepend.to_hash
+    update_attributes(ndepend.to_hash)
   end
   
   def execute
-    return unless check_command
-    result = run_command @command, create_parameters.join(" ")
-    failure_message = 'Command Failed. See Build Log For Detail'
-    fail_with_message failure_message if !result
-  end
-
-  def create_parameters
-    params = []
-    params << File.expand_path(@project_file)
-    params
+    unless @project_file
+      fail_with_message("ndepend requires #project_file")
+      return
+    end
+    
+    result = run_command(@command, build_parameters)
+    fail_with_message("NDepend failed, see the build log for more details.") unless result
   end
 
-  def check_command
-    return true if @project_file
-    fail_with_message 'A ndepend project file is required'
-    false
+  def build_parameters
+    p = []
+    p << "\"#{File.expand_path(@project_file)}\""
+    p
   end
-
 end

data/lib/albacore/nugetinstall.rb

@@ -1,57 +1,62 @@
-require 'albacore/albacoretask'
-require 'albacore/support/supportlinux'
+require "albacore/albacoretask"
+require "albacore/config/nugetinstallconfig"
 
 class NuGetInstall
-	include Albacore::Task
- 	include Albacore::RunCommand
- 	include SupportsLinuxEnvironment
+  TaskName = :nugetinstall
 
- 	attr_accessor	:command,
-                :package,
-                :output_directory,
-                :version,
-                :exclude_version,
+  include Albacore::Task
+  include Albacore::RunCommand
+  include Configuration::NuGetInstall
+
+  attr_reader   :no_cache,
                 :prerelease,
-                :no_cache
+                :exclude_version
+  
+  attr_accessor	:package,
+                :output_directory,
+                :version
 
-	attr_array :sources
+	attr_array    :sources
 
-	def initialize(command='NuGet.exe')
-		super()
-		@sources = []
-		@command = command
-		@no_cache = false
-		@prerelease = false
-		@exclude_version = false
+	def initialize()
+		@command = "nuget"
+    
+    super()
+    update_attributes(nugetinstall.to_hash)
 	end
 
 	def execute
-		params = generate_params
-
-		@logger.debug "Build NuGet Install Command Line: #{params}"
-		result = run_command "NuGet", params
-
-		failure_message = "Nuget Install for package #{@package} failed. See Build log for details."
-		fail_with_message failure_message unless result
+    unless @package
+      fail_with_message("nugetinstall requires #package")
+      return
+    end
+    
+		result = run_command("nugetinstall", build_parameters)
+		fail_with_message("NuGet Install failed, see the build log for more details.") unless result
 	end
 
-	def generate_params
-		fail_with_message 'A NuGet package must be specified.' unless @package
-
-		params = []
-		params << 'install'
-		params << package
-		params << "-Version #{version}" if @version
-		params << "-OutputDirectory #{output_directory}" if @output_directory
-		params << "-ExcludeVersion" if @exclude_version
-		params << "-NoCache" if @no_cache
-		params << "-Prerelease" if @prerelease
-		params << "-Source #{build_package_sources}" if @sources unless @sources.empty?
-
-		merged_params = params.join(' ')
+	def build_parameters
+		p = []
+		p << "install"
+		p << @package
+		p << "-Version #{@version}" if @version
+		p << "-OutputDirectory \"#{@output_directory}\"" if @output_directory
+		p << "-ExcludeVersion" if @exclude_version
+		p << "-NoCache" if @no_cache
+		p << "-Prerelease" if @prerelease
+		p << "-Source \"#{@sources.join(";")}\"" if @sources
+		p
 	end
 
-	def build_package_sources
-		"\"#{@sources.join(';')}\""
-	end
+  def no_cache
+    @no_cache = true
+  end
+
+  def prerelease
+    @prerelease = true
+  end
+  
+  def exclude_version
+    @exclude_version = true
+  end
 end