rake-funnel 0.0.1.pre

data/lib/rake/funnel/tasks/msbuild.rb

@@ -0,0 +1,52 @@
+require 'rake/tasklib'
+
+Dir["#{File.dirname(__FILE__)}/msbuild_support/*.rb"].each do |path|
+  require path
+end
+
+module Rake::Funnel::Tasks
+  class MSBuild < Rake::TaskLib
+    attr_accessor :name, :project_or_solution, :args, :search_pattern
+
+    def initialize(name = :compile)
+      @name = name
+      @args = {}
+      @search_pattern = %w(**/*.sln)
+
+      yield self if block_given?
+      define
+    end
+
+    def msbuild
+      @_msbuild || MSBuildSupport::BuildTool.find
+    end
+
+    def msbuild=(value)
+      @_msbuild = value
+    end
+
+    def project_or_solution
+      Rake::Funnel::Support::Finder.new(@_project_or_solution || search_pattern, self, 'No projects or more than one project found.')
+    end
+
+    def project_or_solution=(value)
+      @_project_or_solution = value
+    end
+
+    private
+    def define
+      desc "Compile #{project_or_solution.single_or_default}"
+      task @name do
+        cmd = [
+          msbuild,
+          project_or_solution.single,
+          *Rake::Funnel::Support::Mapper.new(:MSBuild).map(args)
+        ]
+
+        sh(*cmd)
+      end
+
+      self
+    end
+  end
+end

data/lib/rake/funnel/tasks/msbuild_support/build_tool.rb

@@ -0,0 +1,28 @@
+module Rake::Funnel::Tasks::MSBuildSupport
+  class BuildTool
+    class << self
+      def find
+        if Rake::Win32.windows?
+          require 'win32/registry'
+
+          %w{12.0 4.0 3.5 2.0}.collect { |version|
+            msbuild = nil
+            key = "SOFTWARE\\Microsoft\\MSBuild\\ToolsVersions\\#{version}"
+
+            begin
+              Win32::Registry::HKEY_LOCAL_MACHINE.open(key) do |reg|
+                candidate = "#{reg['MSBuildToolsPath']}\\msbuild.exe"
+                msbuild = candidate if File.exists?(candidate)
+              end
+            rescue
+            end
+
+            msbuild
+          }.compact.first
+        else
+          'xbuild'
+        end
+      end
+    end
+  end
+end

data/lib/rake/funnel/tasks/msdeploy.rb

@@ -0,0 +1,58 @@
+require 'rake/clean'
+require 'rake/tasklib'
+
+Dir["#{File.dirname(__FILE__)}/msdeploy_support/*.rb"].each do |path|
+  require path
+end
+
+module Rake::Funnel::Tasks
+  class MSDeploy < Rake::TaskLib
+    attr_accessor :name, :msdeploy, :log_file, :args
+
+    def initialize(name = :msdeploy)
+      @name = name
+      @msdeploy = 'msdeploy'
+      @args = {}
+
+      yield self if block_given?
+      define
+    end
+
+    def log_file
+      @log_file || "#{@name}.log"
+    end
+
+    private
+    def define
+      CLEAN.include(log_file)
+
+      desc "Deploy #{deploy_source(args)}"
+      task @name do
+        mapper = Rake::Funnel::Support::Mapper.new(:MSDeploy)
+        cmd = [quote(msdeploy), mapper.map(args)]
+          .flatten
+          .join(' ')
+
+        MSDeploySupport::RegistryPatch.new do
+          shell(cmd, log_file: log_file, error_lines: /^(error|[\w\.]*exception)/i)
+        end
+      end
+
+      self
+    end
+
+    def deploy_source(args)
+      source = (args || {}).fetch(:source, {})
+      path = source.first
+      return if path.nil?
+
+      Pathname.new(path[1]).relative_path_from(Pathname.new('.').realpath) rescue path[1]
+    end
+
+    def quote(value)
+      value = value.gsub(/"/, '""') if value.kind_of?(String)
+      return %Q{"#{value}"} if value =~ /\s/
+      value
+    end
+  end
+end

data/lib/rake/funnel/tasks/msdeploy_support/registry_patch.rb

@@ -0,0 +1,84 @@
+module Rake::Funnel::Tasks::MSDeploySupport
+  class RegistryPatch
+    KEYS = [
+      'SOFTWARE\Microsoft\IIS Extensions\MSDeploy\3',
+      'SOFTWARE\Wow6432Node\Microsoft\IIS Extensions\MSDeploy\3'
+    ]
+    VERSION_VALUE = 'Version'
+    FAKE_VERSION = '99.0.0.0'
+
+    def initialize(&block)
+      begin
+        patch.apply!
+        yield block if block_given?
+      ensure
+        patch.revert!
+      end
+    end
+
+    private
+    def patch
+      @patch ||= create_patch
+    end
+
+    def root
+      Win32::Registry::HKEY_LOCAL_MACHINE
+    end
+
+    def delete_key(key)
+      return nil unless key.created?
+
+      keyname = key.keyname
+      Proc.new {
+        root.create(File.dirname(keyname)) do |r|
+          r.delete_key(File.basename(keyname), true)
+        end
+      }
+    end
+
+    def delete_value(key, value)
+      keyname = key.keyname
+      Proc.new {
+        root.create(keyname) do |r|
+          r.delete_value(value)
+        end
+      }
+    end
+
+    def create_patch
+      begin
+        require 'win32/registry'
+      rescue LoadError
+        return Rake::Funnel::Support::Patch.new(self)
+      end
+
+      Rake::Funnel::Support::Patch.new(self) do |p|
+        resets = []
+
+        p.setup do
+          resets = KEYS.map do |key|
+            root.create(key) do |r|
+              begin
+                r[VERSION_VALUE]
+
+                delete_version = Proc.new {}
+              rescue Win32::Registry::Error
+                r[VERSION_VALUE] = FAKE_VERSION
+
+                delete_version = delete_value(r, VERSION_VALUE)
+              end
+
+              delete_key(r) || delete_version
+            end
+          end
+        end
+
+        p.reset do
+          resets.compact.each do |reset|
+            reset.call
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rake/funnel/tasks/nunit.rb

@@ -0,0 +1,46 @@
+require 'rake/tasklib'
+
+module Rake::Funnel::Tasks
+  class NUnit < Rake::TaskLib
+    attr_accessor :name, :files, :args
+
+    def initialize(name = :test)
+      @name = name
+      @args = {}
+      @files = %w(build/specs/**/*.dll build/specs/**/*.exe)
+
+      yield self if block_given?
+      define
+    end
+
+    def nunit
+      @_nunit || 'nunit-console.exe'
+    end
+
+    def nunit=(value)
+      @_nunit = value
+    end
+
+    private
+    def define
+      desc "Test #{test_assemblies.all_or_default.join(', ')}"
+      task name do
+        Rake::Funnel::Integration::TeamCity::NUnitPlugin.setup(nunit)
+
+        cmd = [
+          *Rake::Funnel::Support::Mono.invocation(nunit),
+          *test_assemblies.all,
+          *Rake::Funnel::Support::Mapper.new(:NUnit).map(args)
+        ]
+
+        sh(*cmd)
+      end
+
+      self
+    end
+
+    def test_assemblies
+      Rake::Funnel::Support::Finder.new(files, self, 'No test assemblies found.')
+    end
+  end
+end

data/lib/rake/funnel/tasks/paket.rb

@@ -0,0 +1,39 @@
+require 'rake/tasklib'
+
+module Rake::Funnel::Tasks
+  class Paket < Rake::TaskLib
+    attr_accessor :name, :paket, :paket_args, :bootstrapper, :bootstrapper_args
+
+    def initialize(name = :paket)
+      @name = name
+
+      @paket = File.join('.paket', 'paket.exe')
+      @paket_args = 'restore'
+
+      @bootstrapper = File.join('.paket', 'paket.bootstrapper.exe')
+      @bootstrapper_args = nil
+
+      yield self if block_given?
+      define
+    end
+
+    private
+    def define
+      desc "#{paket_cmd.join(' ')} (optionally #{bootstrapper_cmd.join(' ')})"
+      task name do
+        sh(*bootstrapper_cmd) unless File.exist?(paket)
+        sh(*paket_cmd)
+      end
+
+      self
+    end
+
+    def bootstrapper_cmd
+      Rake::Funnel::Support::Mono.invocation(bootstrapper, bootstrapper_args)
+    end
+
+    def paket_cmd
+      Rake::Funnel::Support::Mono.invocation(paket, paket_args)
+    end
+  end
+end

data/lib/rake/funnel/tasks/quick_template.rb

@@ -0,0 +1,45 @@
+require 'rake/clean'
+require 'rake/tasklib'
+
+module Rake::Funnel::Tasks
+  class QuickTemplate < Rake::TaskLib
+    attr_accessor :name, :search_pattern, :context
+
+    def initialize(name = :template)
+      @name = name
+
+      @search_pattern = %w(**/*.template)
+      @context = binding
+
+      yield self if block_given?
+      define
+    end
+
+    private
+    def define
+      results = templates.all_or_default.map { |t| result_filename(t) }
+      CLEAN.include(*results)
+
+      desc "Generate #{templates.all_or_default.join(', ')}"
+      task name do
+        templates.all_or_default.each do |template|
+          target = result_filename(template)
+          Rake.rake_output_message "Creating file #{target}"
+
+          content = Rake::Funnel::Support::TemplateEngine.render(File.read(template), template, context)
+          File.write(target, content)
+        end
+      end
+
+      self
+    end
+
+    def templates
+      Rake::Funnel::Support::Finder.new(search_pattern, self, 'No templates found.')
+    end
+
+    def result_filename(template)
+      template.ext
+    end
+  end
+end

data/lib/rake/funnel/tasks/side_by_side_specs.rb

@@ -0,0 +1,33 @@
+require 'rake/tasklib'
+
+Dir["#{File.dirname(__FILE__)}/side_by_side_specs_support/*.rb"].each do |path|
+  require path
+end
+
+module Rake::Funnel::Tasks
+  class SideBySideSpecs < Rake::TaskLib
+    attr_accessor :name, :projects, :references, :specs, :enabled
+
+    def initialize(name = :compile)
+      @name = name
+
+      @projects = %w(**/*.csproj **/*.vbproj **/*.fsproj)
+      @references = []
+      @specs = %w(*Specs.cs **/*Specs.cs *Tests.cs **/*Tests.cs)
+      @enabled = false
+
+      yield self if block_given?
+      define
+    end
+
+    private
+    def define
+      task name do
+        next unless enabled
+        SideBySideSpecsSupport::Remover.remove({ projects: projects, references: references, specs: specs })
+      end
+
+      self
+    end
+  end
+end

data/lib/rake/funnel/tasks/side_by_side_specs_support/remover.rb

@@ -0,0 +1,62 @@
+require 'rexml/document'
+
+module Rake::Funnel::Tasks::SideBySideSpecsSupport
+  class Remover
+    class << self
+      DEFAULTS = {
+        projects: [],
+        references: [],
+        specs: []
+      }
+
+      def remove(args = {})
+        args = DEFAULTS.merge(args)
+
+        projects(args).each do |project|
+          xml = REXML::Document.new(File.read(project), { attribute_quote: :quote })
+
+          removed = remove_references(args, xml) + remove_specs(args, xml)
+
+          write_xml(project, xml) if removed.flatten.any?
+        end
+
+        delete_specs(args)
+      end
+
+      private
+      def write_xml(project, xml)
+        File.open(project, 'w+') do |file|
+          xml.write(output: file, ie_hack: true)
+        end
+      end
+
+      def delete_specs(args)
+        Dir[*args[:specs]].uniq.each do |spec|
+          RakeFileUtils.rm(spec)
+        end
+      end
+
+      def projects(args)
+        Dir[*args[:projects]]
+      end
+
+      def list(args)
+        ([] << args).flatten
+      end
+
+      def remove_references(args, xml)
+        list(args[:references]).map do |ref|
+          query = "/Project//Reference[starts-with(lower-case(@Include), '#{ref.downcase}')]"
+          xml.elements.delete_all(query)
+        end
+      end
+
+      def remove_specs(args, xml)
+        list(args[:specs]).map do |glob|
+          query = "/Project//Compile[matches(lower-case(@Include), '#{glob}')]"
+          xml.elements.delete_all(query)
+        end
+      end
+    end
+  end
+end

data/lib/rake/funnel/tasks/timing.rb

@@ -0,0 +1,100 @@
+require 'rake'
+require 'rake/tasklib'
+
+Dir["#{File.dirname(__FILE__)}/timing_support/*.rb"].each do |path|
+  require path
+end
+
+module Rake::Funnel::Tasks
+  class Timing < Rake::TaskLib
+    attr_accessor :name
+    attr_reader :stats
+
+    def initialize(name = :timing)
+      @name = name
+      @stats = TimingSupport::Statistics.new
+
+      yield self if block_given?
+
+      define
+    end
+
+    def reset!
+      patches.each { |p| p.revert! }
+    end
+
+    private
+    def define
+      patches.each { |p| p.apply! }
+
+      task @name, :failed do |task, args|
+        TimingSupport::Report.new(@stats, args).render
+      end
+
+      timing_task = Rake.application.current_scope.path_with_task_name(@name)
+      Rake.application.top_level_tasks.push(timing_task)
+
+      self
+    end
+
+    def patches
+      @patches ||= create_patches
+    end
+
+    def create_patches
+      report = Rake::Funnel::Support::Patch.new do |p|
+        report_invoker = -> (opts) { TimingSupport::Report.new(@stats, opts).render }
+
+        p.setup do
+          Rake::Application.class_eval do
+            orig_display_error_message = instance_method(:display_error_message)
+
+            define_method(:display_error_message) do |ex|
+              orig_display_error_message.bind(self).call(ex)
+
+              report_invoker.call(failed: true)
+            end
+
+            orig_display_error_message
+          end
+        end
+
+        p.reset do |memo|
+          Rake::Application.class_eval do
+            define_method(:display_error_message) do |ex|
+              memo.bind(self).call(ex)
+            end
+          end
+        end
+      end
+
+      benchmark = Rake::Funnel::Support::Patch.new do |p|
+        benchmark_invoker = -> (task, &block) { @stats.benchmark(task, &block) }
+
+        p.setup do
+          Rake::Task.class_eval do
+            orig_execute = instance_method(:execute)
+
+            define_method(:execute) do |args|
+              benchmark_invoker.call(self) do
+                orig_execute.bind(self).call(args)
+              end
+            end
+
+            orig_execute
+          end
+        end
+
+        p.reset do |memo|
+          Rake::Task.class_eval do
+            define_method(:execute) do |ex|
+              memo.bind(self).call(ex)
+            end
+          end
+        end
+      end
+
+      [report, benchmark]
+    end
+  end
+end

data/lib/rake/funnel/tasks/timing_support/report.rb

@@ -0,0 +1,89 @@
+require 'smart_colored/extend'
+
+module Rake::Funnel::Tasks::TimingSupport
+  class Report
+    class Column
+      attr_reader :header
+
+      def initialize(stats: [], header: '', accessor: -> (_) { '' })
+        @stats = stats
+        @header = header
+        @accessor = accessor
+      end
+
+      def width
+        longest_value = @stats.map { |s| @accessor.call(s) }.max_by { |m| m.length } || ''
+        width = longest_value.length
+        width = @header.length if width < @header.length
+        width
+      end
+
+      def format_header
+        @header.ljust(width)
+      end
+
+      def format_value(value)
+        @accessor.call(value).ljust(width)
+      end
+    end
+
+    SPACE = 3
+    HEADER_WIDTH = 70
+
+    def initialize(stats, opts = {})
+      @stats = stats
+      @opts = opts
+    end
+
+    def render
+      header
+      rows
+      footer
+    end
+
+    def columns
+      @columns ||= ([
+        Column.new(stats: @stats, header: 'Target', accessor: -> (timing) { timing[:task].name }),
+        Column.new(stats: @stats, header: 'Duration', accessor: -> (timing) { format(timing[:time]) })
+      ])
+    end
+
+    private
+    def header
+      puts '-' * HEADER_WIDTH
+      puts 'Build time report'
+      puts '-' * HEADER_WIDTH
+
+      puts columns.map { |c| c.format_header }.join(' ' * SPACE)
+      puts columns.map { |c| c.format_header.gsub(/./, '-') }.join(' ' * SPACE)
+    end
+
+    def rows
+      @stats.each do |timing|
+        puts columns.map { |c| c.format_value(timing) }.join(' ' * SPACE)
+      end
+    end
+
+    def footer
+      puts '-' * HEADER_WIDTH
+      puts 'Total'.ljust(columns[0].width) + ' ' * SPACE + format(Time.now - @stats.started_at)
+      status_message
+      puts '-' * HEADER_WIDTH
+    end
+
+    def format(seconds)
+      Time.at(seconds).utc.strftime('%H:%M:%S')
+    end
+
+    def status_message
+      status = @opts[:failed] ? 'Failed' : 'OK'
+      status = 'Status'.ljust(columns[0].width) + ' ' * SPACE + status
+
+      if @opts[:failed]
+        $stderr.puts status.bold.red
+      else
+        $stdout.puts status.bold.green
+      end
+    end
+  end
+end

data/lib/rake/funnel/tasks/timing_support/statistics.rb

@@ -0,0 +1,26 @@
+module Rake::Funnel::Tasks::TimingSupport
+  class Statistics
+    include Enumerable
+
+    attr_reader :started_at
+
+    def initialize
+      @stats = []
+      @started_at = Time.now
+    end
+
+    def each(&block)
+      @stats.each(&block)
+    end
+
+    def benchmark(task)
+      t0 = Time.now
+      begin
+        yield if block_given?
+      ensure
+        t1 = Time.now
+        @stats << { task: task, time: t1 - t0 }
+      end
+    end
+  end
+end