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

data/lib/albacore/output.rb

@@ -1,108 +1,105 @@
-require 'albacore/albacoretask'
-require 'erb'
-require 'ostruct'
-require 'fileutils'
+require "albacore/albacoretask"
+require "erb"
+require "ostruct"
+require "fileutils"
 
-class OutputBuilder
-  include ::Rake::DSL if defined?(::Rake::DSL)
-  
-  def initialize(dir_to, dir_from)
-    @dir_to = dir_to
-    @dir_from = dir_from
+class Output
+  include Albacore::Task
+
+  attr_reader :preserve
+
+  def initialize
+    super()
+
+    @files = []
+    @erbs = []
+    @dirs = []
   end
-  
-  def dir(d)
-    dir(d,d)
+
+  def execute()
+    unless (@from && @to)
+      fail_with_message("output requires #from and #to")
+      return
+    end
+
+    output = OutputBuilder.new(@from, @to)
+
+    FileUtils.rm_rf(@to) unless @preserve
+    FileUtils.mkdir_p(@to)    
+
+    @dirs.each { |dir| output.dir(*dir) }
+    @files.each { |file| output.file(*file) }
+    @erbs.each { |erb| output.erb(*erb) }
   end
 
-  def dir(dir, dir_to)
-    FileUtils.cp_r "#{@dir_from}/#{dir}", "#{@dir_to}/#{dir_to}"
+  def from(source)
+    @from = source
   end
 
-  def file(f)
-    file(f,f)
+  def to(source)
+    @to = source
   end
-    
-  def file(f, ft)
-    #todo find more elegant way to create base dir if missing for file.
-    initialize_to_path(ft)
-    FileUtils.cp "#{@dir_from}/#{f}", "#{@dir_to}/#{ft}"
+
+  def preserve
+    @preserve = true
   end
-  
-  def erb(f, ft, locals)
-    initialize_to_path(ft)
-    erb = ERB.new(File.read("#{@dir_from}/#{f}"))
-    File.open("#{@dir_to}/#{ft}", 'w') {|f| f.write erb.result(ErbBinding.new(locals).get_binding)}
+    
+  def file(source, opts = {})
+    @files << [source, opts[:as] || source]
   end
   
-  def self.output_to(dir_to, dir_from, keep_to)
-    FileUtils.rmtree dir_to unless keep_to
-    FileUtils.mkdir_p dir_to unless Dir.exists? dir_to
-    yield OutputBuilder.new(dir_to, dir_from)
+  def dir(source, opts = {})
+    @dirs << [source, opts[:as] || source]
   end
   
-private
-  def initialize_to_path(ft)
-    topath = File.dirname("#{@dir_to}/#{ft}")
-    FileUtils.mkdir_p topath unless File.exist? topath
-    topath
-  end
-end
-
-class ErbBinding < OpenStruct
-  def get_binding
-    return binding()
+  def erb(source, opts = {})
+    @erbs << [source, opts[:as] || source, opts[:locals] || {}]
   end
 end
-  
 
-class Output
-  include Albacore::Task
-
-  def initialize
-    super()
-
-    @files = []
-    @erbs = []
-    @directories = []
-    @keep_to = false
+class OutputBuilder  
+  def initialize(from, to)
+    @from = from
+    @to = to
   end
 
-  def execute()
-    fail_with_message 'No base dir' if @from_dir.nil?
-    fail_with_message 'No output dir' if @to_dir.nil?
+  def dir(source, destination)
+    from = File.join(@from, source)
+    to = File.join(@to, destination)
 
-    OutputBuilder.output_to(@to_dir, @from_dir, @keep_to)  do |o|
-      @directories.each { |d| o.dir *d }
-      @files.each { |f| o.file *f }
-      @erbs.each { |f| o.erb *f }
-    end
+    FileUtils.cp_r(from, to)
   end
   
-  def file(f, opts={})
-    f_to = opts[:as] || f
-    @files << [f,f_to]
-  end
+  def file(source, destination)
+    from = File.join(@from, source)
+    to = File.join(@to, destination)
 
-  def keep_to
-   @keep_to = true
-  end
-  def erb(f, opts={})
-    f_to = opts[:as] || f
-    @erbs << [f,f_to,opts[:locals]||{}]
+    FileUtils.cp_p(from, to)
   end
   
-  def dir(d, opts={})
-    d_to = opts[:as]
-    @directories << [d,d_to]
+  def erb(source, destination, locals)
+    from = File.join(@from, source)
+    to = File.join(@to, destination)
+
+    erb = ERB.new(File.read(from))
+    binding = ErbBinding.new(locals)
+    content = erb.result(binding.get_binding())
+    
+    FileUtils.mkdir_p(File.dirname(to))
+    File.write(to, content)
   end
-  
-  def from(from_dir)
-    @from_dir = from_dir
+end
+
+module FileUtils
+  # copy a file, creating the full source, if necessary
+  def self.cp_p(source, destination)
+    FileUtils.mkdir_p(File.dirname(destination))
+    FileUtils.cp(source, destination)
   end
+end
 
-  def to(to_dir)
-    @to_dir = to_dir
+class ErbBinding < OpenStruct
+  def get_binding
+    return binding()
   end
-  
 end

data/lib/albacore/plink.rb

@@ -1,47 +1,50 @@
-require 'albacore/albacoretask'
+require "albacore/albacoretask"
+require "albacore/config/plinkconfig"
 
 class PLink
+  TaskName = :plink
+  
   include Albacore::Task
   include Albacore::RunCommand
+  include Configuration::PLink
+
+  attr_reader   :verbose
 
-  attr_accessor :host, :port, :user, :key, :verbose
-  attr_array :commands
+  attr_accessor :host, 
+                :port, 
+                :user, 
+                :key
+
+  attr_array    :commands
 
   def initialize()
-      @require_valid_command = false
-      @port = 22
-      @verbose = false
-      @commands = []
-      super()
+    @port = 22
+    
+    super()
+    update_attributes(plink.to_hash)
   end
 
-  def run()
-    return unless check_command
+  def execute()
+    unless @command
+      fail_with_message("plink requires #command")
+      return
+    end
     
-    parameters = create_parameters
-    result = run_command "Plink", parameters.join(" ")
-    failure_message = 'Command Failed. See Build Log For Detail'
-    fail_with_message failure_message if !result
-  end
-  
-  def create_parameters
-    parameters = []
-    parameters << "#{@user}@#{@host} -P #{@port} "
-    parameters << build_parameter("i", @key) unless @key.nil?
-    parameters << "-batch"
-    parameters << "-v" if @verbose
-    parameters << @commands
-    @logger.debug "PLink Parameters" + parameters.join(" ")
-    return parameters
+    result = run_command("plink", build_parameters)
+    fail_with_message("PLink failed, see the build log for more details") unless result
   end
 
-  def build_parameter(param_name, param_value)
-    "-#{param_name} #{param_value}"
+  def build_parameters
+    p = []
+    p << "#{"#{@user}@" if @user}#{@host} -P #{@port}"
+    p << "-i #{@key}" if @key
+    p << "-batch"
+    p << "-v" if @verbose
+    p << @commands if @commands
+    p
   end
 
-  def check_command
-    return true if @command
-    fail_with_message 'Plink.path_to_command cannot be nil.'
-    return false
-  end
+  def verbose
+    @verbose = true
+  end    
 end

data/lib/albacore/specflow.rb

@@ -0,0 +1,30 @@
+require "albacore/albacoretask"
+require "albacore/config/specflowconfig"
+
+class SpecFlow
+  TaskName = :specflow
+  
+  include Albacore::Task
+  include Albacore::RunCommand
+  include Configuration::SpecFlow
+  
+  attr_accessor :report, 
+                :project
+  
+  def initialize()
+    super()
+    update_attributes(specflow.to_hash)
+  end
+  
+  def execute()
+    result = run_command("specflow", build_parameters)
+    fail_with_message("SpecFlow failed, see the build log for more details.") unless result
+  end  
+    	
+  def build_parameters
+    p = []
+    p << @report
+    p << "\"#{@project}\""
+    p
+  end
+end

data/lib/albacore/sqlcmd.rb

@@ -1,82 +1,67 @@
-require 'albacore/albacoretask'
+require "albacore/albacoretask"
+require "albacore/config/sqlcmdconfig"
 
 class SQLCmd
+  TaskName = :sqlcmd
+
   include Albacore::Task
   include Albacore::RunCommand
+  include Configuration::SQLCmd
+
+  attr_reader   :trusted_connection,
+                :ignore_variables,
+                :batch_abort
   
-  attr_accessor :server, :database, :username, :password, :trusted_connection, :batch_abort, :severity
-  attr_array :scripts
-  attr_hash :variables
+  attr_accessor :server, 
+                :database, 
+                :username, 
+                :password, 
+                :severity
+
+  attr_array    :scripts
+
+  attr_hash     :variables
   
   def initialize
-    @require_valid_command = false
-    @scripts=[]
-    @variables={}
-    @trusted_connection = true
-    @batch_abort = true
-    @severity = nil
+    @command = "sqlcmd"
+    
     super()
-    update_attributes Albacore.configuration.sqlcmd.to_hash
+    update_attributes(sqlcmd.to_hash)
   end
   
   def execute
-    return unless check_command
-    
-    cmd_params=[]
-    serverParam = @server.nil? ? build_parameter("S", ".") : build_parameter("S", @server)
-    cmd_params << serverParam
-    cmd_params << build_parameter("d", @database) unless @database.nil?
-    cmd_params << get_authentication_params
-    cmd_params << build_variable_list if @variables.length > 0
-    cmd_params << get_batch_abort_param
-    cmd_params << build_script_list if @scripts.length > 0
-    cmd_params << build_parameter("V", @severity) unless @severity.nil?
-    
-    result = run_command "SQLCmd", cmd_params.join(" ")
-    
-    failure_msg = 'SQLCmd Failed. See Build Log For Detail.'
-    fail_with_message failure_msg if !result
-  end
-
-  def get_batch_abort_param
-    "-b" if (@scripts.length > 1 && @batch_abort)
-  end
-
-  def get_authentication_params
-    integratedParam = "-E" if @trusted_connection
-    if ((!(@username.nil?)) and (!(@password.nil?)))
-      integratedParam = build_parameter("U", @username) + " " + build_parameter("P", @password)
+    unless @command
+      fail_with_message("sqlcmd requires #command")
+      return
     end
-    integratedParam
+    
+    result = run_command("sqlcmd", build_parameters)
+    fail_with_message("SQLCMD failed, see the build log for more details.") unless result
   end
-
-  def check_command
-    sql2012cmdPath = File.join(ENV['SystemDrive'],'program files','microsoft sql server','110','tools','binn', 'sqlcmd.exe')
-    sql2008cmdPath = File.join(ENV['SystemDrive'],'program files','microsoft sql server','100','tools','binn', 'sqlcmd.exe')
-    sql2005cmdPath = File.join(ENV['SystemDrive'],'program files','microsoft sql server','90','tools','binn', 'sqlcmd.exe')
-    sql2012cmdPathx86 = File.join(ENV['SystemDrive'],'program files (x86)','microsoft sql server','110','tools','binn', 'sqlcmd.exe')
-    sql2008cmdPathx86 = File.join(ENV['SystemDrive'],'program files (x86)','microsoft sql server','100','tools','binn', 'sqlcmd.exe')
-    sql2005cmdPathx86 = File.join(ENV['SystemDrive'],'program files (x86)','microsoft sql server','90','tools','binn', 'sqlcmd.exe')
-    @command = [sql2012cmdPath, sql2008cmdPath, sql2005cmdPath, sql2012cmdPathx86, sql2008cmdPathx86, sql2005cmdPathx86].select { |p| File.exist?(p) }.first
-    return true if @command != nil
-    fail_with_message 'SQLCmd.command cannot be nil.'
-    return false
+  
+  def build_parameters
+    p = []
+    p << "-S \"#{@server}\"" if @server
+    p << "-d \"#{@database}\"" if @database
+    p << "-E" if @trusted_connection
+    p << "-U \"#{@username}\" -P \"#{@password}\"" if (@username && @password)
+    p << @variables.map { |key, value| "-v #{key}=\"#{value}\"" } if @variables
+    p << "-b" if @batch_abort
+    p << @scripts.map { |script| "-i \"#{script}\"" } if @scripts
+    p << "-V #{@severity}" if @severity
+    p << "-x" if @ignore_variables
+    p
   end
 
-  def build_script_list
-    @scripts.map{|s| "-i \"#{s.strip}\""}.join(" ")
+  def trusted_connection
+    @trusted_connection = true
   end
   
-  def build_parameter(param_name, param_value)
-    "-#{param_name} \"#{param_value}\""
+  def ignore_variables
+    @ignore_variables = true
   end
   
-  def build_variable_list
-    vars = []
-    @variables.each do |k,v| 
-      vars << "-v #{k}=#{v}"
-    end
-    vars.join(" ")
+  def batch_abort
+    @batch_abort = true
   end
-  
 end

data/lib/albacore/support/platform.rb

@@ -0,0 +1,25 @@
+module Albacore
+  module Support
+    class Platform
+      def self.linux?
+        RUBY_PLATFORM.include?("linux")
+      end
+
+      def self.quote(string)
+        "\"#{string}\""
+      end
+
+      def self.windows_path(path)
+        path.gsub("/", "\\")
+      end
+
+      def self.linux_path(path)
+        path.gsub("\\", "/")
+      end
+
+      def self.format_path(path)
+        quote(linux? ? linux_path(path) : windows_path(path))
+      end
+    end
+  end
+end