bozo-scripts 0.1.5 → 0.1.6

data/lib/bozo/preparers/common_assembly_info.rb

@@ -0,0 +1,34 @@
+module Bozo::Preparers
+
+  class CommonAssemblyInfo
+
+    def company_name(name)
+      @company_name = name
+    end
+
+    def execute
+      log_info 'Generating common assembly info'
+
+      git_hash = env['GIT_HASH_FULL']
+      computer_name = env['COMPUTERNAME']
+      trademark = computer_name ? "#{computer_name} #{git_hash}" : git_hash
+      path = File.expand_path(File.join('build', 'CommonAssemblyInfo.cs'))
+
+      log_debug "Version: #{version}"
+      log_debug "Commit hash: #{git_hash}"
+      log_debug "Computer name: #{computer_name}" if computer_name
+      log_debug "Path: #{path}"
+
+      File.open(path, 'w+') do |f|
+        f << "using System.Reflection;\n"
+        f << "\n"
+        f << "[assembly: AssemblyCompany(\"#{@company_name}\")]\n"
+        f << "[assembly: AssemblyVersion(\"#{version}\")]\n"
+        f << "[assembly: AssemblyFileVersion(\"#{version}\")]\n"
+        f << "[assembly: AssemblyTrademark(\"#{trademark}\")]"
+      end
+    end
+
+  end
+
+end

data/lib/bozo/preparers/file_templating.rb

@@ -0,0 +1,152 @@
+module Bozo::Preparers
+
+  # Preparer for creating files based upon configuration files and ERB-style
+  # templates before any compilation occurs.
+  #
+  # == Overview
+  #
+  # This preparer is primarily intended for generating config files with shared
+  # values but it is capable of generating whatever files you want. Each
+  # instance of the preparer is isolated from the anothers so you could specify
+  # multiple preparers to work with different configurations and templates if
+  # you wished.
+  #
+  # By default the preparer will load <tt>default.rb</tt> followed by
+  # <tt>[environment].rb</tt> followed by <tt>[machine_name].rb</tt> from the
+  # configured config_path if the file exists. It will then load any files
+  # explicitly required through the config_file method.
+  #
+  # == Hook configuration
+  #
+  #   prepare :file_templating do |t|
+  #     t.config_path 'somewhere' # defaults to 'config' if not specified
+  #     t.config_file 'my/specific/file.rb' # must be a specific file
+  #     t.template_files 'src/**/*.config.template' # can use glob format
+  #   end
+  #
+  # Source files are expected to have an additional extension compared to the
+  # target file. For example, a source file of
+  # <tt>src/csharp/Project/Project.config.template</tt> will generate the file
+  # <tt>src/csharp/Project/Project.config</tt>.
+  #
+  # == Configuration files
+  #
+  # Configuration files specify a hash of hashes in a more readable format.
+  # For example:
+  #
+  #   group :example do
+  #     set :one, 'foo'
+  #     set :two, 'bar'
+  #   end
+  #
+  # Internally creates a hash like:
+  #
+  #   {:example => {:one => 'foo', :two => 'bar'}}
+  #
+  # A configuration file can overwrite the values specified by a preceding one
+  # without error. Groups can be opened and closed as desired and nesting
+  # groups is possible.
+  #
+  # == Template files
+  #
+  # To use a value within an ERB template you specify the hash hierarchy as if
+  # they were method names rather than having to use the full hash syntax.
+  #
+  # Therefore, this is valid:
+  #
+  #   Foo is <%= example.one %>
+  #
+  # Whilst this is *not* valid:
+  #
+  #   Foo is <%= self[:example][:one] %>
+  #
+  # If a template uses a value that is not specified within the configuration
+  # then the preparer will raise an error and halt the build.
+  class FileTemplating
+
+    # Creates a new instance.
+    def initialize
+      @config_path = 'config'
+      @template_globs = []
+      @config_files = []
+    end
+
+    # Sets the path of the directory within which the preparer should look for
+    # the default configuration files.
+    #
+    # @param [String] path
+    #     The path to the directory containing the default configuration files.
+    def config_path(path)
+      @config_path = path
+    end
+
+    # Adds a specific file to load configuration from.
+    #
+    # @param [String] path
+    #     The path to a configuration file.
+    def config_file(path)
+      @config_files << path
+    end
+
+    # Adds a set of templates files from which to generate files.
+    #
+    # @param [String] glob
+    #     A glob that points to a set of files that should pass through the
+    #     templating engine.
+    def template_files(glob)
+      @template_globs << glob
+    end
+
+    # Generate all the files matching the configuration.
+    def execute
+      log_info '' # formatting
+      log_info 'Generating files'
+
+      get_coordinator.generate_files do |template, target|
+        log_debug "Generating #{target} from #{template}"
+      end
+    end
+
+    private
+
+    # Creates a new templating coordinator based upon the current
+    # configuration.
+    def get_coordinator
+      coordinator = Bozo::ErubisTemplatingCoordinator.new
+
+      add_config coordinator
+      add_templates coordinator
+
+      coordinator
+    end
+
+    # Adds the configuration to the templating coordinator.
+    def add_config(coordinator)
+      add_default_config_files coordinator
+      @config_files.each {|f| coordinator.required_config_file f}
+    end
+
+    # Adds the default configuration from the configuration directory to the
+    # templating coordinator.
+    #
+    # @param [ErubisTemplatingCoordinator] coordinator
+    #     The template coordinator to add the configuration to.
+    def add_default_config_files(coordinator)
+      default_files = ['default.rb', "#{environment}.rb"]
+      default_files << "#{env['MACHINENAME']}.rb" if env['MACHINENAME']
+
+      default_files.each do |file|
+        coordinator.config_file File.join(@config_path, file)
+      end
+    end
+
+    # Adds the templates to the templating coordinator.
+    def add_templates(coordinator)
+      @template_globs.each do |glob|
+        coordinator.template_files glob
+      end
+    end
+
+  end
+
+end

data/lib/bozo/publishers/file_copy.rb

@@ -0,0 +1,83 @@
+require 'fileutils'
+
+module Bozo::Publishers
+
+  # Publisher that copies files from one location to another.
+  class FileCopy
+
+    # Creates a new instance.
+    def initialize
+      @directories = []
+    end
+
+    # Adds a source directory of files copy.
+    #
+    # Must be relative to the project root. All files within the directory and
+    # its subdirectories will be copied to the destination directory,
+    # maintaining the file structure.
+    #
+    # @params [Array] args
+    #     Path to a directory relative to the project root.
+    def directory(*args)
+      @directories << args
+    end
+
+    # Set the destination directory of the file copy.
+    #
+    # Must be an absolute path.
+    #
+    # @params [String] destination
+    #     The absolution path the source files should be copied to.
+    def destination(destination)
+      @destination = destination
+    end
+
+    def execute
+      if @directories.empty? or @destination.nil?
+        raise Bozo::ConfigurationError.new 'You must specify at least one source file or directory AND a destination directory'
+      end
+
+      ensure_no_clashing_files
+
+      copy_pairs do |source, target|
+        FileUtils.mkdir_p File.dirname(target)
+        log_debug "Publishing \"#{File.basename(source)}\" to \"#{target}\""
+        FileUtils.cp source, target
+      end
+    end
+
+    private
+
+    # Checks the destination does not contain files that will be overwritten by
+    # the source files.
+    def ensure_no_clashing_files
+      existing_files = []
+
+      copy_pairs do |source, target|
+        existing_files << target if File.exist? target
+      end
+
+      raise Bozo::ConfigurationError.new "Target files already exist - #{existing_files}" unless existing_files.empty?
+    end
+
+    # Returns the source-destination file pairs specified by the source
+    # directories and destination directory.
+    def copy_pairs # :yields: source_path, destination_path
+      destination = File.join @destination
+
+      @directories.each do |dir|
+        relative_source_dir = File.join(dir)
+        source_dir = File.expand_path relative_source_dir
+        source_dir_path = Pathname.new source_dir
+
+        Dir[File.join(source_dir, '**', '*')].each do |source_file|
+          rel_path = Pathname.new(source_file).relative_path_from(source_dir_path).to_s
+          target_file = File.join(destination, rel_path)
+          yield source_file, target_file
+        end
+      end
+    end
+
+  end
+
+end

data/lib/bozo/publishers/rubygems.rb

@@ -0,0 +1,18 @@
+module Bozo::Publishers
+
+  # Publisher that publishes gem files to rubygems.org
+  class Rubygems
+
+    def execute
+      Dir['dist/gem/*.gem'].each { |gem| push gem }
+    end
+
+    private
+
+    def push(gem)
+      execute_command :rubygems, ['gem', 'push', gem]
+    end
+
+  end
+
+end

data/lib/bozo/test_runners/dotcover.rb

@@ -0,0 +1,158 @@
+require 'nokogiri'
+
+module Bozo::TestRunners
+
+  # Adds a code coverage test runner using dotCover
+  #
+  # The default configuration looks for dotCover in the ProgramFiles(x86) path
+  #
+  # Test runners can be defined for dotCover to run against. Each runner
+  # produces a separate dotcover output
+  class DotCover
+    def self.default_path
+      if ENV['teamcity.dotCover.home'].nil?
+        if ENV['ProgramFiles(x86)'].nil?
+          program_files_path = ENV['ProgramFiles']
+        else
+          program_files_path = ENV['ProgramFiles(x86)']
+        end
+
+        File.join(program_files_path, 'JetBrains', 'dotCover', 'v1.2', 'Bin', 'dotcover.exe')
+      else
+        File.join(ENV['teamcity.dotCover.home'], 'dotcover.exe')
+      end
+    end
+
+    def initialize
+      @@defaults = {
+        :path => DotCover.default_path,
+        :required => true
+      }
+
+      @config = {}
+      @runners = []
+    end
+
+    # Returns whether dotcover is installed at the configured path
+    def dotcover_installed?
+      path = configuration[:path]
+
+      return false if path.nil?
+
+      File.exist? path
+    end
+
+    # Adds a test runner
+    #
+    # @param [Symbol] runner
+    #     A test runner to wrap with dotcover
+    def runner(runner, &block)
+      add_instance runner, block
+    end
+
+    # Specifies whether covering with dotcover is required
+    #
+    # If it is not required, and dotcover cannot be found, then test runners
+    # are executed without coverage. If dotcover is required but cannot be
+    # found then an error will occur.
+    #
+    # @param [boolean] required
+    #     Whether dotCover coverage is required
+    def required?(required = nil)
+      @config[:required] = required unless required.nil?
+      
+      @config[:required]
+    end
+
+    def execute
+      if required? or dotcover_installed?
+        @runners.each {|runner| execute_with_coverage runner}
+      else
+        @runners.each {|runner| execute_without_coverage(runner)}
+      end
+    end
+
+    private
+
+    # Resolves the named class within the given namespace and then created an
+    # instance of the class before adding it to the given collection and
+    # yielding it to the configuration block when one is provided.
+    #
+    # @param [Symbol] type
+    #     The name of the step executor.
+    # @param [Proc] block
+    #     Optional block to refine the configuration of the step executor.
+    def add_instance(type, block)
+      instance = Bozo::TestRunners.const_get(to_class_name(type)).new
+      instance.extend Bozo::Runner
+      @runners << instance
+      block.call instance if block
+    end
+
+    # Converts a symbol into a Pascal Case class name.
+    #
+    # eg. `:single` => `"Single"`, `:two_words` => `"TwoWords"`.
+    #
+    # @param [Symbol] type
+    #     The name of a step executor.
+    def to_class_name(type)
+      type.to_s.split('_').map{|word| word.capitalize}.join
+    end
+
+    def execute_without_coverage(runner)
+      log_debug 'Running ' + runner.class.to_s + ' without coverage'
+      runner.execute
+    end
+
+    def execute_with_coverage(runner)
+      if required? & !dotcover_installed?
+        log_fatal "Attempting to run with coverage but dotcover could not be found at #{configuration[:path]}"
+      end
+
+      log_debug "Running #{runner.class} with coverage"
+
+      config = configuration
+      dotcover_path = config[:path]
+      coverage_path = generate_coverage_file runner
+
+      args = []
+      args << '"' + dotcover_path + '"'
+      args << "analyse #{coverage_path}"
+
+      log_debug 'Running dotcover from "' + dotcover_path + '"'
+      execute_command :dot_cover, args
+    end
+
+    def generate_coverage_file(runner)
+      output_file = File.expand_path(File.join('temp', 'dotcover', "#{Time.now.to_i}-dotcover-report.xml"))
+
+      runner_args = runner.runner_args
+      runner_args.flatten!
+
+      builder = Nokogiri::XML::Builder.new do |doc|
+        doc.AnalyseParams do
+          doc.Executable runner.runner_path.gsub(/\//, '\\')
+          doc.Arguments runner_args.join(' ')
+          doc.WorkingDir File.expand_path(File.join('temp', 'dotcover'))
+          doc.Output output_file
+        end
+      end
+
+      coverage_path = File.expand_path(File.join('temp', 'dotcover', "coverage.xml"))
+      FileUtils.mkdir_p File.dirname(coverage_path)
+      File.open(coverage_path, 'w+') {|f| f.write(builder.to_xml)}
+
+      coverage_path
+    end
+
+    def configuration
+      config_with_defaults
+    end
+
+    def config_with_defaults
+      @@defaults.merge @config
+    end
+
+  end
+
+end

data/lib/bozo/test_runners/nunit.rb

@@ -0,0 +1,131 @@
+module Bozo::TestRunners
+
+  # A TestRunner for NUnit
+  # By default the x64 runner is used. If you want to use a different
+  # platform runner then set the platform, e.g. 'x86'.
+  #
+  # == Dotcover integration
+  # To enable integration with the dotcover test runner the following
+  # interface needs to be used
+  #
+  #   runner_path # should return the path to the runners executable
+  #   runner_args # should return the arguments to be passed to use
+  class Nunit
+  
+    def initialize
+      @projects = []
+      @include = []
+      @exclude = []
+    end
+    
+    def destination(destination)
+      @destination = destination
+    end
+
+    def platform(platform)
+      @platform = platform
+    end
+    
+    def project(path)
+      @projects << path
+    end
+    
+    def report_path(path)
+      @report_path = path
+    end
+
+    def coverage(coverage)
+      @coverage = coverage
+    end
+
+    def include(include)
+      cannot_define_both_include_and_exclude_categories if @exclude.any?
+      @include << include
+    end
+
+    def exclude(exclude)
+      cannot_define_both_include_and_exclude_categories if @include.any?
+      @exclude << exclude
+    end
+    
+    def to_s
+      "Run tests with nunit against projects #{@projects}"
+    end
+
+    # Returns the path to the runner's executable.
+    #
+    # @returns [String]
+    def runner_path
+      exe_name = "nunit-console.exe"
+
+      if defined? @platform
+        log_debug "Looking for runner with #@platform platform"
+        exe_name = "nunit-console-#@platform.exe"
+      end
+
+      nunit_runners = expand_and_glob('packages', 'NUnit*', 'tools', exe_name)
+      raise nunit_runner_not_found if nunit_runners.empty?
+      raise multiple_runners_found if nunit_runners.size > 1
+
+      nunit_runner = nunit_runners.first
+
+      log_debug "Found runner at #{nunit_runner}"
+
+      nunit_runner
+    end
+
+    # Returns the arguments required for the runner's executable.
+    #
+    # @returns [Array]
+    def runner_args
+      args = []
+
+      @projects.each do |project|
+        expand_and_glob('temp', 'msbuild', project, '**', "#{project}.dll").each do |test_dll|
+          args << "\"#{test_dll}\""
+        end
+      end
+      args << '/nologo'
+
+      report_path = @report_path
+      report_path = expand_path('temp', 'nunit', "#{Time.now.to_i}-nunit-report.xml") unless report_path
+
+      # Ensure the directory is there because NUnit won't make it
+      FileUtils.mkdir_p File.dirname(report_path)
+
+      args << "/xml:\"#{report_path}\""
+      args << "/include:#{@include.join(',')}" if @include.any?
+      args << "/exclude:#{@exclude.join(',')}" if @exclude.any?
+
+      args
+    end
+    
+    def execute
+      execute_command :nunit, [runner_path] << runner_args
+    end
+
+    private
+
+    def nunit_runner_not_found
+      Bozo::ConfigurationError.new 'No NUnit runners found. You must install one via nuget.'
+    end
+
+    def multiple_runners_found
+      Bozo::ConfigurationError.new 'Multiple NUnit runners found. There should only be one.'
+    end
+    
+    def expand_path(*args)
+      File.expand_path(File.join(args))
+    end
+    
+    def expand_and_glob(*args)
+      Dir[expand_path(*args)]
+    end
+
+    def cannot_define_both_include_and_exclude_categories
+      raise Bozo::ConfigurationError.new 'Both include and exclude categories defined. You cannot specify both for nunit.'
+    end
+  
+  end
+
+end

data/lib/bozo/test_runners/runit.rb

@@ -0,0 +1,35 @@
+module Bozo::TestRunners
+
+  class Runit
+
+    def initialize
+      @paths = []
+    end
+
+    def path(path)
+      @paths << path
+    end
+
+    def execute
+      require 'test/unit'
+      
+      test_files = []
+
+      @paths.each do |p|
+        Dir[p].select {|f| (File.extname f) == '.rb'}.each {|f| test_files << f}
+      end
+
+      # raise an error if no test files were found. This may indicate a configuration issue
+      raise Bozo::ConfigurationError.new "No tests found" unless test_files.any?
+      raise Bozo::ExecutionError.new(:runit, test_files, -1) unless execute_tests test_files
+    end
+
+    private
+
+    def execute_tests(test_files)
+      Test::Unit::AutoRunner.run(true, nil, test_files)
+    end
+
+  end
+
+end

data/lib/bozo/version.rb

@@ -0,0 +1,5 @@
+module BozoScripts
+
+  VERSION = File.read(File.expand_path(File.dirname(File.realpath(__FILE__)) + '/../../VERSION')).strip
+  
+end

data/lib/bozo_scripts.rb

@@ -0,0 +1,26 @@
+$:.push File.expand_path(File.dirname(__FILE__))
+
+require 'fileutils'
+require 'rainbow'
+require 'bozo'
+
+require 'bozo/compilers/msbuild'
+require 'bozo/dependency_resolvers/bundler'
+require 'bozo/dependency_resolvers/nuget'
+require 'bozo/hooks/fxcop'
+require 'bozo/hooks/git_commit_hashes'
+require 'bozo/hooks/git_tag_release'
+require 'bozo/hooks/teamcity'
+require 'bozo/hooks/timing'
+require 'bozo/packagers/rubygems'
+require 'bozo/packagers/nuget'
+require 'bozo/preparers/common_assembly_info'
+require 'bozo/preparers/file_templating'
+require 'bozo/publishers/file_copy'
+require 'bozo/publishers/rubygems'
+require 'bozo/test_runners/dotcover'
+require 'bozo/test_runners/nunit'
+require 'bozo/test_runners/runit'
+require 'bozo/configuration'
+require 'bozo/erubis_templating_coordinator'
+require 'bozo/version'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bozo-scripts
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Garry Shutler
@@ -88,7 +88,30 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- lib/bozo/compilers/msbuild.rb
+- lib/bozo/configuration.rb
+- lib/bozo/dependency_resolvers/bundler.rb
+- lib/bozo/dependency_resolvers/nuget.rb
+- lib/bozo/erubis_templating_coordinator.rb
+- lib/bozo/hooks/fxcop.rb
+- lib/bozo/hooks/git_commit_hashes.rb
+- lib/bozo/hooks/git_tag_release.rb
+- lib/bozo/hooks/teamcity.rb
+- lib/bozo/hooks/timing.rb
+- lib/bozo/packagers/nuget.rb
+- lib/bozo/packagers/rubygems.rb
+- lib/bozo/preparers/common_assembly_info.rb
+- lib/bozo/preparers/file_templating.rb
+- lib/bozo/publishers/file_copy.rb
+- lib/bozo/publishers/rubygems.rb
+- lib/bozo/test_runners/dotcover.rb
+- lib/bozo/test_runners/nunit.rb
+- lib/bozo/test_runners/runit.rb
+- lib/bozo/version.rb
+- lib/bozo_scripts.rb
+- VERSION
+- LICENSE
 homepage: https://github.com/zopaUK/bozo-scripts
 licenses: []
 metadata: {}