alpacabuildtool 1.0.0

data/alpacabuildtool.gemspec

@@ -0,0 +1,34 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'alpacabuildtool/versioning/versioning'
+version = ((AlpacaBuildTool::Versioning.find).to_s '%M.%m.%p%s').gsub('-', '.')
+
+Gem::Specification.new do |s|
+  s.name = 'alpacabuildtool'
+  s.version = version
+  s.author = 'Vasyl Purchel'
+  s.email = 'vasyl.purchel@gmail.com'
+  s.homepage = 'https://github.com/vasyl-purchel/alpaca'
+  s.license = 'MIT'
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'yet another build tool for Visual Studio solutions'
+  s.files = `git ls-files -z`.split("\x0")
+  s.test_files = s.files.grep(/^(test|spec|features|test_data)/)
+  s.require_paths << 'lib'
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README.rdoc', 'alpacabuildtool.rdoc']
+  s.rdoc_options << '--title' << 'AlpacaBuildTool'
+  s.rdoc_options << '--main' << 'README.rdoc' << '-ri'
+  s.bindir = 'bin'
+  s.executables << 'alpaca'
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rdoc')
+  s.add_development_dependency('cucumber', '~> 2.0.0')
+  s.add_development_dependency('rspec', '~> 3.2.0')
+  s.add_development_dependency('fakefs')
+  s.add_development_dependency('rubocop', '~> 0.30.1')
+  s.add_development_dependency('bundler', '~> 1.6')
+  s.add_development_dependency('simplecov', '~> 0.7')
+  s.add_runtime_dependency('gli', '2.13.0')
+  s.add_runtime_dependency('rainbow')
+end

data/alpacabuildtool.rdoc

@@ -0,0 +1,5 @@
+= alpacabuildtool
+
+Generate this with
+    alpacabuildtool rdoc
+After you have described your command line interface

data/alpacabuildtool.todo

@@ -0,0 +1,9 @@
+tasks:
+ ☐ decouple from tools (configure test_tool with formatter type, parameters
+   and so on from configs instead of NUnit class)
+ ☐ add nunit tests categories (not types like unit, service, ...
+   but MetaTestsAttribute, CoreTestsAttribute...)
+ ☐ add service tests running:
+    ☐ eval 'service_tests_script' to update service configuration
+    ☐ run 'exe' in child process
+    ☐ run 'service' type project tests

data/bin/alpaca

@@ -0,0 +1,142 @@
+#!/usr/bin/env ruby
+require 'gli'
+require 'alpacabuildtool'
+
+module AlpacaBuildTool
+  ##
+  # The *GliWrapper* module provides command line interface by using GLI::App
+  module GliWrapper
+    include GLI::App
+    extend self
+
+    program_desc 'is a build tool for Visual Studio solutions'
+    subcommand_option_handling :normal
+    arguments :strict
+    gem_path = File.join(File.expand_path(File.dirname(__FILE__)), '..')
+    version Versioning.parse(File.join(gem_path, '.semver')).to_s
+
+    on_error do |exception|
+      puts exception.backtrace if ENV['DEV'] == 'true'
+      true
+    end
+
+    desc 'Solutions search pattern'
+    default_value '**/*.sln'
+    flag [:p, :pattern]
+
+    desc 'Compile solution[s]'
+    long_desc 'Compiling each solution founded from pattern in global options'
+    command :compile do |command|
+      command.desc 'Build solution in Debug mode'
+      command.switch :d, :debug
+
+      command.desc 'Update project versions'
+      command.switch :u, :update
+
+      command.action do |global, options, _|
+        Application.new.compile(global[:p],
+                                debug: options[:d] || false,
+                                update_version: options[:u] || false)
+      end
+    end
+
+    desc 'Test solution[s]'
+    long_desc 'Testing each solution founded from pattern in global options'
+    command :test do |command|
+      command.desc 'Test solution in Debug mode'
+      command.switch :d, :debug, negatable: false
+
+      command.desc 'Run tests with coverage'
+      command.switch [:c, :coverage]
+
+      command.desc 'Test type'
+      command.default_value 'all'
+      command.flag :t, :type
+
+      command.action do |global, options, _|
+        Application.new.test(global[:p],
+                             debug: options[:d] || false,
+                             coverage: options[:c] || false,
+                             type: options[:t])
+      end
+    end
+
+    desc 'Generate reports for solution[s]'
+    long_desc 'Generate reports for all founded results for solutions'
+    command :report do |command|
+      command.desc 'Report category'
+      command.default_value 'all'
+      command.flag :t, :type
+
+      command.action do |global, options, _|
+        Application.new.report(global[:p], type: options[:t])
+      end
+    end
+
+    desc 'Create packages for solution[s]'
+    long_desc 'Create new packages for solutions'
+    command :pack do |command|
+      command.desc 'Pack package in Debug mode'
+      command.switch :d, :debug, negatable: false, default_value: false
+
+      command.desc 'Push package after it created if it contains changes'
+      command.switch :p, :push, default_value: false
+
+      command.desc 'Force push package after it created'
+      command.switch :f, :force, default_value: false
+
+      command.action do |global, options, _|
+        Application.new.package(global[:p], options)
+      end
+    end
+
+    desc 'Release packages for solution[s]'
+    long_desc 'Update package to release version and push it'
+    command :release do |command|
+      command.desc 'Push to the source after released'
+      command.switch :p, :push, default_value: true
+
+      command.desc 'Force push package after it created'
+      command.switch :f, :force, default_value: false
+
+      command.action do |global, options, _|
+        Application.new.release(global[:p], options)
+      end
+    end
+
+    desc 'Update solution[s] versions'
+    long_desc 'Update version for each solution'
+    command :update do |command|
+      command.desc 'Version dimension to be updated(patch, minor..)'
+      command.default_value 'patch'
+      command.flag :d, :dimension
+
+      command.action do |global, options, _|
+        Application.new.update(global[:p], options)
+      end
+    end
+
+    desc 'Configure alpaca to your needs'
+    long_desc 'Save configuration into local/global conf files
+      for further usage'
+    command :configure do |command|
+      command.desc 'configure solution[s] from global pattern'
+      command.arg_name 'node1.node2.property=value', :multiple
+      command.command :local do |subcommand|
+        subcommand.action do |global, _, arguments|
+          Application.new.configure_local(global[:p], arguments)
+        end
+      end
+
+      command.desc 'configure alpaca in user wide sence'
+      command.arg_name 'node1.node2.property=value', :multiple
+      command.command :global do |subcommand|
+        subcommand.action do |_, _, arguments|
+          Application.new.configure_global(arguments)
+        end
+      end
+    end
+  end
+end
+
+exit AlpacaBuildTool::GliWrapper.run(ARGV)

data/features/alpaca.feature

@@ -0,0 +1,8 @@
+@windows @linux
+Feature: Alpaca app kinda works
+  In order to do anything with application I need to
+  be sure that it still runs ok
+
+  Scenario: App just runs
+    When I get help for "alpaca"
+    Then the exit status should be 0

data/features/step_definitions/alpaca_steps.rb

@@ -0,0 +1,13 @@
+When(/^I run "(.*?)"$/) do |command_line|
+  call = "#{prefix}#{command_line}"
+  @call_result = `#{call}`
+end
+
+When(/I get help for "(.*)"/) do |app_name|
+  @app_name = app_name
+  step %(I run "#{@app_name} help")
+end
+
+Then(/the exit status should be (.*)/) do |status|
+  expect($CHILD_STATUS.to_i).to eq status.to_i
+end

data/features/step_definitions/visual_studio_solutions_steps.rb

@@ -0,0 +1,47 @@
+Then(/^alpaca build file (.*?)$/) do |project_file|
+  proj = File.basename(project_file, '.*')
+  build_project = /#{proj} -> (.*?)\\#{project_file}/
+  expect(@call_result.match(build_project)).to_not be nil
+end
+
+Then(/^alpaca do not build file (.*?)$/) do |project_file|
+  proj = File.basename(project_file, '.*')
+  build_project = /#{proj} -> (.*?)\\#{project_file}/
+  expect(@call_result.match(build_project)).to be nil
+end
+
+Then(/^alpaca restore nuget packages for (.*?)$/) do |solution_file|
+  solution_dir = File.dirname(File.expand_path(solution_file))
+  nuget_call = /Nuget.exe restore #{File.expand_path(solution_file)}/
+  expect(@call_result.match(nuget_call)).to_not be nil
+  expect(Dir.glob(solution_dir + '/packages/*').count).to be > 0
+end
+
+Then(/^solution has failing unit test$/) do
+  # nothing to do here as there is failing unit test in solution 2
+  # step is used only as a marker in reports
+end
+
+Then(/^alpaca generate unit test results (.*?)$/) do |results_file|
+  expect(File.exist?(results_file)).to be true
+end
+
+Then(/^alpaca generate test coverage summary (.*?)$/) do |summary_file|
+  expect(File.exist?(summary_file)).to be true
+end
+
+Then(/^alpaca generate unit tests report (.*?)$/) do |report_file|
+  expect(File.exist?(report_file)).to be true
+end
+
+Then(/^alpaca generate coverage report (.*?)$/) do |index_file|
+  expect(File.exist?(index_file)).to be true
+end
+
+Then(/^alpaca creates (.*?)$/) do |package_file|
+  expect(File.exist?(package_file)).to be true
+end
+
+AfterStep('@teardown_changes') do
+  `git stash save --keep-index --include-untracked`
+end

data/features/support/env.rb

@@ -0,0 +1,10 @@
+require 'rbconfig'
+
+def prefix
+  case RbConfig::CONFIG['host_os']
+  when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+    'bundle exec ruby bin/'
+  else
+    'bin/'
+  end
+end

data/features/visual_studio_solutions.feature

@@ -0,0 +1,43 @@
+@windows
+Feature: Alpaca can work with Visual Studio solutions
+  In order to work with visual studio solutions I need to be sure
+  that alpaca can be used as a build tool for them
+
+  Scenario: Alpaca compile solution
+    When I run "alpaca compile"
+    And alpaca build file TestSolution.exe
+    And alpaca do not build file TestSolution.nobuild.exe
+    And alpaca restore nuget packages for test_data/sln2/SolutionName.sln
+    And alpaca build file ProjectName.dll
+    And alpaca build file ProjectName2.dll
+    And the exit status should be 0
+
+  Scenario: Alpaca test solution
+    When I run "alpaca test"
+    And solution has failing unit test
+    Then the exit status should be 256
+
+  Scenario: Alpaca test with coverage solution
+    When I run "alpaca test -c"
+    Then alpaca generate unit test results test_data/sln2/.tests/UnitTestsResult.xml
+    And alpaca generate test coverage summary test_data/sln2/.tests/coverage.xml
+    And the exit status should be 0
+
+  Scenario: Alpaca report tests results
+    When I run "alpaca report"
+    Then alpaca generate unit tests report test_data/sln2/.tests/UnitTestsResult.html
+    Then alpaca generate coverage report test_data/sln2/.tests/index.htm
+
+  Scenario: Alpaca pack solution
+    When I run "alpaca pack"
+    Then alpaca creates test_data/sln1/.output/TestData.FirstSolution.0.0.1-alpha.nupkg
+    Then alpaca creates test_data/sln1/.output/TestData.FirstSolution.0.0.1-alpha.symbols.nupkg
+    And alpaca creates test_data/sln2/.output/TestData.SecondSolution.2.0.11.nupkg
+    And alpaca creates test_data/sln2/.output/TestData.SecondSolution.2.0.11.symbols.nupkg
+    And the exit status should be 0
+
+  @teardown_changes
+  Scenario: Alpaca release package
+    When I run "alpaca -p '**/TestSolution.sln' release --no-push"
+    Then alpaca creates test_data/sln1/.output/TestData.FirstSolution.0.0.1.nupkg
+    And the exit status should be 0

data/lib/alpacabuildtool.rb

@@ -0,0 +1,4 @@
+require 'alpacabuildtool/application'
+require 'alpacabuildtool/versioning/versioning'
+
+# :main: README.rdoc

data/lib/alpacabuildtool/application.rb

@@ -0,0 +1,195 @@
+require 'alpacabuildtool/log/log'
+require 'alpacabuildtool/entities/solution'
+require 'alpacabuildtool/managers/build_manager'
+require 'alpacabuildtool/managers/package_manager'
+require 'alpacabuildtool/managers/test_manager'
+require 'alpacabuildtool/managers/report_manager'
+
+module AlpacaBuildTool
+  ##
+  # Application is a main entry point for CLI
+  class Application
+    include Log
+
+    ##
+    # Compiles solution [s]
+    #
+    # +pattern+:: pattern for solutions search
+    # +options+:: hash with compilation options
+    # <tt>options[:debug] = true</tt> is to compile solution in debug mode<br>
+    # <tt>options[:update_version] = true</tt> is to update project versions
+    # before compiling
+    #
+    #    app.compile('**/*.sln', debug: true, update_version: true)
+    #    # => building found solutions in debug mode
+    #    #    with updating project versions
+    def compile(pattern, options)
+      log.header 'Compile'
+      each_solution(pattern) do |solution|
+        build_manager = BuildManager.new(solution)
+        build_manager.build(options[:debug], options[:update_version])
+      end
+    end
+
+    ##
+    # Run tests for solution [s]
+    #
+    # +pattern+:: pattern for solutions search
+    # +options+:: hash with testing options
+    # <tt>options[:debug] = true</tt> is to run tests in debug mode<br>
+    # <tt>options[:coverage] = true</tt> is to run coverage<br>
+    # <tt>options[:type] = 'all'</tt> is to run 'all' test types
+    # ('all', 'unit', 'service')
+    #
+    #    app.test('**/*.sln', coverage: true, type: 'unit')
+    #    # => running unit tests with coverage
+    def test(pattern, options)
+      log.header 'Test'
+      each_solution(pattern) do |solution|
+        test_projects = solution.specific_projects(options[:type])
+        next log.info 'no tests discovered' if test_projects.empty?
+        test_manager = TestManager.new(solution)
+        test_manager.test(test_projects, options[:coverage], options[:debug])
+      end
+    end
+
+    ##
+    # Convert test results into reports for solution [s]
+    #
+    # +pattern+:: pattern for solutions search
+    # +options+:: hash with reporting options
+    # <tt>options[:type] = 'all'</tt> is to convert 'all' results into reports
+    # ('all', 'tests', 'coverage')
+    #
+    #    app.report('**/*.sln', type: 'coverage')
+    #    # => converting coverage results into html reports
+    def report(pattern, options)
+      log.header 'Report'
+      each_solution(pattern) do |solution|
+        report_manager = ReportManager.new(solution)
+        report_manager.convert(options[:type])
+      end
+    end
+
+    ##
+    # Create packages for solution [s]
+    #
+    # +pattern+:: pattern for solutions search
+    # +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
+    #
+    #    app.package('**/*.sln')
+    #    # => creating only packages with changes in release mode without
+    #    #    pushing them
+    def package(pattern, options)
+      log.header 'Package'
+      each_solution(pattern) do |solution|
+        version = solution.package_version
+        package_manager = PackageManager.new(solution)
+        (solution.configuration['packages'] || []).each do |package|
+          package_manager.create_package(package, version, options)
+        end
+      end
+    end
+
+    ##
+    # Release packages for solution [s]
+    #
+    # Updates .semver file to get release version if it is not release yet
+    # Rebuilds solution and create release package
+    # Changes are checked from last release package
+    #
+    # +pattern+:: pattern for solutions search
+    # +options+:: hash with releasing options
+    # <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
+    #
+    #    app.release('**/*.sln')
+    #    # => creating only packages with changes without pushing them
+    def release(pattern, options)
+      log.header 'Release'
+      each_solution(pattern) do |solution|
+        semver = Versioning.find(solution.dir)
+        semver.release if semver.prerelease?
+        Versioning.save semver
+      end
+      compile(pattern, debug: false, update_version: true)
+      test(pattern, {})
+      options[:debug] = false
+      package(pattern, options)
+    end
+
+    ##
+    # Update .semver files for solution [s]
+    #
+    # +pattern+:: pattern for solutions search
+    # +options+:: hash with releasing options
+    # <tt>options['dimension'] = :patch</tt> is to update version patch
+    # (major, minor, patch, prerelease)
+    #
+    #    app.update('**/*.sln', 'dimension' => :minor)
+    #    # => increase minor version in .semver by 1
+    def update(pattern, options)
+      log.header 'Update'
+      each_solution(pattern) do |solution|
+        semver = Versioning.find(solution.dir)
+        semver.increase(options['dimension'].to_sym)
+        Versioning.save semver
+      end
+    end
+
+    ##
+    # Update/create *~/.alpaca.conf*
+    #
+    # +properties+:: array of properties to store in global configuration
+    # in format node1.node2.property=value
+    #
+    #    app.configure_global(['hello.world=yay'])
+    #    # => produce yaml text in ~/.alpaca.conf:
+    #    #    hello:
+    #    #      world: yay
+    def configure_global(properties)
+      log.header 'Configure'
+      Configuration.set(properties)
+    end
+
+    ##
+    # Update/create *local configuration*
+    #
+    # +pattern+:: pattern for solutions search
+    # +properties+:: array of properties to store in global configuration
+    # in format node1.node2.property=value
+    #
+    #    app.configure_local('**/*.sln', ['hello.world=yay'])
+    #    # => produce yaml text in .alpaca.conf for each solution:
+    #    #    hello:
+    #    #      world: yay
+    def configure_local(pattern, properties)
+      log.header 'Configure'
+      Solutions.each(pattern) do |solution|
+        log.puts "saving configuration for #{solution.name}"
+        Configuration.new(solution).set(properties)
+      end
+    end
+
+    private
+
+    def each_solution(pattern)
+      Dir.glob(pattern).each do |file|
+        next unless File.file?(file) && file.end_with?('.sln')
+        solution = Solution.new(file)
+        log.puts solution
+        next log.info 'no build solution' if solution.no_build?
+        Dir.chdir(solution.dir) do
+          yield solution
+        end
+      end
+    end
+  end
+end