bozo-scripts 0.1.5 → 0.1.6

data/lib/bozo/erubis_templating_coordinator.rb

@@ -0,0 +1,128 @@
+require 'erubis'
+
+module Bozo
+  
+  # Class for creating files based upon configuration files and ERB-style
+  # templates.
+  # 
+  # == Overview
+  # 
+  # This class is primarily intended for generating config files with shared
+  # values but it is capable of generating whatever files you want.
+  # 
+  # == 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 hook will raise an error and halt the build.
+  class ErubisTemplatingCoordinator
+
+    # Create a new instance.
+    #
+    # @param [Configuration] configuration
+    #     The configuration to use with templates. If not specified a new
+    #     object is created.
+    def initialize(configuration = Bozo::Configuration.new)
+      @templates = []
+      @configuration = configuration
+    end
+
+    # Adds a required configuration file to the underlying configuration
+    # object.
+    # 
+    # @param [String] path
+    #     The path of the configuration file to load.
+    def required_config_file(path)
+      raise RuntimeError.new "Required config file #{path} could not be found" unless File.exist? path
+      config_file path
+    end
+    
+    # Adds a configuration file to the underlying configuration object if a
+    # file exists at the given path.
+    # 
+    # @param [String] path
+    #     The path of the configuration file to load.
+    def config_file(path)
+      @configuration.load path if File.exist? path
+    end
+
+    # Adds a template file to use when generating files.
+    # 
+    # @param [String] path
+    #     The path of the template file.
+    def template_file(path)
+      @templates << path
+    end
+
+    # Adds a selection of template files to use when generating files.
+    # 
+    # @param [String] glob
+    #     A glob from that matches template files.
+    def template_files(glob)
+      @templates = @templates + Dir[glob]
+    end
+
+    # Generate all the files matching the underlying configuration.
+    #
+    # @param [Proc] block
+    #     A block that will be called with the template path and target file
+    #     path when provided.
+    def generate_files(&block)
+      @templates.each {|template| generate_file template, block}
+    end
+
+    private
+
+    # Generate the file relating to the template file using the given
+    # configuration.
+    # 
+    # @param [String] template_path
+    #     The path of the template file that should be filled using the
+    #     configuration.
+    # @param [Proc] block
+    #     A block that will be called with the template path and target file
+    #     path when provided.
+    def generate_file(template_path, block)
+      target_path = template_path.sub /\.[^\.]+$/, ''
+
+      block.call(template_path, target_path) unless block.nil?
+
+      template_content = IO.read template_path
+      template = Erubis::Eruby.new template_content
+
+      content = @configuration.apply {|binding| template.result(binding)}
+
+      File.open(target_path, 'w+') {|f| f.write(content)}
+    end
+
+  end
+
+end

data/lib/bozo/hooks/fxcop.rb

@@ -0,0 +1,152 @@
+module Bozo::Hooks
+
+  # Specifies a hook for running FxCop.
+  #
+  # The default configuration runs against the compiled assemblies produced via
+  # msbuild.
+  #
+  # Alternatively a specific .fxcop project file can be specified in the 
+  # configuration.
+  class FxCop
+
+    def self.default_path
+      if ENV['ProgramFiles(x86)'].nil?
+        program_files_path = ENV['ProgramFiles']
+      else
+        program_files_path = ENV['ProgramFiles(x86)']
+      end
+
+      File.join(program_files_path, 'Microsoft Fxcop 10.0', 'fxcopcmd.exe') unless program_files_path.nil?
+    end
+
+    def initialize
+      @@defaults = {
+        :types => [],
+        :framework_versions => [:net35, :net40],
+        :project => nil,
+        :path => FxCop.default_path
+      }
+
+      @config = {}
+    end
+
+    # Adds a type to analyze
+    def type(type)
+      @config[:types] ||= []
+      @config[:types] << type
+    end
+
+    # Specifies an fxcop project file
+    def project(project)
+      @config[:project] = project
+    end
+
+    # Specifies the fxcop path
+    def path(path = nil)
+      @config[:path] = path unless path.nil?
+      
+      @config[:path]
+    end
+
+    # Runs the post_compile hook
+    def post_compile
+      config = config_with_defaults
+
+      raise no_executable_path_specified if path.nil?
+      raise no_executable_exists unless File.exists?(path)
+
+      if config[:project].nil?
+        execute_projects config
+      else
+        execute_fxcop_project config
+      end
+    end
+
+    private
+
+    def config_with_defaults
+      @@defaults.merge @config
+    end
+
+    # The path to output the fxcop results to
+    def output_path
+      out_path = File.expand_path File.join('temp', 'fxcop')
+      FileUtils.mkdir_p out_path
+      out_path
+    end
+
+    # Executes fxcop against the msbuild built assemblies
+    #
+    # @param [Hash] config
+    #     The fxcop configuration
+    def execute_projects(config)
+      log_debug "Executing projects with '#{path}'" if config[:framework_versions].any?
+
+      config[:framework_versions].each do |framework_version|
+        args = []
+        args << '"' + path + '"'
+        args << "/out:#{output_path}\\#{Time.now.to_i}-#{framework_version}-FxCop-report.xml"
+        args << "/types:" + config[:types].join(',') unless config[:types].empty?
+
+        project_dirs.each do |project|
+          projects = project_files(project, framework_version)
+
+          projects.each do |project_file|
+            project_path = File.expand_path(project_file).gsub(/\//, '\\')
+            args << "/file:\"#{project_path}\""
+          end
+        end
+
+        execute_command :fx_cop, args
+      end
+    end
+
+    # Executes a .fxcop file
+    #
+    # @param [Hash] config
+    #     The fxcop configuration
+    def execute_fxcop_project(config)
+      log_debug "Executing fxcop project '#{config[:project]}' with '#{path}'"
+
+      args = []
+      args << '"' + path + '"'
+      args << "/out:\"#{output_path}\\#{File.basename(config[:project], '.*')}-FxCop-report.xml\""
+      args << "/project:\"#{config[:project]}\""
+      args << "/types:" + config[:types].join(',') unless config[:types].empty?
+
+      execute_command :fx_cop, args
+    end
+
+    # Create a new error specifying that the executable path
+    # has not been specified.
+    def no_executable_path_specified
+      ConfigurationError.new "No path specified for fxcop"
+    end
+
+    # Create a new error specifying that the fxcop executable
+    # does not exist at the path.
+    def no_executable_exists
+      ConfigurationError.new "FxCop executable does not exist at #{path}"
+    end
+
+    # List of compiled assemblies and executables
+
+    # @param [String] project_path
+    #     The path of the project
+    # @param [Symbol] framework_version
+    #     The framework_version to find assemblies for
+    def project_files(project_path, framework_version)
+      project_name = File.basename(project_path)
+      file_matcher = File.expand_path File.join(project_path, framework_version.to_s, "#{project_name}.{dll,exe}")
+      Dir[file_matcher]
+    end
+
+    # List of all the msbuild built projects
+    def project_dirs
+      project_file_matcher = File.expand_path File.join('temp', 'msbuild', '*')
+      Dir[project_file_matcher]
+    end
+
+  end
+
+end

data/lib/bozo/hooks/git_commit_hashes.rb

@@ -0,0 +1,12 @@
+module Bozo::Hooks
+
+  class GitCommitHashes
+    
+    def post_dependencies
+      env['GIT_HASH'] = `git log -1 --format="%h"`.strip
+      env['GIT_HASH_FULL'] = `git log -1 --format="%H"`.strip
+    end
+    
+  end
+
+end

data/lib/bozo/hooks/git_tag_release.rb

@@ -0,0 +1,23 @@
+module Bozo::Hooks
+
+  # Hook to tag a git repository when a release is published from a build
+  # server.
+  class GitTagRelease
+
+    def post_publish
+      return unless build_server?
+      log_info "Tagging repository for release #{version}"
+
+      tag_name = "rel-#{version}"
+
+      if `git tag`.split("\n").include? tag_name
+        raise Bozo::ConfigurationError.new "The tag #{tag_name} already exists"
+      end
+
+      execute_command :git, ['git', 'tag', tag_name]
+      execute_command :git, ['git', 'push', '--tags']
+    end
+
+  end
+
+end

data/lib/bozo/hooks/teamcity.rb

@@ -0,0 +1,92 @@
+module Bozo::Hooks
+
+  class Teamcity
+
+    include Bozo::ClassNameHelpers
+
+    def pre_compile
+      return unless Teamcity.hosted_in_teamcity?
+      log_pre_step :compile
+
+      puts "##teamcity[buildNumber '#{version}']"
+      # currently a general compiler which wraps everything. Once a compiler hook is added can distinguish
+      # each specific compiler
+      puts "##teamcity[compilationStarted compiler='Bozo']"
+    end
+
+    def post_compile
+      return unless Teamcity.hosted_in_teamcity?
+      puts "##teamcity[compilationFinished compiler='Bozo']"
+      log_post_step :compile
+    end
+
+    def post_test
+      return unless Teamcity.hosted_in_teamcity?
+
+      report
+      report_dotnetcoverage
+
+      log_post_step :test
+    end
+
+    def method_missing(method, *args)
+      if method.to_s =~ /^(pre|post)_(.+)/
+        send "log_#{$1}_step".to_sym, $2
+      else
+        super
+      end
+    end
+
+    def respond_to?(method)
+      method.to_s =~ /^(pre|post)_(.+)/ or super
+    end
+
+    # Returns whether teamcity is hosting bozo
+    def self.hosted_in_teamcity?
+      not ENV['TEAMCITY_VERSION'].nil?
+    end
+
+    private
+
+    # Notifies teamcity of general reports such as test runner results
+    def report
+      report_types = [:nunit, :fxcop]
+      report_types.each do |type|
+        reports = report_files(File.join(Dir.pwd, "/temp"), type)
+
+        reports.each do |report|
+          puts "##teamcity[importData type='#{type}' path='#{report}']"
+        end
+      end
+    end
+
+    # Notifies teamcity of dotNetCoverage results
+    def report_dotnetcoverage
+      tool_types = [:dot_cover]
+      
+      tool_types.each do |type|
+        reports = report_files(File.join(Dir.pwd, "/temp"), type)
+
+        reports.each do |report|
+          tool_name = to_class_name(type).downcase
+          puts "##teamcity[importData type='dotNetCoverage' tool='#{tool_name}' path='#{report}']"
+        end
+      end
+    end
+
+    def log_pre_step(step)
+      puts "##teamcity[progressStart 'Pre #{step}']" if Teamcity.hosted_in_teamcity?
+    end
+
+    def log_post_step(step)
+      puts "##teamcity[progressEnd 'Post #{step}']" if Teamcity.hosted_in_teamcity?
+    end
+
+    def report_files(path, type)
+      files = File.expand_path(File.join(path, "/**/*-#{to_class_name(type)}-report.xml"))
+      Dir[files]
+    end
+
+  end
+
+end

data/lib/bozo/hooks/timing.rb

@@ -0,0 +1,41 @@
+module Bozo::Hooks
+  
+  class Timing
+  
+    def initialize
+      @timings = {}
+    end
+    
+    def print_timings
+      puts ''
+      @timings.each do |stage, times|
+        puts format_timing(stage, times).bright.color(stage == :build ? :cyan : :black)
+      end
+    end
+    
+    def format_timing(stage, args)
+      time_taken = (args[:post] - args[:pre]).round(1)
+      "#{stage.to_s.capitalize.ljust(14)} #{time_taken.to_s.rjust(5)}s"
+    end
+    
+    def record(stage, point)
+      @timings[stage] ||= {}
+      @timings[stage][point] = Time.now
+    end
+    
+    def method_missing(method, *args)
+      if method.to_s =~ /^(pre|post)_(.+)/
+        record $2.to_sym, $1.to_sym
+        print_timings if $1 == 'post' and $2 == 'build'
+      else
+        super
+      end
+    end
+    
+    def respond_to?(method)
+      method.to_s =~ /^(pre|post)_(.+)/ or super
+    end
+  
+  end
+  
+end

data/lib/bozo/packagers/nuget.rb

@@ -0,0 +1,226 @@
+require 'nokogiri'
+
+module Bozo::Packagers
+
+  class Nuget
+    
+    def initialize
+      @libraries = []
+      @executables = []
+      @websites = []
+    end
+    
+    def destination(destination)
+      @destination = destination
+    end
+    
+    def library(project)
+      @libraries << LibraryPackage.new(project, self)
+    end
+
+    def executable(project)
+      @executables << ExecutablePackage.new(project)
+    end
+
+    def website(project)
+      @websites << WebsitePackage.new(project)
+    end
+    
+    def required_tools
+      :nuget
+    end
+
+    def project_url(url)
+      @project_url = url
+    end
+
+    def license_url(url)
+      @license_url = url
+    end
+
+    def author(author)
+      @author = author
+    end
+    
+    def to_s
+      "Publish projects with nuget #{@libraries | @executables | @websites} to #{@destination}"
+    end
+    
+    def execute
+      @libraries.each {|project| package project}
+      @executables.each {|project| package project}
+      @websites.each {|project| package project}
+    end
+
+    # Returns the version that the package should be given.
+    def package_version
+      # If running on a build server then it is a real release, otherwise it is
+      # a preview release and the version should reflect that.
+      if build_server?
+        version
+      else
+        "#{version}-pre#{env['GIT_HASH']}"
+      end
+    end
+
+    private
+
+    def package(project)
+      spec_path = generate_specification(project)
+      create_package(project.name, spec_path, true)
+    end
+    
+    def generate_specification(project)
+      log_debug "Generating specification for #{project.name}"
+      builder = Nokogiri::XML::Builder.new do |doc|
+        doc.package(:xmlns => "http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd") do
+          doc.metadata do
+            doc.id project.name
+            doc.version_ package_version
+            doc.authors @author
+            doc.description project.name
+            doc.projectUrl @project_url
+            doc.licenseUrl @license_url
+            doc.dependencies do
+              project.dependencies.each do |dep|
+                doc.dependency(dep)
+              end
+            end
+          end
+          doc.files do
+            project.files.each do |file|
+              doc.file(file)
+            end
+          end
+        end
+      end
+      spec_path = File.expand_path(File.join('temp', 'nuget', "#{project.name}.nuspec"))
+      FileUtils.mkdir_p File.dirname(spec_path)
+      File.open(spec_path, 'w+') {|f| f.write(builder.to_xml)}
+      spec_path
+    end
+    
+    def create_package(project, spec_path, omit_analysis = false)
+      args = []
+      
+      dist_dir = File.expand_path(File.join('dist', 'nuget'))
+      
+      args << File.expand_path(File.join('build', 'tools', 'nuget', 'NuGet.exe'))
+      args << 'pack'
+      args << "\"#{spec_path}\""
+      args << '-OutputDirectory'
+      args << "\"#{dist_dir}\""
+      args << '-NoPackageAnalysis' if omit_analysis
+      
+      # Ensure the directory is there because Nuget won't make it
+      FileUtils.mkdir_p dist_dir
+      
+      log_debug "Creating nuget package for #{project}"
+      
+      execute_command :nuget, args
+    end
+    
+  end
+
+  private
+
+  class ExecutablePackage
+
+    def initialize(project)
+      @name = project
+    end
+
+    def name
+      @name
+    end
+
+    def dependencies
+      []
+    end
+
+    def files
+      [{:src => File.expand_path(File.join('temp', 'msbuild', @name, '**', '*.*')).gsub(/\//, '\\'), :target => 'exe'}]
+    end
+
+  end
+
+  class LibraryPackage
+
+    def initialize(project, nuget)
+      @name = project
+      @nuget = nuget
+    end
+
+    def name
+      @name
+    end
+
+    def dependencies
+      project_reference_dependencies + nuget_dependencies
+    end
+
+    def files
+      %w{dll pdb xml}.map do |extension|
+        {:src => File.expand_path(File.join('temp', 'msbuild', @name, '**', "#{@name}.#{extension}")).gsub(/\//, '\\'), :target => 'lib'}
+      end
+    end
+
+    private
+
+    def project_reference_dependencies
+      doc = Nokogiri::XML(File.open(project_file))
+
+      doc.xpath('//proj:Project/proj:ItemGroup/proj:ProjectReference/proj:Name', {"proj" => "http://schemas.microsoft.com/developer/msbuild/2003"}).map do |node|
+        {:id => node.text, :version => "[#{@nuget.package_version}]"}
+      end
+    end
+
+    # get dependencies from packages.config
+    def nuget_dependencies
+      package_file = packages_file
+      return [] unless File.exist? package_file
+
+      doc = Nokogiri::XML(File.open(package_file))
+
+      doc.xpath('//packages/package').map do |node|
+        {:id => node[:id], :version => "[#{node[:version]}]"}
+      end
+    end
+
+    def packages_file
+      find_file_in_project 'packages.config'
+    end
+
+    def project_file
+      find_file_in_project "#{@name}.csproj"
+    end
+
+    def find_file_in_project(file_name)
+      file = File.expand_path(File.join('src', 'csharp', @name, file_name))
+      file = File.expand_path(File.join('test', 'csharp', @name, file_name)) unless File.exist? file
+      file
+    end
+
+  end
+
+  class WebsitePackage
+
+    def initialize(project)
+      @name = project
+    end
+
+    def name
+      @name
+    end
+
+    def dependencies
+      []
+    end
+
+    def files
+      [{:src => File.expand_path(File.join('temp', 'msbuild', @name, '**', '*.*')).gsub(/\//, '\\'), :target => 'website'}]
+    end
+
+  end
+  
+end

data/lib/bozo/packagers/rubygems.rb

@@ -0,0 +1,24 @@
+module Bozo::Packagers
+
+  # Specifies gem packager.
+  #
+  # Builds any '*.gemspec' file in the root directory
+  class Rubygems
+
+    def execute
+      dist_dir = File.expand_path(File.join('dist', 'gem'))
+      FileUtils.mkdir_p dist_dir
+
+      Dir['*.gemspec'].each { |spec| build_gem spec }
+      Dir['*.gem'].each { |file| FileUtils.mv file, File.join(dist_dir, file) }
+    end
+
+    private
+
+    def build_gem(spec)
+      execute_command :rubygems, ['gem', 'build', spec]
+    end
+
+  end
+
+end