albacore 1.0.0 → 2.0.0.rc.1

data/lib/albacore/dsl.rb

@@ -0,0 +1,90 @@
+require 'albacore/cross_platform_cmd'
+
+module Albacore
+  module DSL
+    # this means that you can use all things available in the cross platform
+    # cmd from within albacore
+    include Albacore::CrossPlatformCmd
+    
+    private
+
+    # a rake task type for outputting assembly versions
+    def asmver *args, &block
+      require 'albacore/task_types/asmver'
+      Albacore.define_task *args do
+        c = Albacore::Asmver::Config.new
+        yield c
+        Albacore::Asmver::Task.new(c.opts).execute
+      end
+    end
+
+    # a task for building sln or proj files - or just invoking something
+    # with MsBuild
+    def build *args, &block
+      require 'albacore/task_types/build'
+      Albacore.define_task *args do
+        c = Albacore::Build::Config.new
+        yield c
+
+        fail "unable to find MsBuild or XBuild" unless c.exe
+        command = Albacore::Build::Cmd.new(c.work_dir, c.exe, c.parameters)
+        Albacore::Build::Task.new(command).execute
+      end
+    end
+
+    # restore the nugets to the solution
+    def nugets_restore *args, &block
+      require 'albacore/task_types/nugets_restore'
+      Albacore.define_task *args do
+        c = Albacore::NugetsRestore::Config.new
+        yield c
+
+        c.ensure_authentication! 
+
+        c.packages.each do |p|
+          command = Albacore::NugetsRestore::Cmd.new(c.work_dir, c.exe, c.opts_for_pkgcfg(p))
+          Albacore::NugetsRestore::Task.new(command).execute
+        end
+      end
+    end
+    
+    # pack nugets
+    def nugets_pack *args, &block
+      require 'albacore/task_types/nugets_pack'
+      Albacore.define_task *args do
+        c = Albacore::NugetsPack::Config.new
+        yield c
+        Albacore::NugetsPack::ProjectTask.new(c.opts).execute
+      end
+    end
+
+    # basically a command with some parameters; allows you to execute your
+    # tests with albacore
+    def test_runner *args, &block
+      require 'albacore/task_types/test_runner'
+      Albacore.define_task *args do
+        c = Albacore::TestRunner::Config.new
+        yield c
+
+        c.files.each { |dll|
+          command = Albacore::TestRunner::Cmd.new c.work_dir, c.exe, c.parameters, dll
+          Albacore::TestRunner::Task.new(command).execute
+        }
+      end
+    end
+
+    # Restore hint paths to registered nugets
+    def restore_hint_paths *args, &block
+      require 'albacore/tools/restore_hint_paths'
+      Albacore.define_task *args do
+        c = Albacore::RestoreHintPaths::Config.new
+        yield c
+
+        t = Albacore::RestoreHintPaths::Task.new c
+        t.execute
+      end
+    end
+  end
+end
+
+self.extend Albacore::DSL

data/lib/albacore/errors/command_failed_error.rb

@@ -0,0 +1,11 @@
+module Albacore
+  class CommandFailedError < StandardError
+
+    attr_reader :executable
+
+    def initialize message, executable
+      super(message)
+      @executable = executable
+    end
+  end
+end

data/lib/albacore/errors/command_not_found_error.rb

@@ -0,0 +1,13 @@
+# -*- encoding: utf-8 -*-
+
+module Albacore
+  class CommandNotFoundError < StandardError
+
+    attr_reader :executable
+
+    def initialize message, executable
+      super(message)
+      @executable = executable
+    end
+  end
+end

data/lib/albacore/errors/unfilled_property_error.rb

@@ -0,0 +1,14 @@
+# -*- encoding: utf-8 -*-
+
+module Albacore
+  class UnfilledPropertyError < StandardError
+    attr_accessor :property
+    def initialize property, message
+      super(message)
+      @property = property
+    end
+    def message
+      %Q{The property "#{property}"; #{message}}
+    end
+  end
+end

data/lib/albacore/ext/README.md

@@ -0,0 +1,12 @@
+# Folder: ext
+
+The `ext` folder contains Albacore extensions. Write code in this folder
+according to the following conventions:
+
+ * doing `require 'albacore/ext/extension_name'` should add the extensions
+   of `extension_name` to the current albacore application. This means
+   that there should be no further requirement to call into albacore
+   after such a `require` call has been done.
+ * prefer to do extensions via `Albacore.subscribe` over extending
+   at the call-site, monkey-patching, or including the extended in
+   other class/module/object instances.

data/lib/albacore/ext/teamcity.rb

@@ -0,0 +1,64 @@
+require 'albacore'
+
+module Albacore
+  module Ext
+    # The teamcity module writes appropriate build-script "interaction messages"
+    # (see http://confluence.jetbrains.com/display/TCD7/Build+Script+Interaction+with+TeamCity#BuildScriptInteractionwithTeamCity-artPublishing)
+    # to STDOUT.
+    module TeamCity
+      # Escaped the progress message
+      # (see http://confluence.jetbrains.com/display/TCD7/Build+Script+Interaction+with+TeamCity#BuildScriptInteractionwithTeamCity-ServiceMessages)
+      # The Unicode symbol escape is not implemented
+      # Character                                  Should be escaped as
+      # ' (apostrophe)                             |'
+      # \n (line feed)                             |n
+      # \r (carriage return)                       |r
+      # \uNNNN (unicode symbol with code 0xNNNN)   |0xNNNN
+      # | (vertical bar)                           ||
+      # [ (opening bracket)                        |[
+      # ] (closing bracket)                        |]
+      def self.escape message
+        message.gsub(/([\[|\]|\|'])/, '|\1').gsub(/\n/, '|n').gsub(/\r/, '|r')
+      end
+      def self.configure
+        Albacore.subscribe :artifact do |artifact|
+          ::Albacore.puts "##teamcity[publishArtifacts '#{artifact.location}']"
+        end
+        Albacore.subscribe :build_version do |version|
+          # tell teamcity our decision
+          ::Albacore.puts "##teamcity[buildNumber '#{version.build_version}']"
+        end
+        Albacore.subscribe :progress do |p|
+          # tell teamcity of our progress
+          ::Albacore.puts "##teamcity[progressMessage '#{escape p.message}']"
+        end
+        Albacore.subscribe :start_progress do |p|
+          # tell teamcity of our progress
+          start_progress p.message
+        end
+        Albacore.subscribe :finish_progress do |p|
+          # tell teamcity of our progress
+          finish_progress p.message
+        end
+      end
+      private
+      PROGRESS_QUEUE = []
+      # Starts a new progress block
+      def self.start_progress(name)
+        PROGRESS_QUEUE.push name
+        ::Albacore.puts "##teamcity[progressStart '#{escape name}']"
+      end
+      # Finishes the progress block and all child progress blocks
+      def self.finish_progress(name = '')
+        loop do
+          p = PROGRESS_QUEUE.pop
+          ::Albacore.puts "##teamcity[progressFinish '#{escape p}']" unless p.nil?
+          break unless !p.nil? || name == p || name == ''
+        end
+      end
+    end
+  end
+end
+
+# subscribe the handlers directly when loading this file
+Albacore::Ext::TeamCity.configure

data/lib/albacore/facts.rb

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+module Albacore
+  module Facts
+    
+    def self.processor_count
+      case RbConfig::CONFIG['host_os']
+      when /darwin9/
+        `hwprefs cpu_count`.to_i
+      when /darwin/
+        ((`which hwprefs` != '') ? `hwprefs thread_count` : `sysctl -n hw.ncpu`).to_i
+      when /linux/
+        `cat /proc/cpuinfo | grep processor | wc -l`.to_i
+      when /freebsd/
+        `sysctl -n hw.ncpu`.to_i
+      when /mswin|mingw/
+        require 'win32ole'
+        # http://msdn.microsoft.com/en-us/library/windows/desktop/aa394373%28v=vs.85%29.aspx
+        wmi = WIN32OLE.connect("winmgmts://")
+        cpu = wmi.ExecQuery("select NumberOfLogicalProcessors from Win32_Processor")
+        cpu.to_enum.first.NumberOfLogicalProcessors
+      end
+    end
+  end
+end

data/lib/albacore/logging.rb

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+require 'logger'
+require 'albacore/application'
+
+module Albacore
+  module Logging
+    def trace *str, &block
+      ::Albacore.application.logger.debug *str, &block
+    end
+    def debug *str, &block
+      ::Albacore.application.logger.debug *str, &block
+    end
+    def info *str, &block
+      ::Albacore.application.logger.info *str, &block
+    end
+    def warn *str, &block
+      ::Albacore.application.logger.warn *str, &block
+    end
+    def error *str, &block
+      ::Albacore.application.logger.error *str, &block
+    end
+    def fatal *str, &block
+      ::Albacore.application.logger.fatal *str, &block
+    end
+    def puts *str
+      ::Albacore.application.puts *str
+    end
+    def err str
+      ::Albacore.application.err str
+    end
+  end
+end

data/lib/albacore/nuget_model.rb

@@ -0,0 +1,387 @@
+require 'map'
+require 'albacore/logging'
+require 'albacore/project'
+require 'albacore/paths'
+
+module Albacore
+  module NugetModel
+    class IdVersion
+      attr_reader :id, :version
+      def initialize id, version
+        @id, @version = id, version
+      end
+      def to_s
+        "#{id}@#{version}"
+      end
+    end
+
+    class FileItem
+      attr_reader :src, :target, :exclude
+      def initialize src, target, excl
+        src, target = Albacore::Paths.normalise_slashes(src),
+          Albacore::Paths.normalise_slashes(target)
+        @src, @target, @exclude = src, target, excl
+      end
+      def to_s
+        "NugetModel::FileItem(src: #{@src}, target: #{@target}, exclude: #{@exclude}"
+      end
+    end
+
+    # the nuget xml metadata element writer
+    class Metadata
+      include Logging
+
+      def self.nuspec_field *syms
+        syms.each do |sym|
+          self.class_eval(
+%{def #{sym}
+  @#{sym}
+end})
+          self.class_eval(
+%{def #{sym}= val
+  @#{sym} = val
+  @set_fields.add? :#{sym}
+end})                      
+        end 
+      end
+
+      # gets or sets the id of this package
+      nuspec_field :id
+      
+      # gets or sets the version of this package
+      nuspec_field :version
+
+      # gets or sets the authors of this package
+      nuspec_field :authors
+
+      # gets or sets the description of this package
+      nuspec_field :description
+
+      # gets or sets the language that this package has been built with
+      nuspec_field :language
+
+      # gets or sets the project url for this package
+      nuspec_field :project_url
+
+      # gets or sets the license url for this package
+      nuspec_field :license_url
+
+      # gets or sets the release notes for this build.
+      nuspec_field :release_notes
+
+      # gets or sets the owners of this package
+      nuspec_field :owners
+
+      # gets or sets whether this package requires a license acceptance from the user
+      # hint: don't.
+      nuspec_field :require_license_acceptance
+
+      # gets or sets the copyright for this package
+      nuspec_field :copyright
+
+      # get or sets the tags for this package
+      nuspec_field :tags
+
+      # get the dependent nuget packages for this package
+      nuspec_field :dependencies
+
+      # gets the framework assemblies for this package
+      nuspec_field :framework_assemblies
+
+      # gets the field symbols that have been set
+      attr_reader :set_fields
+
+      # initialise a new package data object
+      def initialize dependencies = nil, framework_assemblies = nil
+        @set_fields   = Set.new
+        @dependencies = dependencies || Hash.new
+        @framework_assemblies = framework_assemblies || Hash.new
+
+        debug "creating new metadata with dependencies: #{dependencies} [nuget model: metadata]" unless dependencies.nil?
+        debug "creating new metadata (same as prev) with fw asms: #{framework_assemblies} [nuget model: metadata]" unless framework_assemblies.nil?
+      end
+
+      # add a dependency to the package; id and version
+      def add_dependency id, version
+        @dependencies[id] = IdVersion.new id, version
+      end
+
+      # add a framework dependency for the package
+      def add_framework_dependency id, version
+        @framework_assemblies[id] = IdVersion.new id, version
+      end
+
+      def to_xml_builder
+        # alt: new(encoding: 'utf-8')
+        Nokogiri::XML::Builder.new do |x|
+          x.metadata {
+            @set_fields.each do |f|
+              x.send(Metadata.pascal_case(f), send(f))
+            end
+            x.dependencies {
+              @dependencies.each { |k, d|
+                x.dependency id: d.id, version: d.version
+              }
+            }
+          }
+        end
+      end
+
+      # transform the data structure to the corresponding xml
+      def to_xml
+        to_xml_builder.to_xml
+      end
+
+      def merge_with other
+        raise ArgumentError, 'other is nil' if other.nil?
+        raise ArgumentError, 'other is wrong type' unless other.is_a? Metadata
+
+        trace { "#{self} merging with #{other} [nuget model: metadata]" }
+
+        deps = @dependencies.clone.merge(other.dependencies)
+        fw_asms = @framework_assemblies.clone.merge(other.framework_assemblies)
+
+        m_next = Metadata.new deps, fw_asms
+
+        # set all my fields to the new instance
+        @set_fields.each do |field|
+          debug "setting field '#{field}' to be '#{send(field)}' [nuget model: metadata]" 
+          m_next.send(:"#{field}=", send(field))
+        end
+
+        # set all other's fields to the new instance, overriding mine
+        other.set_fields.each do |field|
+          debug "setting field '#{field}' to be '#{send(field)}' [nuget model: metadata]" 
+          m_next.send(:"#{field}=", other.send(field))
+        end
+
+        m_next
+      end
+
+      def to_s
+        "NugetModel::Metadata(#{ @set_fields.map { |f| "#{f}=#{send(f)}" }.join(', ') })"
+      end
+
+      self.extend Logging
+
+      def self.from_xml node
+        m = Metadata.new
+        node.children.reject { |n| n.text? }.each do |n|
+          if n.name == 'dependencies'
+            n.children.reject { |n| n.text? }.each do |dep|
+              m.add_dependency dep['id'], dep['version']
+            end
+          elsif n.name == 'frameworkDepdendencies'
+            n.children.reject { |n| n.text? }.each do |dep|
+              m.add_framework_depdendency dep['id'], dep['version']
+            end 
+          else
+            # just set the property
+            m.send(:"#{underscore n.name}=", n.inner_text)
+          end
+        end
+        m
+      end
+
+      def self.pascal_case str
+        str = str.to_s unless str.respond_to? :split
+        str = str.split('_').inject([]){ |buffer,e| buffer.push(buffer.empty? ? e : e.capitalize) }.join
+        :"#{str}"
+      end
+      
+      def self.underscore str
+        str.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+      end
+    end
+
+    # the nuget package element writer
+    class Package
+      include Logging
+
+      # the metadata corresponds to the metadata element of the nuspec
+      attr_accessor :metadata
+
+      # the files is something enumerable that corresponds to the file
+      # elements inside '//package/files'.
+      attr_accessor :files
+
+      # creates a new nuspec package instance
+      def initialize metadata = nil, files = nil
+        @metadata = metadata || Metadata.new
+        @files = files || []
+      end
+
+      # add a file to the instance
+      def add_file src, target, exclude = nil
+        @files << FileItem.new(src, target, exclude)
+        self
+      end
+
+      # remove the file denoted by src
+      def remove_file src
+        src = src.src if src.respond_to? :src # if passed an OpenStruct e.g.
+        trace { "remove_file: removing file '#{src}' [nuget model: package]" }
+        @files = @files.reject { |f| f.src == src }
+      end
+
+      # do something with the metadata.
+      # returns the #self Package instance
+      def with_metadata &block
+        yield @metadata if block_given?
+        self
+      end
+
+      # gets the current package as a xml builder
+      def to_xml_builder
+        md = Nokogiri::XML(@metadata.to_xml).at_css('metadata').to_xml
+        Nokogiri::XML::Builder.new(encoding: 'utf-8') do |x|
+          x.package(xmlns: 'http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd') {
+            x << md
+            #x.__send__ :insert, md.at_css("metadata")
+#           x << md.at_css("metadata").to_xml(indent: 4)
+            x.files {
+              @files.each do |f|
+                if f.exclude
+                  x.file src: f.src, target: f.target, exclude: f.exclude
+                else
+                  x.file src: f.src, target: f.target
+                end
+              end
+            }
+          }
+        end
+      end
+
+      # gets the current package as a xml node
+      def to_xml
+        to_xml_builder.to_xml
+      end
+
+      # creates a new Package/Metadata by overriding data in this instance with
+      # data from passed instance
+      def merge_with other
+        m_next = @metadata.merge_with other.metadata
+        files_other = {}
+        other.files.each { |f| files_other[f.src] = f }
+        f_next = @files.collect { |f| files_other.fetch f.src, f }
+        Package.new m_next, f_next
+      end
+
+      def to_s
+        "NugetModel::Package(files: #{@files.map(&:to_s)}, metadata: #{ @metadata.to_s })"
+      end
+
+      # gimme some logging lööve
+      self.extend Logging
+
+      # read the nuget specification from a nuspec file
+      def self.from_xml xml
+        ns = { ng: 'http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd' }
+        parser = Nokogiri::XML(xml)
+        meta = Metadata.from_xml(parser.xpath('.//ng:metadata', ns))
+        files = parser.
+          xpath('.//ng:files', ns).
+          children.
+          reject { |n| n.text? or n['src'].nil? }.
+          collect { |n| FileItem.new n['src'], n['target'], n['exclude'] }
+        Package.new meta, files
+      end
+
+      # read the nuget specification from a xxproj file (e.g. csproj, fsproj)
+      def self.from_xxproj_file file, *opts
+        proj = Albacore::Project.new file
+        from_xxproj proj, *opts
+      end
+
+      # Read the nuget specification from a xxproj instance (e.g. csproj, fsproj)
+      # Options:
+      #  - symbols
+      #  - dotnet_version
+      #  - known_projects
+      #  - configuration
+      #  - project_dependencies
+      #  - nuget_dependencies
+      def self.from_xxproj proj, *opts
+        opts = Map.options(opts || {}).
+          apply({
+            symbols:              false,
+            dotnet_version:       'net40',
+            known_projects:       Set.new,
+            configuration:        'Debug',
+            project_dependencies: true,
+            verify_files:         false,
+            nuget_dependencies:   true })
+
+        trace { "#from_xxproj opts: #{opts} [nuget model: package]" }
+
+        version = opts.get :version
+        package = Package.new
+        package.metadata.id = proj.name if proj.name
+        package.metadata.version = version if version
+        package.metadata.authors = proj.authors if proj.authors
+
+        if opts.get :nuget_dependencies
+          # add declared packages as dependencies
+          proj.declared_packages.each do |p|
+            package.metadata.add_dependency p.id, p.version
+          end
+        end
+
+        if opts.get :project_dependencies
+          # add declared projects as dependencies
+          proj.
+            declared_projects.
+            keep_if { |p| opts.get(:known_projects).include? p.name }.
+            each do |p|
+            debug "adding project dependency: #{proj.name} => #{p.name} at #{version} [nuget model: package]"
+            package.metadata.add_dependency p.name, version
+          end
+        end
+
+        output = proj.output_path(opts.get(:configuration))
+        target_lib = %W[lib #{opts.get(:dotnet_version)}].join(Albacore::Paths.separator)
+
+        if opts.get :symbols 
+          compile_files = proj.included_files.keep_if { |f| f.item_name == "compile" }
+
+          debug "add compiled files: #{compile_files} [nuget model: package]"
+          compile_files.each do |f|
+            target = %W[src #{Albacore::Paths.normalise_slashes(f.include)}].join(Albacore::Paths.separator)
+            package.add_file f.include, target
+          end 
+
+          debug "add dll and pdb files [nuget model: package]"
+          package.add_file(Albacore::Paths.normalise_slashes(output + proj.asmname + '.pdb'), target_lib)
+          package.add_file(Albacore::Paths.normalise_slashes(output + proj.asmname + '.dll'), target_lib)
+        else
+          # add *.{dll,xml,config}
+          %w[dll xml config].each do |ext|
+            file = %W{#{output} #{proj.asmname}.#{ext}}.
+              map { |f| f.gsub /\\$/, '' }.
+              map { |f| Albacore::Paths.normalise_slashes f }.
+              join(Albacore::Paths.separator)
+            debug "adding binary file #{file} [nuget model: package]"
+            package.add_file file, target_lib
+          end
+        end
+
+        if opts.get :verify_files
+          package.files.each do |file|
+            file_path = File.expand_path file.src, proj.proj_path_base
+            unless File.exists? file_path
+              package.remove_file file.src
+              info "while building nuspec for proj: #{proj.name}, file: #{file.src} => #{file.target} not found, removing from nuspec [nuget model: package]"
+              trace { "files: #{package.files.map { |f| f.src }.inspect} [nuget model: package]" }
+            end
+          end
+        end
+
+        package
+      end
+    end
+  end
+end