tinyci 0.4 → 0.5.1

data/lib/tinyci/executor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'tinyci/subprocesses'
 require 'tinyci/logging'
 require 'ostruct'
@@ -5,33 +7,33 @@ require 'erb'
 
 module TinyCI
   # Parent class for Builder and Tester classes
-  # 
+  #
   # @abstract
   class Executor
     include Subprocesses
     include Logging
-    
+
     # Returns a new instance of the executor.
-    # 
-    # @param config [Hash] Configuration hash, typically taken from relevant key in the {Config} object.
-    # @param logger [Logger] Logger object
-    def initialize(config, logger: nil)
+    #
+    # @param config [Hash] Configuration hash, typically taken
+    # from relevant key in the {Config} object.
+    def initialize(config)
       @config = config
-      @logger = logger
+      @logger = config[:logger]
     end
-    
+
     def command
       ['/bin/sh', '-c', "'#{interpolate(@config[:command])}'"]
     end
-    
+
     private
-    
+
     def interpolate(command)
       erb = ERB.new command
-      
+
       erb.result(erb_scope)
     end
-    
+
     def template_vars
       OpenStruct.new(
         commit: @config[:commit],

data/lib/tinyci/git_utils.rb

@@ -1,16 +1,17 @@
+# frozen_string_literal: true
+
 require 'tinyci/subprocesses'
+require 'git_clone_url'
 
 module TinyCI
-  
   # Methods for dealing with git repos.
   module GitUtils
-    
     # Returns the absolute path to the root of the current git directory
-    # 
+    #
     # @return [String] the path
     def repo_root
       return git_directory_path if inside_bare_repo?
-      
+
       if inside_git_directory?
         File.expand_path('..', git_directory_path)
       elsif inside_work_tree?
@@ -19,48 +20,116 @@ module TinyCI
         raise 'not in git directory or work tree!?'
       end
     end
-    
+
     # Are we currently under a git repo?
     def inside_git_directory?
       execute(git_cmd('rev-parse', '--is-inside-git-dir')) == 'true'
     end
-    
+
     # Are we under a bare repo?
     def inside_bare_repo?
       execute(git_cmd('rev-parse', '--is-bare-repository')) == 'true'
     end
-    
+
     # Are we currently under a git work tree?
     def inside_work_tree?
       execute(git_cmd('rev-parse', '--is-inside-work-tree')) == 'true'
     end
-    
+
     # Are we currently under a repo in any sense?
     def inside_repository?
-      execute(git_cmd('rev-parse', '--is-inside-work-tree', '--is-inside-git-dir')).split.any? {|s| s == 'true'}
+      cmd = git_cmd('rev-parse', '--is-inside-work-tree', '--is-inside-git-dir')
+      execute(cmd).split.any? { |s| s == 'true' }
     end
-    
+
     # Returns the absolute path to the .git directory
     def git_directory_path
-      File.expand_path(execute(git_cmd('rev-parse', '--git-dir')), defined?(@working_dir) ? @working_dir : nil)
+      base = defined?(@working_dir) ? @working_dir.to_s : nil
+
+      File.expand_path(execute(git_cmd('rev-parse', '--git-dir')), base)
+    end
+
+    # Does the specified file exist in the repo at the specified revision
+    def file_exists_in_git?(path, ref = @commit)
+      cmd = git_cmd('cat-file', '-e', "#{ref}:#{path}")
+
+      execute_and_return_status(cmd).success?
+    end
+
+    # Does the given sha exist in this repo's history?
+    def commit_exists?(commit = @commit)
+      cmd = git_cmd('cat-file', '-e', commit)
+
+      execute_and_return_status(cmd).success?
+    end
+
+    # Does the repo have a commit matching the given name?
+    def remote_exists?(remote = @remote)
+      execute(git_cmd('remote')).split("\n").include? remote
+    end
+
+    # Get the url for a given remote
+    # Alias for #push_url
+    def remote_url(remote = @remote)
+      push_url remote
     end
-    
+
+    # Does the given remote point to github?
+    def github_remote?(remote = @remote)
+      remote_url(remote).host == 'github.com'
+    end
+
+    # Does the given remote point to an ssh url?
+    def ssh_remote?(remote = @remote)
+      remote_url(remote).is_a? URI::SshGit::Generic
+    end
+
+    # Return the upstream remote for the current branch
+    def current_tracking_remote
+      full = execute git_cmd 'rev-parse', '--symbolic-full-name', '--abbrev-ref', '@{push}'
+      full.split('/')[0]
+    rescue TinyCI::Subprocesses::SubprocessError => e
+      log_error 'Current branch does not have an upstream remote' if e.status.exitstatus == 128
+    end
+
+    # The current HEAD branch
+    def current_branch
+      execute git_cmd 'rev-parse', '--abbrev-ref', 'HEAD'
+    end
+
+    # The push url for the specified remote, parsed into a `URI` object
+    def push_url(remote = @remote)
+      url = raw_push_url(remote)
+      GitCloneUrl.parse url
+    rescue URI::InvalidComponentError
+      URI.parse url
+    end
+
+    # Parse the commit time from git
+    def time
+      @time ||= Time.at execute(git_cmd('show', '-s', '--format=%at', @commit)).to_i
+    end
+
     # Execute a git command, passing the -C parameter if the current object has
     # the working_directory instance var set
     def git_cmd(*args)
       cmd = ['git']
-      cmd += ['-C', @working_dir] if defined?(@working_dir) && !@working_dir.nil?
+      cmd += ['-C', @working_dir.to_s] if defined?(@working_dir) && !@working_dir.nil?
       cmd += args
-      
+
       cmd
     end
-    
-    private
-    
+
+    # Get push url as a string. Not intended to be called directly, instead call {#push_url}
+    def raw_push_url(remote = @remote)
+      @push_urls ||= {}
+      @push_urls[remote] ||= execute git_cmd 'remote', 'get-url', '--push', remote
+    end
+
     def self.included(base)
       base.include Subprocesses
     end
-    
+
     def self.extended(base)
       base.extend Subprocesses
     end

data/lib/tinyci/hookers/script_hooker.rb

@@ -1,60 +1,59 @@
+# frozen_string_literal: true
+
 require 'tinyci/executor'
 
 module TinyCI
   module Hookers
     class ScriptHooker < TinyCI::Executor
       # All the hooks
-      HOOKS = %w{
+      HOOKS = %w[
         before_build
-        
+
         after_build_success
         after_build_failure
-        
+
         after_build
-        
+
         before_test
-        
+
         after_test_success
         after_test_failure
-        
+
         after_test
-        
+
         after_all
-      }
-      
+      ].freeze
+
       # Those hooks that will halt exectution if they fail
-      BLOCKING_HOOKS = %w{
+      BLOCKING_HOOKS = %w[
         before_build
         before_test
-      }
-      
+      ].freeze
+
       HOOKS.each do |hook|
-        define_method hook+"_present?" do
+        define_method hook + '_present?' do
           @config.key? hook.to_sym
         end
-        
-        define_method hook+"!" do
+
+        define_method hook + '!' do
           return unless send("#{hook}_present?")
-          
+
           log_info "executing #{hook} hook..."
           begin
             execute_stream(script_location(hook), label: hook, pwd: @config[:export])
-            
+
             return true
           rescue SubprocessError => e
-            if BLOCKING_HOOKS.include? hook
-              raise e if ENV['TINYCI_ENV'] == 'test'
-              
-              log_error e
-              
-              return false
-            else
-              return true
-            end
+            return true unless BLOCKING_HOOKS.include? hook
+
+            raise e if ENV['TINYCI_ENV'] == 'test'
+
+            log_error e
+            return false
           end
         end
       end
-      
+
       def script_location(hook)
         ['/bin/sh', '-c', "'#{interpolate(@config[hook.to_sym])}'"]
       end

data/lib/tinyci/installer.rb

@@ -1,56 +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)
+    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
 
-#{Gem.bin_path('tinyci', 'tinyci')} 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