alpacabuildtool 1.0.0

data/lib/alpacabuildtool/log/log.rb

@@ -0,0 +1,15 @@
+require 'alpacabuildtool/log/rainbowify_logger'
+
+module AlpacaBuildTool
+  ##
+  # Log adds logger to any class that include it
+  module Log
+    attr_writer :log
+
+    ##
+    # Method gives access to logger with lazy initialization
+    def log
+      @log ||= RainbowifyLogger.new
+    end
+  end
+end

data/lib/alpacabuildtool/log/rainbowify_formatter.rb

@@ -0,0 +1,70 @@
+require 'date'
+require 'logger'
+require 'rainbow'
+require 'rainbow/ext/string' unless String.method_defined?(:color)
+require 'alpacabuildtool/log/font'
+
+module AlpacaBuildTool
+  ##
+  # RainbowifyFormatter provides formatting for standart
+  # ruby logger by adding colors(rainbow gem) and ASCII art headers
+  # for HEADER (6) severity
+  class RainbowifyFormatter < Logger::Formatter
+    ##
+    # Provides custom logging implementation
+    #
+    # +severity+:: severity to log(HEADER, PUTS, INFO, ERROR...)
+    # +datetime+:: date time stamp
+    # +progname+:: not used here
+    # +message+:: message to log
+    def call(severity, datetime, _progname, message)
+      case severity
+      when 'HEADER' then header(message)
+      when 'PUTS' then puts(message)
+      else usual(message, severity, datetime)
+      end
+    end
+
+    private
+
+    def header(message)
+      font = Font.new('doom')
+      result = artify_message("\x00#{message}", font)
+      result.join("\n").gsub(/\0/, '').gsub(font.hard_blank, ' ')
+        .color(:green).bright + "\n"
+    end
+
+    def puts(message)
+      message.to_s.color(:blue).bright + "\n"
+    end
+
+    def usual(message, severity, datetime)
+      date_format = datetime.strftime('%FT%T.%L')
+      "[#{date_format}] #{severity}: #{message}".color(color(severity)) + "\n"
+    end
+
+    def color(severity)
+      case severity
+      when 'DEBUG' then :cyan
+      when 'INFO' then :green
+      when 'WARN' then :yellow
+      when 'ERROR' then :red
+      when 'FATAL' then :magenta
+      else :white
+      end
+    end
+
+    def artify_message(msg, font)
+      result = []
+      msg.each_char do |c|
+        o = c.ord
+        o = '0' unless font.char?(o)
+        font.height.times do |j|
+          line = font[o][j]
+          result[j] = (result[j] ||= '') + line
+        end
+      end
+      result
+    end
+  end
+end

data/lib/alpacabuildtool/log/rainbowify_logger.rb

@@ -0,0 +1,47 @@
+require 'logger'
+require 'alpacabuildtool/log/rainbowify_formatter'
+
+module AlpacaBuildTool
+  ##
+  # RainbowifyLogger class is extending ruby logger
+  # with _header_ and _puts_ methods and add colors to logs
+  class RainbowifyLogger < Logger
+    ##
+    # Custom severities that current logger support
+    SEVERITIES = %w(DEBUG INFO WARN ERROR FATAL PUTS HEADER)
+
+    ##
+    # Creates instance of logger with STDOUT as IO object
+    # for logger and adds RainbowifyFormatter as a formatter
+    #
+    # Creates ruby logger with STDOUT object and rainbowify formatter
+    def initialize
+      super(STDOUT)
+      @formatter = RainbowifyFormatter.new
+    end
+
+    ##
+    # Override logger.format_severity in order to use our own severities
+    def format_severity(severity)
+      SEVERITIES[severity] || 'ANY'
+    end
+
+    ##
+    # Log nice ASCII art styled header
+    #
+    # +progname+:: program name
+    # accepts &block
+    def puts(progname = nil, &block)
+      add(5, nil, progname, &block)
+    end
+
+    ##
+    # Log nice ASCII art styled header
+    #
+    # +progname+:: program name
+    # accepts &block
+    def header(progname = nil, &block)
+      add(6, nil, progname, &block)
+    end
+  end
+end

data/lib/alpacabuildtool/managers/build_manager.rb

@@ -0,0 +1,32 @@
+require 'alpacabuildtool/tools/msbuild'
+require 'alpacabuildtool/managers/package_manager'
+
+module AlpacaBuildTool
+  ##
+  # BuildManager provides methods to build *.sln solutions
+  class BuildManager
+    ##
+    # Creates an instance
+    #
+    # +solution+:: solution to be used to configure build manager and to be
+    # built later
+    def initialize(solution)
+      @solution = solution
+      @package_manager = PackageManager.new(@solution)
+      @build_tool = MSBuild.new(@solution.configuration['MSBuild'])
+    end
+
+    ##
+    # Build solution
+    #
+    # +debug+:: set to build in debug mode
+    # +update_version:: set to update AssemblyInfo.cs files for all solution
+    # projects
+    def build(debug, update_version)
+      @package_manager.restore_packages
+      build_version = @solution.build_version
+      @solution.update_projects_version(build_version) if update_version
+      @build_tool.build(@solution.file, debug)
+    end
+  end
+end

data/lib/alpacabuildtool/managers/package_manager.rb

@@ -0,0 +1,136 @@
+require 'alpacabuildtool/entities/nuspec'
+require 'alpacabuildtool/package_types/project_package'
+require 'alpacabuildtool/package_types/tool_package'
+require 'alpacabuildtool/tools/nuget'
+require 'alpacabuildtool/tools/git'
+require 'fileutils'
+
+module AlpacaBuildTool
+  ##
+  # PackageManager provides package management methods for solution
+  class PackageManager < Nuget
+    ##
+    # Defines where packages used by alpaca should be downloaded
+    DOWNLOAD_DIR = File.join(File.expand_path('~'), '.download/')
+
+    ##
+    # Creates an instance
+    # Use Nuget as package management tool
+    #
+    # +solution+:: solution to be used to configure build manager and to be
+    # used further
+    def initialize(solution)
+      @solution = solution
+      super(@solution.configuration['Nuget'])
+    end
+
+    ##
+    # Returns named tool configured from current solution
+    #
+    # +name+:: tool name
+    # +*args+:: arguments for tool creation
+    #
+    #    package_manager.get('NUnit')
+    #    # => #<AlpacaBuildTool:NUnit **>
+    #    package_manager.get('OpenCover', @test_tool)
+    #    # => #<AlpacaBuildTool:OpenCover @tool=..NUnit..**>
+    def get(name, *args)
+      config = @solution.configuration[name]
+      AlpacaBuildTool.const_get(name).new(config, *args) do
+        exe_pattern = File.join(DOWNLOAD_DIR, '**', config['exe'])
+        unless Dir.glob(exe_pattern).any?
+          id, pre = config['package_id'], config['pre_release'] || false
+          install(id, DOWNLOAD_DIR, pre)
+        end
+        Dir.glob(exe_pattern).first
+      end
+    end
+
+    ##
+    # Restore packages for solution
+    def restore_packages
+      if Dir.glob(File.dirname(@solution.file) + '/**/packages.config').empty?
+        log.info 'no packages.config discovered'
+        return
+      end
+      restore(@solution.file)
+    end
+
+    ##
+    # Create and push if requested nuget package
+    #
+    # +config+:: package configuration from solution local configuration
+    # +version+:: package version to be created
+    # +options+:: hash with packaging options
+    # <tt>options[:debug] = true</tt> is to create packages from debug mode<br\>
+    # <tt>options[:push] = true</tt> is to push packages after they are created
+    # <br\>
+    # <tt>options[:force] = true</tt> is to create/push packages even if it has
+    # no changes
+    def create_package(config, version, options)
+      config = generate_config(config, version)
+      project = @solution.project(config['project'])
+      changes, changelog = package_changes(config, project.dir)
+      log.info "#{config['id']} unchanged..." unless changes
+      return unless changes || options[:force]
+      generate_package(project, config, options[:debug], changelog)
+      push_packages(config) if options[:push]
+    end
+
+    private
+
+    def generate_config(config, version)
+      common = @solution.configuration['all_packages'] || {}
+      common.merge(config).merge('version' => version)
+    end
+
+    def package_changes(config, project_dir)
+      FileUtils.rm_rf File.join(DOWNLOAD_DIR, config['id'])
+      begin
+        changes, changelog = latest_package_changes(config, project_dir)
+      rescue
+        changes = Git.changes(project_dir)
+      end
+      new_changes = "#{Git.revision}\n---#{config['version']}---\n#{changes}\n"
+      [changes != '', new_changes + (changelog || ['']).reduce(:+)]
+    end
+
+    def latest_package_changes(config, project_dir)
+      install(config['id'], DOWNLOAD_DIR, config['version'].include?('-'),
+              true, config['source'])
+      file = File.join(DOWNLOAD_DIR, config['id'], 'CHANGES.txt')
+      changelog = IO.readlines(file)
+      commit_id = changelog.shift.gsub(/\n/, '')
+      [Git.changes(project_dir, commit_id), changelog]
+    end
+
+    def generate_package(project, config, debug, changelog)
+      package = typed_package(config['type'], config['id'], project, debug)
+      write_mandatory_files(package, config, changelog)
+      write_optional_file(package.files[2], config)
+      pack(*package.options)
+    end
+
+    def typed_package(type, id, project, debug)
+      AlpacaBuildTool.const_get("#{type.capitalize}Package")
+        .new(id, project, debug)
+    end
+
+    def write_mandatory_files(package, config, changelog)
+      File.write(package.files[0], Nuspec.new(config, package.add_files?).to_s)
+      File.write(package.files[1], changelog)
+    end
+
+    def write_optional_file(file, config)
+      File.write(file, config['readme']) if config['readme']
+    end
+
+    def push_packages(config)
+      output_dir = @configuration['commands']['pack']['OutputDirectory']
+      file = File.join(output_dir, "#{config['id']}.#{config['version']}")
+      push("#{file}.nupkg", config['source'])
+      symbols = "#{file}.symbols.nupkg"
+      push(symbols, config['symbol_source']) if File.exist?(symbols)
+    end
+  end
+end

data/lib/alpacabuildtool/managers/report_manager.rb

@@ -0,0 +1,33 @@
+require 'alpacabuildtool/tools/nunit_orange'
+require 'alpacabuildtool/tools/report_generator'
+require 'alpacabuildtool/managers/package_manager'
+
+module AlpacaBuildTool
+  ##
+  # ReportManager provides methods to convert test results to reports
+  class ReportManager
+    ##
+    # Creates an instance
+    #
+    # +solution+:: solution to be used to configure reports manager
+    def initialize(solution)
+      package_manager = PackageManager.new(solution)
+      @test_tool = package_manager.get('NUnitOrange')
+      @coverage_tool = package_manager.get('ReportGenerator')
+    end
+
+    ##
+    # Convert results to reports
+    #
+    # +type+:: type of results to be converted(tests, coverage, all)
+    def convert(type)
+      case type
+      when 'tests' then @test_tool.convert
+      when 'coverage' then @coverage_tool.convert
+      when 'all'
+        @test_tool.convert
+        @coverage_tool.convert
+      end
+    end
+  end
+end

data/lib/alpacabuildtool/managers/test_manager.rb

@@ -0,0 +1,35 @@
+require 'alpacabuildtool/tools/nunit'
+require 'alpacabuildtool/tools/open_cover'
+require 'alpacabuildtool/managers/package_manager'
+
+module AlpacaBuildTool
+  ##
+  # TestManager provides methods to test *.sln solutions
+  class TestManager
+    ##
+    # Creates an instance
+    #
+    # +solution+:: solution to be used to configure test manager
+    def initialize(solution)
+      package_manager = PackageManager.new(solution)
+      @test_tool = package_manager.get('NUnit')
+      @coverage_tool = package_manager.get('OpenCover', @test_tool)
+    end
+
+    ##
+    # Test list of projects
+    #
+    # +test_projects+:: list of projects with tests
+    # +coverage+:: set to run coverage
+    # +debug+:: set to run tests with debug configuration
+    def test(test_projects, coverage = false, debug = false)
+      test_projects.each do |project|
+        if coverage
+          @coverage_tool.call { |tool| tool.test(project.file, debug) }
+        else
+          @test_tool.test(project.file, debug)
+        end
+      end
+    end
+  end
+end

data/lib/alpacabuildtool/os.rb

@@ -0,0 +1,29 @@
+require 'rbconfig'
+
+module AlpacaBuildTool
+  ##
+  # Os provides methods to simplify defining host os
+  module Os
+    ##
+    # Returns host os as :windows, :macosx, :linux or :unix
+    def self.os
+      @os ||= (
+        host_os = RbConfig::CONFIG['host_os']
+        get_os(host_os)
+      )
+    end
+
+    def self.get_os(host_os)
+      case host_os
+      when /mswin|msys|mingw|cygwin|bccwin|wince|emc/ then :windows
+      when /darwin|mac os/ then :macosx
+      when /linux/ then :linux
+      when /solaris|bsd/ then :unix
+      else
+        fail "unknown os: #{host_os.inspect}"
+      end
+    end
+
+    private_class_method :get_os
+  end
+end

data/lib/alpacabuildtool/package_types/project_package.rb

@@ -0,0 +1,44 @@
+module AlpacaBuildTool
+  ##
+  # ProjectPackage provides configuration of normal nuget packages created
+  # from projects
+  class ProjectPackage
+    ##
+    # Creates an instance
+    #
+    # +package_id+:: not used in current class, but need to be here for
+    # consistent interface with other package types
+    # +project+:: project to be used to create a package
+    # +debug+:: is debug configuration should be used to create a package
+    def initialize(_, project, debug)
+      @nuspec_file = File.join(project.dir, "#{project.name}.nuspec")
+      @readme_file = File.join(project.dir, 'README.txt')
+      @changelog_file = File.join(project.dir, 'CHANGES.txt')
+      @file = project.file
+      @debug = debug
+    end
+
+    ##
+    # Returns array of files: *.nuspec, CHANGELOG.txt, README.txt
+    def files
+      [@nuspec_file, @changelog_file, @readme_file]
+    end
+
+    ##
+    # Returns options to be passed to Nuget.pack
+    def options
+      [@file, @debug ? 'Debug' : 'Release']
+    end
+
+    ##
+    # Returns true so Nuspec file creation process will store readme and
+    # changelog files into <files/> entry
+    #
+    # This is required for normal packages as they are created from *.csproj
+    # but adding them for :tool packages cause missing all other files as
+    # :tool package is created from folder and not *.csproj
+    def add_files?
+      true
+    end
+  end
+end