albacore 1.0.0 → 2.0.0.rc.1

data/lib/albacore/tools/restore_hint_paths.rb

@@ -0,0 +1,112 @@
+# -*- encoding: utf-8 -*-
+
+require 'nokogiri'
+require 'pathname'
+require 'rake'
+require 'albacore/logging'
+require 'albacore/project'
+
+module Albacore::Tools
+  # a package repository is a location where the nugets or wraps are stored
+  class PackageRepo
+    include Logging
+    # initialize that package repository with a path to all the packages
+    def initialize path
+      @path = path
+    end
+    # find the latest package based on the package id
+    def find_latest pkg_id
+      trace "finding latest from #{@path}, id: #{pkg_id}"
+      sorted = Dir.glob(File.join(@path, "#{pkg_id}*/**/*.dll")) # find the latest
+      path = sorted.first
+      Package.new pkg_id, path
+    end
+  end
+
+  # a package encapsulates the properties of a set package with a 
+  # distinct path, version and id
+  class Package
+    attr_reader :id, :path
+    def initialize id, path
+      @id = id
+      @path = path
+    end
+    def path
+      @path
+    end
+    def to_s
+      "Package[#{@path}]"
+    end
+  end
+
+  # a tuple of a package and a ref
+  class MatchedRef
+    attr_accessor :package, :ref
+    def initialize package, ref
+      @package, @ref = package, ref
+    end
+  end
+
+  
+  module RestoreHintPaths
+    class Config
+      attr_accessor :asmname_to_package
+      attr_accessor :lang
+      attr_accessor :projs, :dry_run
+      def initialize
+        @asmname_to_package = {}
+        @lang = 'fs'
+      end
+    end
+    class Task
+      include Logging
+      def initialize config
+        @config = config
+      end
+      def execute
+        ps = map_file_list(@config.projs) || find_projs_in_need(@config.lang)
+        ps.each do |proj|
+          info "fixing #{proj}"
+          fix_refs proj, @config.asmname_to_package
+          info "saving #{proj}"
+          proj.save unless @config.dry_run
+        end
+      end
+      
+      private
+      def find_projs_in_need ext
+        map_file_list FileList["./src/**/*.#{ext}proj"]
+      end
+      def map_file_list fl
+        return nil if fl.nil?
+        fl.collect{ |path| Project.new(path) }.
+           keep_if{ |fp| fp.has_faulty_refs? && fp.has_packages_config? }
+      end
+      def matched_refs refs, packages, asmname_to_package = {}
+        refs.collect { |ref| 
+          ref_include_id = asmname_to_package.fetch(ref['Include'].split(',')[0]) { |k| k }
+          found_pkg = packages[ref_include_id]
+          debug "ref[Include] = #{ref_include_id}, package: #{found_pkg}" unless found_pkg.nil?
+          debug "NOMATCH: #{ref_include_id}" if found_pkg.nil?
+          found_pkg.nil? ? nil : MatchedRef.new(found_pkg, ref)
+        }.keep_if { |match| not match.nil? }
+      end
+
+      def fix_refs p, asmname_to_package = {}
+        packages = Hash[p.find_packages.collect { |v| [v.id, v] }]
+        trace "packages: #{packages}"
+        matches = matched_refs p.faulty_refs, packages, asmname_to_package
+        trace "matches: #{matches}"
+        matches.each{ |match|
+          dll_path = Pathname.new match.package.path
+          proj_path = Pathname.new p.proj_path_base
+          hint_path = Nokogiri::XML::Node.new "HintPath", p.proj_xml_node
+          hint_path.content = dll_path.relative_path_from proj_path
+          match.ref << hint_path
+          debug "For #{p.asmname} => hint_path: #{hint_path}"
+        }
+        trace p.proj_xml_node
+      end
+    end
+  end
+end

data/lib/albacore/version.rb

@@ -1,3 +1,3 @@
-module Albacore
-  VERSION = "1.0.0"
-end
+module Albacore
+  VERSION = "2.0.0.rc.1"
+end

data/spec/Rakefile

@@ -0,0 +1,5 @@
+require 'albacore'
+task :default do
+  sh "ruby --version"
+  sh "oh noes"
+end

data/spec/albacore_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe "pub sub" do
+  it {
+    @got_it = false
+    Albacore.subscribe :pubsub do |obj| 
+      @got_it = obj
+    end
+    Albacore.publish :pubsub, true
+    @got_it.should be_true
+  }
+end

data/spec/asmver_spec.rb

@@ -0,0 +1,151 @@
+require 'albacore/task_types/asmver/engine'
+require 'albacore/task_types/asmver/file_generator'
+
+include Albacore::Asmver
+
+%w|Fs Vb Cpp Cs|.each do |lang|
+  require "albacore/task_types/asmver/#{lang.downcase}"
+  describe "the #{lang} engine" do
+    subject do
+      "Albacore::Asmver::#{lang}".split('::').inject(Object) { |o, c| o.const_get c }.new
+    end
+    %w|build_attribute build_named_parameters build_positional_parameters build_using_statement build_comment namespace_end namespace_start|.each do |m|
+      it "should have a public API ##{m.to_s}" do
+        should respond_to(:"#{m}")
+      end
+    end
+    describe 'when building version attribute' do
+      let :version do
+        subject.build_attribute 'AssemblyVersion', '0.2.3'
+      end
+      it 'should contain the name AssemblyVersion' do
+        version.should include('AssemblyVersion')
+      end
+      it 'should contain the version 0.2.3' do
+        version.should include('0.2.3')
+      end
+      it 'should include the "assembly:" string' do
+        version.should include('assembly: ')
+      end
+    end
+    describe 'when building using statement' do
+      let :using do
+        subject.build_using_statement 'System.Runtime.CompilerServices'
+      end
+      it 'should contain the namespace System.Runtime.CompilerServices' do
+        using.should =~ /System.{1,2}Runtime.{1,2}CompilerServices/
+      end
+    end
+    describe 'when building named parameters' do
+      let :plist do
+        subject.build_named_parameters milk_cows: true, birds_fly: false, hungry_server: 'sad server'
+      end
+      it 'should include the parameter names' do
+        plist.should =~ /milk_cows .{1,2} true. birds_fly .{1,2} false. hungry_server .{1,2} "sad server"/
+      end
+    end
+    describe 'when building positional parameters' do
+      let :plist do
+        subject.build_positional_parameters ((%w|a b c hello|) << false)
+      end
+      it 'should include the positional parameters' do
+        plist.should eq('"a", "b", "c", "hello", false')
+      end
+    end
+    describe 'when building single line comment' do
+      let :comment do
+        subject.build_comment 'this is my comment'
+      end
+      it 'should include the string verbatim' do
+        comment =~ /this is my comment/
+      end
+      let :expected do
+        { 'Fs' => %r{// this is my comment},
+          'Vb' => %r{' this is my comment},
+          'Cs' => %r{// this is my comment},
+          'Cpp' => %r{// this is my comment}
+        }[lang]
+      end
+      it 'should include the correct syntax for single line comment' do
+        comment.should =~ expected
+      end
+    end
+    describe 'when building a multi-line comment' do
+      let :comment do
+        subject.build_comment %{This is a very interesting comment
+on many lines}
+      end
+      let :expected do
+        { 'Cs' => %{/*
+ This is a very interesting comment
+ on many lines
+*/},
+          'Fs' => %{(*
+ This is a very interesting comment
+ on many lines
+*)},
+          'Vb' =>
+%{' This is a very interesting comment
+' on many lines},
+          'Cpp' => %{/*
+ This is a very interesting comment
+ on many lines
+*/}
+        }[lang]
+      end
+      it 'should build the multiline comment' do
+        comment.should eq(expected)
+      end
+    end
+  end
+end
+describe FileGenerator do
+  subject do
+    FileGenerator.new(Fs.new, 'MyNamespace.Here', {})
+  end
+  it do
+    subject.should respond_to(:generate)
+  end
+end
+describe FileGenerator, 'when generating F# file' do
+  subject do
+    FileGenerator.new(Fs.new, 'My.Fs.Ns', {})
+  end
+  let :generated do
+    subject.generate com_visible: false,
+      assembly_title: 'My.Ns',
+      assembly_version: '0.1.2',
+      custom_thing: %w|a b c|,
+      named_thing: { :b => 3, :c => 'hi' }
+  end
+  it 'should include namespace' do
+    generated.should =~ /namespace My\.Fs\.Ns(\r\n?|\n)/
+  end
+  it 'should open System.Reflection' do
+    generated.should =~ /open System\.Reflection/
+  end
+  it 'should open System.Runtime.CompilerServices' do
+    generated.should =~ /open System\.Runtime\.CompilerServices/
+  end
+  it 'should open System.Runtime.InteropServices' do
+    generated.should =~ /open System\.Runtime\.InteropServices/
+  end
+  it 'should generate the ComVisible attribute' do
+    generated.should include('[<assembly: ComVisible(false)>]')
+  end
+  it 'should generate the AssemblyTitle attribute' do
+    generated.should include('[<assembly: AssemblyTitle("My.Ns")>]')
+  end
+  it 'should generate the AssemblyVersion attribute' do
+    generated.should include('[<assembly: AssemblyVersion("0.1.2")>]')
+  end
+  it 'should generate the CustomThing attribute' do
+    generated.should include('[<assembly: CustomThing("a", "b", "c")>]')
+  end
+  it 'should generate the NamedThing attribute' do
+    generated.should include('[<assembly: NamedThing(b = 3, c = "hi")>]')
+  end
+  it 'should end with ()\n' do
+    generated.should =~ /\(\)(\r\n?|\n)$/m
+  end
+end

data/spec/asmver_task_spec.rb

@@ -0,0 +1,32 @@
+require 'albacore/task_types/asmver'
+
+describe ::Albacore::Asmver::Config, 'when setting attributes and out' do
+  let :strio do
+    StringIO.new
+  end
+  subject do
+    ::Albacore::Asmver::Config.new
+  end
+  def task
+    @task
+  end
+  before :each do
+    subject.file_path = 'Version.fs'
+    subject.namespace = 'Hello.World'
+    subject.attributes guid: 'b766f4f3-3f4e-49d0-a451-9c152059ae81',
+      assembly_version: '0.1.2'
+    subject.out = strio
+    @task = ::Albacore::Asmver::Task.new(subject.opts)
+    @task.execute
+  end
+  it 'should write namespace' do
+    strio.string.should include('namespace Hello.World')
+  end
+  it 'should write Guid("...")' do
+    strio.string.should include('[<assembly: Guid("b766f4f3-3f4e-49d0-a451-9c152059ae81")>]')
+  end
+  it 'should write AssemblyVersion' do
+    strio.string.should include('[<assembly: AssemblyVersion("0.1.2")>]')
+  end
+end
+

data/spec/build_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'support/sh_interceptor'
+require 'albacore'
+require 'albacore/task_types/build'
+
+describe 'build config' do
+  subject do
+    Albacore::Build::Config.new
+  end
+  %w[file= sln= target target= logging logging= prop cores cores=].each do |writer|
+    it "should have property :#{writer}" do
+      subject.respond_to?(:"#{writer}").should be_true
+    end
+  end
+  it 'should not have any property' do
+    subject.respond_to?(:something_nonexistent).should be_false
+  end
+
+  describe 'when setting properties' do
+    before do
+      subject.logging = 'minimal'
+    end
+    it do
+      subject.parameters.should include('/verbosity:minimal')
+    end
+  end
+end
+
+describe 'when running with sln' do
+  let :cfg do
+    Albacore::Build::Config.new
+  end
+
+  include_context 'path testing'
+
+  let(:cmd) do
+    cmd = Albacore::Build::Cmd.new cfg.work_dir, 'xbuild', cfg.parameters
+    cmd.extend ShInterceptor
+  end
+
+  before do
+    cfg.sln = 'src/HelloWorld.sln'
+    cmd.execute
+  end
+
+  subject do
+    cmd
+  end
+
+  it do
+    subject.executable.should eq('xbuild')
+  end
+  it do
+    subject.parameters.should eq(%W|/verbosity:minimal #{path 'src/HelloWorld.sln'}|)
+  end
+  it do
+    subject.is_mono_command?.should be_false
+  end
+end
+

data/spec/config_dsl_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'rake'
+require 'albacore/config_dsl'
+
+class Example
+  # self.include won't work: 'private method ...'
+  self.extend ::Albacore::ConfigDSL
+
+  attr_path :out, :in
+
+  attr_path_accessor :a, :b
+
+  attr_path :x do |path|
+    @was_called = path
+  end
+
+  attr_path_accessor :y do |val|
+    @y_called = val
+  end
+
+  def out
+    @out
+  end
+  def in
+    @in
+  end
+
+  def x
+    @x
+  end
+
+  # whether the block was called
+  def was_called
+    @was_called
+  end
+
+  def y_called
+    @y_called
+  end
+end
+
+describe Example, 'when setting properties' do
+  before do
+    subject.out = 'a/b/c'
+    subject.in  = 'a\\b\\c'
+    subject.a   = 'a/b/c'
+    subject.b   = 'a\\b\\c'
+  end
+  let :expected do
+    ::Rake::Win32.windows? ? 'a\\b\\c' : 'a/b/c'
+  end
+  it 'should have remapped :in' do
+    subject.in.should eq(expected)
+  end
+  it 'should have remapped :out' do
+    subject.out.should eq(expected)
+  end
+  it 'should be able to read and write :a' do
+    subject.a.should eq(expected)
+  end
+  it 'should be able to read and write :b' do
+    subject.b.should eq(expected)
+  end
+end
+
+describe Example, 'when using blocks for properties' do
+  before do
+    subject.x = 'a/b/c'
+    subject.y = 'a\\b\\c'
+  end
+  let :expected do
+    ::Rake::Win32.windows? ? 'a\\b\\c' : 'a/b/c'
+  end
+  it 'should have written x' do
+    subject.x.should eq(expected)
+  end
+  it 'should have called x block' do
+    subject.was_called.should eq(expected)
+  end
+  it 'should have called y block' do
+    subject.y_called.should eq(expected)
+  end
+end