tinyci 0.4.2 → 0.5

data/lib/tinyci/installer.rb

@@ -1,61 +1,63 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 require 'tinyci/git_utils'
 
 module TinyCI
-  
   # Responsible for writing the git hook file
   class Installer
     include GitUtils
-    
+
     # Constructor
-    # 
-    # @param [String] working_dir The directory from which to run. Does not have to be the root of the repo
+    #
+    # @param [String] working_dir The directory from which to run. Does not have to be the
+    # root of the repo.
     # @param [Logger] logger Logger object
     def initialize(working_dir: nil, logger: nil, absolute_path: false)
       @logger = logger
       @working_dir = working_dir || repo_root
       @absolute_path = absolute_path
     end
-    
+
     # Write the hook to the relevant path and make it executable
     def install!
       unless inside_repository?
-        log_error "not currently in a git repository"
+        log_error 'not currently in a git repository'
         return false
       end
-      
+
       if hook_exists?
-        log_error "post-update hook already exists in this repository"
+        log_error 'post-update hook already exists in this repository'
         return false
       end
-      
-      File.open(hook_path, 'a') {|f| f.write hook_content}
+
+      File.open(hook_path, 'a') { |f| f.write hook_content }
       FileUtils.chmod('u+x', hook_path)
-      
+
       log_info 'tinyci post-update hook installed successfully'
     end
-    
+
     private
-    
+
     def hook_exists?
       File.exist? hook_path
     end
-    
+
     def hook_path
       File.expand_path('hooks/post-update', git_directory_path)
     end
-    
+
     def bin_path
       @absolute_path ? Gem.bin_path('tinyci', 'tinyci') : 'tinyci'
     end
-    
+
     def hook_content
-      <<-EOF
-#!/bin/sh
-unset GIT_DIR
+      <<~HOOK
+        #!/bin/sh
+        unset GIT_DIR
 
-#{bin_path} run --all
-      EOF
+        #{bin_path} run --all
+      HOOK
     end
   end
 end

data/lib/tinyci/log_viewer.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'tinyci/path_utils'
+require 'tinyci/git_utils'
+require 'file-tail'
+
+module TinyCI
+  # For reviewing the log files created by tinyCI runs. Can print lines from either a specific
+  # commit's logfile, or from the global logfile. Has functionality similar to the coreutils `tail`
+  # command.
+  class LogViewer
+    include PathUtils
+    include GitUtils
+
+    #
+    # Constructor
+    #
+    # @param [<Type>] working_dir  The directory from which to run.
+    # @param [<Type>] commit The commit to run against
+    # @param [<Type>] follow After printing, instead of exiting, block and wait for additional data to be appended be the file and print it as it
+    #   is written. Equivalent to unix `tail -f`
+    # @param [<Type>] num_lines How many lines of the file to print, starting from the end.
+    # Equivalent to unix `tail -n`
+    #
+    def initialize(working_dir:, commit: nil, follow: false, num_lines: nil)
+      @working_dir = working_dir
+      @commit = commit
+      @follow = follow
+      @num_lines = num_lines
+    end
+
+    def view!
+      if @follow
+        tail
+      else
+        dump
+      end
+    end
+
+    private
+
+    def dump
+      unless inside_repository?
+        warn 'Error: Not currently inside a git repo, or not on a branch'
+        return false
+      end
+
+      unless logfile_exists?
+        warn "Error: Logfile does not exist at #{logfile_to_read}"
+        warn "Did you mean \e[1mtinyci --remote #{current_tracking_remote} log\e[22m?"
+        return false
+      end
+
+      if @num_lines.nil?
+        puts File.read(logfile_to_read)
+      else
+        File.open(logfile_to_read) do |log|
+          log.extend File::Tail
+          log.return_if_eof = true
+          log.backward @num_lines if @num_lines
+          log.tail { |line| puts line }
+        end
+      end
+    end
+
+    def tail
+      File.open(logfile_to_read) do |log|
+        log.extend(File::Tail)
+
+        log.backward @num_lines if @num_lines
+        log.tail { |line| puts line }
+      end
+    end
+
+    def logfile_to_read
+      if @commit
+        logfile_path
+      else
+        repo_logfile_path
+      end
+    end
+
+    def logfile_exists?
+      File.exist? logfile_to_read
+    end
+  end
+end

data/lib/tinyci/logging.rb

@@ -1,16 +1,16 @@
+# frozen_string_literal: true
+
 require 'tinyci/multi_logger'
 
 module TinyCI
   # Defines helper instance methods for logging to reduce code verbosity
   module Logging
-    
-    %w(log debug info warn error fatal unknown).each do |m|
+    %w[log debug info warn error fatal unknown].each do |m|
       define_method("log_#{m}") do |*args|
         return false unless defined?(@logger) && @logger.is_a?(MultiLogger)
-        
+
         @logger.send(m, *args)
       end
-    end  
-    
+    end
   end
 end

data/lib/tinyci/multi_logger.rb

@@ -1,48 +1,57 @@
+# frozen_string_literal: true
+
 require 'logger'
+require 'fileutils'
 
 module TinyCI
   # This class allows logging to both `STDOUT` and to a file with a single call.
   # @attr [Boolean] quiet Disables logging to STDOUT
   class MultiLogger
-    FORMAT = Proc.new do |severity, datetime, progname, msg|
-      "[#{datetime.strftime "%T"}] #{msg}\n"
+    FORMAT = proc do |_severity, datetime, _progname, msg|
+      "[#{datetime.strftime '%T'}] #{msg}\n"
     end
-    
+
     LEVEL = Logger::INFO
-    
+
     attr_accessor :quiet
-    
+
     # Constructor
-    # 
+    #
     # @param [Boolean] quiet Disables logging to STDOUT
     # @param [String] path Location to write logfile to
-    def initialize(quiet: false, path: nil)
-      @file_logger = nil
-      self.output_path = path
+    def initialize(quiet: false, path: nil, paths: [])
+      @file_loggers = []
+      add_output_path path
+      paths.each { |p| add_output_path(p) }
       @quiet = quiet
-      
+
       @stdout_logger = Logger.new($stdout)
       @stdout_logger.formatter = FORMAT
       @stdout_logger.level = LEVEL
     end
-    
+
     def targets
       logs = []
-      logs << @file_logger if @file_logger
+      logs += @file_loggers
       logs << @stdout_logger unless @quiet
-      
+
       logs
     end
-    
-    def output_path=(path)
-      if path
-        @file_logger = Logger.new(path)
-        @file_logger.formatter = FORMAT
-        @file_logger.level = LEVEL
-      end
+
+    def add_output_path(path)
+      return unless path
+
+      FileUtils.touch path
+
+      logger = Logger.new(path)
+      logger.formatter = FORMAT
+      logger.level = LEVEL
+      @file_loggers << logger
+
+      logger
     end
 
-    %w(log debug info warn error fatal unknown).each do |m|
+    %w[log debug info warn error fatal unknown].each do |m|
       define_method(m) do |*args|
         targets.each { |t| t.send(m, *args) }
       end

data/lib/tinyci/path_utils.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'tinyci/subprocesses'
+require 'tinyci/git_utils'
+require 'fileutils'
+
+module TinyCI
+  # Methods for computing paths.
+  module PathUtils
+    def builds_path
+      File.absolute_path("#{@working_dir}/builds")
+    end
+
+    # Build the absolute target path
+    def target_path
+      File.join(builds_path, "#{time.to_i}_#{@commit}")
+    end
+
+    # Build the export path
+    def export_path
+      File.join(target_path, 'export')
+    end
+
+    private
+
+    def logfile_path
+      File.join(target_path, 'tinyci.log')
+    end
+
+    def repo_logfile_path
+      File.join(builds_path, 'tinyci.log')
+    end
+
+    # Ensure a path exists
+    def ensure_path(path)
+      FileUtils.mkdir_p path
+    end
+
+    def self.included(base)
+      base.include TinyCI::Subprocesses
+      base.include TinyCI::GitUtils
+    end
+  end
+end

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