tinyci 0.4 → 0.5.1

data/lib/tinyci/runner.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'tinyci/subprocesses'
 require 'tinyci/git_utils'
+require 'tinyci/path_utils'
 require 'tinyci/logging'
 require 'tinyci/config'
 
@@ -14,178 +17,191 @@ require 'fileutils'
 
 module TinyCI
   # Responsible for managing the running of TinyCI against a single git object.
-  # 
-  # @attr builder [TinyCI::Executor] Returns the Builder object. Used solely for testing at this time.
-  # @attr tester [TinyCI::Executor] Returns the Tester object. Used solely for testing at this time.
+  #
+  # @attr builder [TinyCI::Executor] Returns the Builder object. Used solely for testing.
+  # @attr tester [TinyCI::Executor] Returns the Tester object. Used solely for testing.
   class Runner
     include Subprocesses
     include GitUtils
+    include PathUtils
     include Logging
-    
+
+    CONFIG_FILENAME = '.tinyci.yml'
+
     attr_accessor :builder, :tester, :hooker
-    
+
     # Constructor, allows injection of generic configuration params.
-    # 
+    #
     # @param working_dir [String] The working directory to execute against.
     # @param commit [String] SHA1 of git object to run against
     # @param logger [Logger] Logger object
-    # @param time [Time] Override time of object creation. Used solely for testing at this time.
-    # @param config [Hash] Override TinyCI config object, normally loaded from `.tinyci` file. Used solely for testing at this time.
+    # @param time [Time] Override time of object creation. Used solely for testing.
+    # @param config [Hash] Override TinyCI config object, normally loaded from `.tinyci` file.
+    # Used solely for testing.
     def initialize(working_dir: '.', commit:, time: nil, logger: nil, config: nil)
       @working_dir = working_dir
-      @logger = logger
       @config = config
       @commit = commit
-      @time = time || commit_time
+      @time = time
+      @logger = logger.is_a?(MultiLogger) ? MultiLogger.new(quiet: logger.quiet) : nil
+      ensure_path target_path
+      setup_log
     end
-    
+
     # Runs the TinyCI system against the single git object referenced in `@commit`.
-    # 
+    #
     # @return [Boolean] `true` if the commit was built and tested successfully, `false` otherwise
+    # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity
     def run!
       begin
-        ensure_path target_path
-        setup_log
-        
         log_info "Commit: #{@commit}"
-        
-        log_info "Cleaning..."
+
+        unless config_exists?
+          log_error "No config found for #{@commit}"
+
+          return false
+        end
+
+        log_info 'Cleaning...'
         clean
-        
-        log_info "Exporting..."
+
+        log_info 'Exporting...'
         ensure_path export_path
         export
-        
+
         begin
-          load_config
+          config
         rescue ConfigMissingError => e
           log_error e.message
           log_error 'Removing export...'
           clean
-          
+
           return false
         end
         @builder ||= instantiate_builder
         @tester  ||= instantiate_tester
         @hooker  ||= instantiate_hooker
-        
-        log_info "Building..."
+
+        log_info 'Building...'
         run_hook! :before_build
         begin
           @builder.build
-        rescue => e
+        rescue StandardError => e
           run_hook! :after_build_failure
-          
+
           raise e if ENV['TINYCI_ENV'] == 'test'
-          
+
           log_error e
           log_debug e.backtrace
-          
+
           return false
         else
           run_hook! :after_build_success
         ensure
           run_hook! :after_build
         end
-        
-        
-        log_info "Testing..."
+
+        log_info 'Testing...'
         run_hook! :before_test
         begin
           @tester.test
-        rescue => e
+        rescue StandardError => e
           run_hook! :after_test_failure
-          
+
           raise e if ENV['TINYCI_ENV'] == 'test'
-          
+
           log_error e
           log_debug e.backtrace
-          
+
           return false
         else
           run_hook! :after_test_success
         ensure
           run_hook! :after_test
         end
-        
+
         log_info "Finished #{@commit}"
-      rescue => e
+      rescue StandardError => e
         raise e if ENV['TINYCI_ENV'] == 'test'
-        
+
         log_error e
         log_debug e.backtrace
         return false
       ensure
         run_hook! :after_all
       end
-      
+
       true
     end
-    
-    # Build the absolute target path
-    def target_path
-      File.absolute_path("#{@working_dir}/builds/#{@time.to_i}_#{@commit}/")
-    end
-    
-    # Build the export path
-    def export_path
-      File.join(target_path, 'export')
-    end
-    
+    # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity
+
     private
-    
+
     def run_hook!(name)
       return unless @hooker
-      
+
       @hooker.send("#{name}!")
     end
-    
+
     # Creates log file if it doesnt exist
     def setup_log
       return unless @logger.is_a? MultiLogger
-      FileUtils.touch logfile_path
-      @logger.output_path = logfile_path
-    end
-    
-    def logfile_path
-      File.join(target_path, 'tinyci.log')
+
+      @logger.add_output_path logfile_path
+      @logger.add_output_path repo_logfile_path
     end
-    
+
     # Instantiate the Builder object according to the class named in the config
     def instantiate_builder
       klass = TinyCI::Builders.const_get(@config[:builder][:class])
-      klass.new(@config[:builder][:config].merge(target: target_path, export: export_path, commit: @commit), logger: @logger)
+      konfig = @config[:builder][:config].merge(
+        target: target_path,
+        export: export_path,
+        commit: @commit,
+        logger: @logger
+      )
+      klass.new(konfig)
     end
-    
+
     # Instantiate the Tester object according to the class named in the config
     def instantiate_tester
       klass = TinyCI::Testers.const_get(@config[:tester][:class])
-      klass.new(@config[:tester][:config].merge(target: target_path, export: export_path, commit: @commit), logger: @logger)
+      konfig = @config[:tester][:config].merge(
+        target: target_path,
+        export: export_path,
+        commit: @commit,
+        logger: @logger
+      )
+      klass.new(konfig)
     end
-    
+
     # Instantiate the Hooker object according to the class named in the config
     def instantiate_hooker
       return nil unless @config[:hooker].is_a? Hash
-      
+
       klass = TinyCI::Hookers.const_get(@config[:hooker][:class])
-      klass.new(@config[:hooker][:config].merge(target: target_path, export: export_path, commit: @commit), logger: @logger)
+      konfig = @config[:hooker][:config].merge(
+        target: target_path,
+        export: export_path,
+        commit: @commit,
+        logger: @logger
+      )
+      klass.new(konfig)
     end
-    
-    # Instantiate the {Config} object from the `.tinyci.yml` file in the exported directory
-    def load_config
-      @config ||= Config.new(working_dir: export_path)
+
+    def config_path
+      File.expand_path(CONFIG_FILENAME, export_path)
     end
 
-    # Parse the commit time from git
-    def commit_time
-      Time.at execute(git_cmd('show', '-s', '--format=%ct', @commit)).to_i
+    def config_exists?
+      file_exists_in_git? CONFIG_FILENAME
     end
 
-    # Ensure a path exists
-    def ensure_path(path)
-      execute 'mkdir', '-p', path
+    # The {Config} object from the `.tinyci.yml` file in the exported directory
+    def config
+      @config ||= Config.new(config_path)
     end
-    
+
     # Delete the export path
     def clean
       FileUtils.rm_rf export_path
@@ -196,7 +212,8 @@ module TinyCI
     # a `git export` subcommand.
     # see https://stackoverflow.com/a/163769
     def export
-      execute_pipe git_cmd('archive', '--format=tar', @commit), ['tar', '-C', export_path, '-xf', '-']
+      execute_pipe git_cmd('archive', '--format=tar',
+                           @commit), ['tar', '-C', export_path, '-xf', '-']
     end
   end
 end

data/lib/tinyci/scheduler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'tinyci/runner'
 require 'tinyci/subprocesses'
 require 'tinyci/git_utils'
@@ -7,82 +9,82 @@ module TinyCI
   # Manages the execution of test jobs. Responsible for deciding which
   # commits need to be built and tested. Also manages the pidfile. This
   # is the main entrypoint for TinyCI.
-  # 
+  #
   # @attr_reader [String] working_dir The working directory to execute against
   class Scheduler
     include Subprocesses
     include Logging
     include GitUtils
-    
+
     attr_reader :working_dir
-    
+
     # Constructor, allows injection of configuration and custom {Runner} class.
     # Config params are passed to {Runner} instances.
-    # 
+    #
     # @param working_dir [String] The working directory to execute against
     # @param logger [Logger] Logger object
     # @param commit [String] specific git object to run against
     # @param runner_class [TinyCI::Runner] Injection of {Runner} dependency
     def initialize(
-        working_dir: nil,
-        logger: nil,
-        commit: nil,
-        runner_class: Runner
-      )
-    
+      working_dir: nil,
+      logger: nil,
+      commit: nil,
+      runner_class: Runner
+    )
+
       @working_dir = working_dir || repo_root
       @logger = logger
       @runner_class = runner_class
       @commit = commit
     end
-    
+
     # Runs the TinyCI system against the relevant commits. Also sets up the pidfile.
-    # 
+    #
     # @return [Boolean] `true` if all commits built and tested successfully, `false` otherwise
     def run!
       pid = PidFile.new(pidfile: 'tinyci.pid', piddir: @working_dir)
-      
+
       result = if @commit
-        run_commit get_commit @commit
-      else
-        run_all_commits
-      end
-      
+                 run_commit get_commit @commit
+               else
+                 run_all_commits
+               end
+
       pid.release
-      
+
       result
     end
-    
+
     private
-    
+
     # Git objects to be executed against, all those without a tinyci tag
-    # 
+    #
     # @return [Array<String>] the sha1 hashes in reverse order of creation time
-    def get_commits
+    def retrieve_commits
       log = execute(git_cmd('log', '--notes=tinyci*', '--format=%H %ct %N§§§', '--reverse'))
-      lines = log.split("§§§")
-      
-      lines.map {|l| format_commit_data(l)}.select {|c| c[:result].nil?}
+      lines = log.split('§§§')
+
+      lines.map { |l| format_commit_data(l) }.select { |c| c[:result].nil? }
     end
-    
+
     def get_commit(sha)
-      data = execute(git_cmd('show', '--quiet', '--notes=tinyci*', "--format=%H %ct", sha))
-      
+      data = execute(git_cmd('show', '--quiet', '--notes=tinyci*', '--format=%H %ct', sha))
+
       format_commit_data(data)
     end
-    
+
     # Instantiates {Runner} for a given git object, runs it, and stores the result
     def run_commit(commit)
       result = @runner_class.new(
-        working_dir: @working_dir,                           
+        working_dir: @working_dir,
         commit: commit[:sha],
         time: commit[:time],
         logger: @logger
       ).run!
-      
+
       set_result(commit, result)
     end
-    
+
     def format_commit_data(data)
       parts = data.split(' ')
       {
@@ -91,22 +93,22 @@ module TinyCI
         result: parts[2]
       }
     end
-    
+
     # Repeatedly gets the list of eligable commits and runs TinyCI against them until there are no more remaining
     def run_all_commits
-      commits = get_commits
-      
-      until commits.empty? do
-        commits.each {|c| run_commit(c)}
-        
-        commits = get_commits
+      commits = retrieve_commits
+
+      until commits.empty?
+        commits.each { |c| run_commit(c) }
+
+        commits = retrieve_commits
       end
     end
-    
+
     # Stores the result in a git note
     def set_result(commit, result)
       result_message = result ? 'success' : 'failure'
-      
+
       execute git_cmd('notes', '--ref', 'tinyci-result', 'add', '-m', result_message, commit[:sha])
     end
   end

data/lib/tinyci/subprocesses.rb

@@ -1,44 +1,48 @@
+# frozen_string_literal: true
+
 require 'open3'
+require 'English'
 require 'tinyci/logging'
 
 module TinyCI
   # Methods for executing subprocesses in various ways and collecting the results.
   module Subprocesses
-    
     # Synchronously execute a command as a subprocess and return the output.
-    # 
+    #
     # @param [Array<String>] command The command line
     # @param [String] label A label for debug and logging purposes
-    # 
+    #
     # @return [String] The output of the command
     # @raise [SubprocessError] if the subprocess returns status > 0
     def execute(*command, label: nil)
-      output, status = Open3.capture2(*command.flatten)
-      
+      stdout, stderr, status = Open3.capture3(*command.flatten)
+
       log_debug caller[0]
       log_debug "CMD: #{command.join(' ')}"
-      log_debug "OUT: #{output}"
-      
+      log_debug "OUT: #{stdout}"
+      log_debug "ERR: #{stderr}"
+
       unless status.success?
-        log_error output
+        log_error stdout
+        log_error stderr
         raise SubprocessError.new(label, command.join(' '), status)
       end
-      
-      output.chomp
+
+      stdout.chomp
     end
-    
+
     # Synchronously execute a chain multiple commands piped into each other as a
     # subprocess and return the output.
-    # 
+    #
     # @param [Array<Array<String>>] commands The command lines
     # @param [String] label A label for debug and logging purposes
-    # 
+    #
     # @return [String] The output of the command
     # @raise [SubprocessError] if the subprocess returns status > 0
     def execute_pipe(*commands, label: nil)
       stdout, waiters = Open3.pipeline_r(*commands)
       output = stdout.read
-      
+
       waiters.each_with_index do |waiter, i|
         status = waiter.value
         unless status.success?
@@ -46,67 +50,72 @@ module TinyCI
           raise SubprocessError.new(label, commands[i].join(' '), status)
         end
       end
-      
+
       output.chomp
     end
-    
+
     # Synchronously execute a command as a subprocess and and stream the output
     # to `STDOUT`
-    # 
+    #
     # @param [Array<String>] command The command line
     # @param [String] label A label for debug and logging purposes
     # @param [String] pwd Optionally specify a different working directory in which to execute the command
-    # 
+    #
     # @return [TrueClass] `true` if the command executed successfully
     # @raise [SubprocessError] if the subprocess returns status > 0
     def execute_stream(*command, label: nil, pwd: nil)
       opts = {}
       opts[:chdir] = pwd unless pwd.nil?
-      
+
       log_debug "CMD: #{command.join(' ')}"
-      
+
       Open3.popen2e(command.join(' '), opts) do |stdin, stdout_and_stderr, wait_thr|
         stdin.close
-        
+
         until stdout_and_stderr.closed? || stdout_and_stderr.eof?
           line = stdout_and_stderr.gets
           log_info line.chomp
           $stdout.flush
         end
-        
-        unless wait_thr.value.success?  
+
+        unless wait_thr.value.success?
           raise SubprocessError.new(label, command.join(' '), wait_thr.value)
         end
+
+      ensure
         stdout_and_stderr.close
       end
-      
+
       true
     end
-    
+
+    def execute_and_return_status(command)
+      system(*command, out: File::NULL, err: File::NULL)
+
+      $CHILD_STATUS
+    end
+
     # An error raised when any of the {Subprocesses} methods fail
-    # 
+    #
     # @attr_reader [Integer] status The return code of the process
     # @attr_reader [String] command The command used to spawn the process
     class SubprocessError < RuntimeError
       attr_reader :status
       attr_reader :command
-      
+
       def initialize(label, command, status, message = "#{label}: `#{command}` failed with status #{status.exitstatus}")
         @status = status
         @command = command
         super(message)
       end
     end
-    
-    private 
-    
+
     def self.included(base)
       base.include TinyCI::Logging
     end
-    
+
     def self.extended(base)
       base.extend TinyCI::Logging
     end
-    
   end
 end

data/lib/tinyci/symbolize.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TinyCI
   module Symbolize
     # recursively make all keys of `hash` into symbols
@@ -7,7 +9,7 @@ module TinyCI
         hash.each { |key, value| h[key.to_sym] = map_value(value) }
       end
     end
-    
+
     def map_value(thing)
       case thing
       when Hash

data/lib/tinyci/testers/script_tester.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'tinyci/executor'
 
 module TinyCI

data/lib/tinyci/testers/test_tester.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'tinyci/executor'
 
 module TinyCI

data/lib/tinyci/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TinyCI
-  VERSION = "0.4"
+  VERSION = '0.5.1'
 end

data/lib/yard_plugin.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'redcarpet'
 
 # This file fixes the mismatch between how github handles links to other
@@ -27,7 +29,13 @@ class CompatMarkdown
 
   def initialize(text)
     renderer = YARD::Templates::Helpers::HtmlHelper::MDLinkRenderer.new
-    markdown = Redcarpet::Markdown.new(renderer, no_intra_emphasis: true, gh_blockcode: true, fenced_code_blocks: true, autolink: true)
+    opts = {
+      no_intra_emphasis: true,
+      gh_blockcode: true,
+      fenced_code_blocks: true,
+      autolink: true
+    }
+    markdown = Redcarpet::Markdown.new(renderer, opts)
     @to_html = markdown.render(text)
   end
 end