tinyci 0.4.2 → 0.5

data/lib/tinyci/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'tinyci/config_transformer'
 require 'tinyci/symbolize'
 require 'yaml'
@@ -6,60 +8,57 @@ module TinyCI
   # Represents the Configuration for a repo, parsed from the `.tinyci.yml` file in the repo root.
   # Mainly a wrapper around a the hash object parsed from the yaml in the config file.
   # The keys of the hash are recursively symbolized.
-  # 
+  #
   # As it is loaded, the configuration file data is passed through the {TinyCI::ConfigTransformer}
   # class, which translates any definitions in the concise format into the more verbose format
   class Config
     include Symbolize
-    
+
+    attr_accessor :config_path
+
     # Constructor
-    # 
+    #
     # @param [String] working_dir The working directory in which to find the config file
     # @param [String] config_path Override the path to the config file
     # @param [String] config Override the config content
-    # 
+    #
     # @raise [ConfigMissingError] if the config file is not found
-    def initialize(working_dir: '.', config_path: nil, config: nil)
-      @working_dir = working_dir
-      @config_pathname = config_path
+    def initialize(config_path, config: nil)
+      @config_path = config_path
       @config_content = config
-      
-      raise ConfigMissingError, "config file #{config_pathname} not found" unless config_file_exists?
+
+      raise ConfigMissingError, "config file #{config_path} not found" unless config_file_exists?
     end
-    
+
     # Address into the config object
-    # 
+    #
     # @param [Symbol] key The key to address
     def [](key)
       config_content[key]
     end
-    
+
     # Return the raw hash representation
-    # 
+    #
     # @return [Hash] The configuration as a hash
     def to_hash
       config_content
     end
-    
+
     private
-    
+
     def config_file_exists?
-      File.exist? config_pathname
-    end
-    
-    def config_pathname
-      @config_pathname || File.expand_path('.tinyci.yml', @working_dir)
+      File.exist? config_path
     end
-    
+
     def config_content
       @config_content ||= begin
-        config = YAML.safe_load(File.read(config_pathname))
+        config = YAML.safe_load(File.read(config_path))
         transformed_config = ConfigTransformer.new(config).transform!
         symbolize(transformed_config).freeze
       end
     end
   end
-    
+
   # Error raised when the config file cannot be found
   class ConfigMissingError < StandardError; end
 end

data/lib/tinyci/config_transformer.rb

@@ -1,61 +1,59 @@
+# frozen_string_literal: true
+
 module TinyCI
   # Transforms the configuration format from the condensed format to the
   # more verbose format accepted by the rest of the system
   class ConfigTransformer
-    
     # Constructor
-    # 
+    #
     # @param [Hash] input The configuration object, in the condensed format
     def initialize(input)
       @input = input
     end
-    
+
     # Transforms the config object
-    # 
+    #
     # @return [Hash] The config object in the verbose form
     def transform!
-      @input.inject({}) do |acc, (key, value)|
+      @input.each_with_object({}) do |(key, value), acc|
         method_name = "transform_#{key}"
-        
+
         if respond_to? method_name, true
-          
           acc.merge! send(method_name, value)
         else
           acc[key] = value
         end
-        
-        acc
       end
     end
-    
+
     private
-    
+
     def transform_build(value)
       {
         builder: {
-          :class => "ScriptBuilder",
+          class: 'ScriptBuilder',
           config: {
             command: value
           }
         }
       }
     end
-    
+
     def transform_test(value)
       {
         tester: {
-          :class => "ScriptTester",
+          class: 'ScriptTester',
           config: {
             command: value
           }
         }
       }
     end
-    
+
     def transform_hooks(value)
       {
         hooker: {
-          :class => "ScriptHooker",
+          class: 'ScriptHooker',
           config: value
         }
       }

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