albacore 0.3.6 → 0.6.2.rc1

data/lib/albacore/asmver/cpp.rb

@@ -0,0 +1,20 @@
+require 'albacore/asmver/engine'
+
+module Albacore::Asmver
+  class CppCliEngine < Engine
+    def initialize
+      @start_token = "["
+      @end_token   = "]"
+      @assignment  = "="
+      @statement_terminator  = ";"
+    end
+
+    def build_attribute_re(attr_name)
+      /^\[assembly: #{attr_name}(.+)/  
+    end
+    
+    def build_using_statement(namespace)
+      "using namespace #{namespace.gsub(/\./, '::')};"
+    end
+  end
+end

data/lib/albacore/asmver/cs.rb

@@ -0,0 +1,17 @@
+require 'albacore/asmver/engine'
+
+module Albacore::Asmver
+  class Cs < Engine
+    def initialize
+      @using       = "using"
+      @start_token = "["
+      @end_token   = "]"
+      @assignment  = "="
+      @statement_terminator  = ";"
+    end
+    
+    def build_attribute_re(attr_name)
+      /^\[assembly: #{attr_name}(.+)/  
+    end
+  end
+end

data/lib/albacore/asmver/engine.rb

@@ -0,0 +1,43 @@
+module Albacore::Asmver
+  class Engine
+    def build_attribute(attr_name, attr_data)
+      attribute = "#{@start_token}assembly: #{attr_name}("
+      
+      if attr_data != nil
+        if attr_data.is_a? Hash
+          # Only named parameters
+          attribute << build_named_parameters(attr_data)
+        elsif attr_data.is_a? Array
+          if attr_data.last.is_a? Hash
+            # Positional and named parameters
+            attribute << build_positional_parameters(attr_data.slice(0, attr_data.length - 1))
+            attribute << ", "
+            attribute << build_named_parameters(attr_data.last)
+          else
+            # Only positional parameters
+            attribute << build_positional_parameters(attr_data)
+          end
+        else
+          # Single positional parameter
+          attribute << "#{attr_data.inspect}"
+        end
+      end
+      
+      attribute << ")#{@end_token}"
+    end
+    
+    def build_named_parameters(data)
+      params = []
+      data.each_pair { |k, v| params << "#{k.to_s} #{@assignment} #{v.inspect}" }
+      params.join(", ")
+    end
+    
+    def build_positional_parameters(data)
+      data.flatten.map{ |a| a.inspect }.join(", ")
+    end
+
+    def build_using_statement(namespace)
+      "#{@using} #{namespace}#{@statement_terminator}"
+    end
+  end
+end

data/lib/albacore/asmver/fs.rb

@@ -0,0 +1,25 @@
+require 'albacore/asmver/engine'
+
+module Albacore::Asmver
+  class Fs < Engine
+    def initialize
+      @using       = "open"
+      @start_token = "[<"
+      @end_token   = ">]"
+      @assignment  = "="
+      @statement_terminator  = ""
+    end
+    
+    def build_attribute_re(attr_name)
+      /^\[\<assembly: #{attr_name}(.+)/
+    end
+    
+    def before
+      "module AssemblyInfo" # this could be anything
+    end
+    
+    def after
+      "()" # need to yield unit
+    end
+  end
+end

data/lib/albacore/asmver/vb.rb

@@ -0,0 +1,17 @@
+require 'albacore/asmver/engine'
+
+module Albacore::Asmver
+  class Vb < Engine
+    def initialize
+      @using       = "Imports"
+      @start_token = "<"
+      @end_token   = ">"
+      @assignment  = ":="
+      @statement_terminator  = ""
+    end
+    
+    def build_attribute_re(attr_name)
+      /^\<assembly: #{attr_name}(.+)/  
+    end
+  end
+end

data/lib/albacore/build.rb

@@ -0,0 +1,203 @@
+# -*- encoding: utf-8 -*-
+
+require 'rake'
+require 'albacore/paths'
+require 'albacore/cmd_config'
+require 'albacore/cross_platform_cmd'
+require 'albacore/logging'
+require 'albacore/facts'
+
+module Albacore
+  module Build
+    class Cmd
+      include CrossPlatformCmd
+      def initialize work_dir, executable, parameters
+        @work_dir = work_dir
+        @executable = executable
+        @parameters = parameters
+      end
+      def execute
+        sh make_command, :work_dir => @work_dir
+      end
+    end
+
+    # The configuration class for xbuild and msbuild. MSDN docs at: http://msdn.microsoft.com/en-us/library/vstudio/ms164311.aspx
+    class Config
+      include CmdConfig
+      include Logging
+
+      attr_accessor :sln, :file, :target, :properties
+
+      def initialize
+        @parameters = Set.new
+
+        w = lambda { |e| CrossPlatformCmd.which(e) ? e : nil }
+
+        @exe = w.call( "msbuild" ) ||
+               w.call( "xbuild" )  ||
+               heuristic_executable
+
+        debug "build using '#{@exe}'"
+        logging "minimal"
+      end
+
+      # the sln file to build
+      def sln= val
+        @parameters.add val
+        @sln = val
+      end
+
+      def sln
+        @sln
+      end
+
+      def file= val
+        @parameters.add val
+        @file = val
+      end
+
+      def file
+        @file
+      end
+
+      # see target method for docs
+      def target= t
+        target t
+      end
+
+      # Call for each target that you want to add, or pass an array or
+      # strings. Only unique targets will be passed to MsBuild.
+      #
+      # From MSDN:
+      #
+      # "Build the specified targets in the project. Specify each target separately, or use a semicolon or comma to separate multiple targets, as the following example shows:
+      # /target:Resources;Compile
+      # If you specify any targets by using this switch, they are run instead of any targets in the DefaultTargets attribute in the project file. For more information, see Target Build Order (http://msdn.microsoft.com/en-us/library/vstudio/ee216359.aspx) and How to: Specify Which Target to Build First (http://msdn.microsoft.com/en-us/library/vstudio/ms171463.aspx).
+      # A target is a group of tasks. For more information, see MSBuild Targets (http://msdn.microsoft.com/en-us/library/vstudio/ms171462.aspx)."
+      #
+      # t  :: the array or string target to add to the list of tarets to build
+      def target t
+        update_array_prop "target", method(:make_target), :targets, t
+      end
+
+      # Allows you to add properties to MsBuild; example:
+      #
+      # b.prop 'WarningLevel', 2
+      # b.prop 'BuildVersion', '3.5.0'
+      #
+      # From MSDN:
+      #
+      # "Set or override the specified project-level properties, where name is the property name and value is the property value. Specify each property separately, or use a semicolon or comma to separate multiple properties, as the following example shows:
+      # /property:WarningLevel=2;OutputDir=bin\Debug"
+      #
+      # The properties will be automatically converted to the correct syntax
+      def prop k, v
+        @properties ||= Hash.new
+        @parameters.delete "/property:#{make_props}" if @properties.any?
+        @properties[k] = v
+        @parameters.add "/property:#{make_props}"
+      end
+
+      # Specifies the amount of information to display in the build log. 
+      # Each logger displays events based on the verbosity level that you set for that logger.
+      # You can specify the following verbosity levels: q[uiet], m[inimal], 
+      # n[ormal], d[etailed], and diag[nostic]. 
+      def logging mode
+        modes = %w{quiet minimal normal detailed diagnostic}.collect{ |m| "/verbosity:#{m}" }
+        @parameters.subtract modes
+        @parameters.add "/verbosity:#{mode}"
+      end
+
+      def logging= mode
+        logging mode
+      end
+
+      # Specifies the number of parallel worker processes to build with
+      # Defaults to the number of logical cores
+      def cores num
+        @parameters.add "/maxcpucount:#{num}"
+      end
+
+      # Pass the parameters that you specify to the console logger, which displays build information in the console window. You can specify the following parameters:
+      # * PerformanceSummary. Show the time that’s spent in tasks, targets, and projects.
+      # * Summary. Show the error and warning summary at the end.
+      # * NoSummary. Don't show the error and warning summary at the end.
+      # * ErrorsOnly. Show only errors.
+      # * WarningsOnly. Show only warnings.
+      # * NoItemAndPropertyList. Don't show the list of items and properties that would appear at the start of each project build if the verbosity level is set to diagnostic.
+      # * ShowCommandLine. Show TaskCommandLineEvent messages.
+      # * ShowTimestamp. Show the timestamp as a prefix to any message.
+      # * ShowEventId. Show the event ID for each started event, finished event, and message.
+      # * ForceNoAlign. Don't align the text to the size of the console buffer.
+      # * DisableConsoleColor. Use the default console colors for all logging messages.
+      # * DisableMPLogging. Disable the multiprocessor logging style of output when running in non-multiprocessor mode.
+      # * EnableMPLogging. Enable the multiprocessor logging style even when running in non-multiprocessor mode. This logging style is on by default.
+      # * Verbosity. Override the /verbosity setting for this logger.
+      def clp param
+        update_array_prop "consoleloggerparameters", method(:make_clp), :clp, param
+      end
+
+      # Set logging verbosity to quiet
+      def be_quiet
+        logging "quiet"
+      end
+
+      # Don't display the startup banner or the copyright message.
+      def nologo
+        @parameters.add "/nologo"
+      end
+
+      private
+      def update_array_prop prop_name, callable_prop_val, field_sym, value
+        field = :"@#{field_sym}"
+        # @targets ||= []
+        instance_variable_set field, [] unless instance_variable_defined? field
+        # parameters.delete "/target:#{make_target}" if @targets.any?
+        @parameters.delete "/#{prop_name}:#{callable_prop_val.call}" if 
+          instance_variable_get(field).any?
+        if value.respond_to? 'each'
+          value.each { |v| instance_variable_get(field) << v }
+        else
+          instance_variable_get(field) << value
+        end
+        instance_variable_get(field).uniq!
+        # @parameters.add "/target:#{make_target}"
+        @parameters.add "/#{prop_name}:#{callable_prop_val.call}"
+      end
+
+      def make_target
+        @targets.join(';')
+      end
+
+      def make_props
+        @properties.collect { |k, v|
+          "#{k}=#{v}"
+        }.join(';')
+      end
+
+      def make_clp
+        @clp.join(';')
+      end
+
+      def heuristic_executable
+        if ::Rake::Win32.windows?
+          trace 'build tasktype finding msbuild.exe'
+          %w{v4.0.30319 v4.0 v3.5 v2.0}.collect { |fw_ver|
+            msb = File.join ENV['WINDIR'], 'Microsoft.NET', 'Framework', fw_ver, 'msbuild.exe'
+            CrossPlatformCmd.which(msb) ? msb : nil
+          }.first
+        else
+          nil
+        end
+      end
+    end
+    class Task
+      def initialize command_line
+        @command_line = command_line
+      end
+      def execute
+        @command_line.execute
+      end
+    end
+  end
+end

data/lib/albacore/cmd_config.rb

@@ -0,0 +1,55 @@
+# -*- encoding: utf-8 -*-
+
+require 'set'
+
+module Albacore
+
+  # Use on **configuration** objects that are command-oriented.
+  #
+  # a mixin that adds a couple of field writers and readers.
+  # specifically, allows the configuration to have a work_dir and exe field
+  # and defined a method that joins paths relative to the work_dir
+  module CmdConfig
+    include Logging
+    
+    # the working directory for this command
+    attr_accessor :work_dir
+    
+    # field field denoting the path of the executable that should be on the path
+    # specified in the work_dir parameter.
+    attr_accessor :exe
+    
+    # returns a Set with parameters
+    def parameters
+      @parameters ||= Set.new
+    end
+    
+    # add a parameter to the list of parameters to pass to the executable
+    def add_parameter param
+      parameters.add param
+    end
+    
+    # helper method that joins the path segments with
+    # respect to the work_dir.
+    private
+    def join *segments
+      segments ||= []
+      segments.unshift work_dir
+      File.join segments
+    end
+    
+    # helper method that changes directory to the work directory
+    # and then yields to the block
+    def in_work_dir
+      unless @work_dir.nil?
+        Dir.chdir @work_dir do
+          trace "in work dir '#{@work_dir}'"
+          yield
+        end
+      else
+        trace "not in work dir, because it is nil."
+        yield
+      end     
+    end
+  end
+end

data/lib/albacore/cross_platform_cmd.rb

@@ -0,0 +1,177 @@
+require 'rake'
+require 'map'
+require 'processpilot/processpilot'
+require 'albacore/paths'
+require 'albacore/logging'
+
+module Albacore
+  # module for normalizing slashes across operating systems
+  # and running commands
+  module CrossPlatformCmd
+    include Logging
+
+    # Exit status class for times the system just gives us a nil.
+    class PseudoStatus
+      attr_reader :exitstatus
+      def initialize(code=0)
+        @exitstatus = code
+      end
+      def to_i
+        @exitstatus << 8
+      end
+      def >>(n)
+        to_i >> n
+      end
+      def stopped?
+        false
+      end
+      def exited?
+        true
+      end
+    end
+
+    class << self
+      include CrossPlatformCmd
+    end
+
+    def normalize_slashes path
+      ::Albacore::Paths.normalize_slashes path
+    end
+
+    # create
+    def make_command
+      ::Albacore::Paths.make_command @executable, @parameters
+    end
+
+    # run process
+    # system(cmd, [args array], [opts])
+    # 
+    # options are passed as the last argument
+    #
+    # options:
+    #  :work_dir => a file path
+    #
+    def system *cmd, &block
+      raise ArgumentError, "cmd is nil" if cmd.nil? # don't allow nothing to be passed
+      block = lambda { |ok, status| ok or fail(format_failure(cmd, status)) } unless block_given?
+      opts = Map.options((Hash === cmd.last) ? cmd.pop : {}) # same arg parsing as rake
+      pars = cmd[1..-1].flatten
+
+      raise ArgumentError, "arguments 1..-1 must be an array" unless pars.is_a? Array
+
+      exe, pars = ::Albacore::Paths.normalise cmd[0], pars 
+      trace "system( exe=#{exe}, pars=#{pars.join(', ')}, options=#{opts.to_s})"
+
+      chdir opts.get(:work_dir) do
+        puts %Q{#{exe} #{pars.join(' ')}} unless opts.get :silent, false # log cmd verbatim
+        begin
+          res = IO.popen([exe, *pars]) { |io| io.readlines }
+        rescue Errno::ENOENT => e
+          return block.call(nil, 127)
+        end
+        puts res unless opts.get(:silent, false) or not opts.get(:output, true)
+        return block.call($? == 0 && res, $?)
+      end
+    end
+    
+    def system_control cmd, *opts, &block
+      cmd = opts[0]
+      opts = Map.options((Hash === cmd.last) ? cmd.pop : {}) # same arg parsing as rake
+      chdir opts[:work_dir] do
+        puts cmd
+        ProcessPilot::pilot cmd, opts, &block
+      end
+    end
+
+    # run in shell
+    def sh *cmd, &block
+      raise ArgumentError, "cmd is nil" if cmd.nil? # don't allow nothing to be passed
+      block = lambda { |ok, status| ok or fail(format_failure(cmd, status)) } unless block_given?
+
+      opts = Map.options((Hash === cmd.last) ? cmd.pop : {}) # same arg parsing as rake
+      cmd = cmd.join(' ') # shell needs a single string
+
+      chdir opts.get(:work_dir) do
+        trace "# sh( ...,  options: #{opts.to_s})"
+        puts cmd unless opts.get :silent, false # log cmd verbatim
+        begin
+          res = IO.popen(cmd, 'r') { |io| io.readlines }
+        rescue Errno::ENOENT => e
+          trace { "got error #{e}" }
+          return block.call(nil, PseudoStatus.new(127))
+        # rescue for JRuby:
+        rescue IOError => e
+          trace { "got error #{e}" }
+          return block.call(nil, PseudoStatus.new(127)) 
+        end
+        puts res unless opts.get :silent, false
+        return block.call($? == 0 && res, $?)
+      end
+    end
+    
+    # shell ignore exit code
+    # returns:
+    #  [ok, status]
+    #  where status:
+    #    #exitstatus : Int
+    #    #pid      : Int
+    def shie *cmd, &block
+      block = lambda { |ok, status| [ok, status] } unless block_given?
+      sh *cmd, &block
+    end
+    
+    def which executable
+      raise ArgumentError, "executable is nil" unless executable
+
+      dir = File.dirname executable
+      file = File.basename executable
+
+      cmd = ::Rake::Win32.windows? ? 'where' : 'which'
+      parameters = []
+      parameters << Paths.normalize_slashes(file) if dir == '.'
+      parameters << Paths.normalize_slashes("#{dir}:#{file}") unless dir == '.'
+
+      trace "#{cmd} #{parameters.join(' ')}"
+
+      # TODO: this still prints to STDERR on Windows
+      res = IO.popen([cmd, *parameters]) do |io|
+        io.read.chomp
+      end
+      
+      unless $? == 0
+        nil
+      else
+        res
+      end
+    rescue Errno::ENOENT => e
+      trace "which/where returned #{$?}: #{e}"
+      nil
+    end
+    
+    def chdir wd, &block
+      return block.call if wd.nil?
+      Dir.chdir wd do
+        trace "pushd #{wd}"
+        res = block.call
+        trace "popd #{wd}"
+        return res
+      end
+    end
+    
+    # private(format_failure)
+    def format_failure cmd, status
+      "Command failed with status (#{status.exitstatus}): [#{cmd}]"
+    end
+
+    # shuffle the executable to be a parameter to
+    # mono, if not on windows.
+    def mono_command
+      unless ::Rake::Win32.windows?
+        trace 'detected running on mono -- unshifting exe file for mono'
+        executable = @executable
+        @executable = "mono"
+        @parameters.unshift executable
+      end
+    end
+  end
+end