rabbitt-githooks 1.3.2 → 1.4.1

data/lib/githooks/hook.rb

@@ -22,7 +22,7 @@ require_relative 'system_utils'
 
 module GitHooks
   class Hook
-    VALID_PHASES = %w{ pre-commit commit-msg }.freeze
+    VALID_PHASES = %w{ pre-commit commit-msg }.freeze unless defined? VALID_PHASES
 
     @__phases__ = {}
     @__mutex__  = Mutex.new
@@ -61,19 +61,19 @@ module GitHooks
       end
     end
 
-    attr_reader :sections, :phase, :repository, :repository_path
+    attr_reader :sections, :phase, :repository, :repository_path, :limiters
     attr_accessor :args, :staged, :untracked, :tracked
 
     def initialize(phase)
-      @phase     = phase.to_s
-      @sections  = {}
-      @commands  = []
-      @args      = []
-      @staged    = true
-      @tracked   = false
-      @untracked = false
-
-      repository_path = Dir.getwd # rubocop:disable UselessAssignment
+      @phase      = phase.to_s
+      @sections   = {}
+      @limiters   = {}
+      @commands   = []
+      @args       = []
+      @staged     = true
+      @tracked    = false
+      @untracked  = false
+      @repository = Repository.new(Dir.getwd)
     end
 
     def [](name)
@@ -117,6 +117,29 @@ module GitHooks
 
     # DSL methods
 
+    def config_path
+      GitHooks.hooks_root.join('configs')
+    end
+
+    def config_file(*path_components)
+      config_path.join(*path_components)
+    end
+
+    def lib_path
+      GitHooks.hooks_root.join('lib')
+    end
+
+    def lib_file(*path_components)
+      lib_path.join(*path_components)
+    end
+
+    def limit(type)
+      unless @limiters.include? type
+        @limiters[type] ||= Repository::Limiter.new(type)
+      end
+      @limiters[type]
+    end
+
     def command(name, options = {})
       setup_command name, options
     end
@@ -160,8 +183,8 @@ module GitHooks
 
       def filter(limiters)
         manifest.dup.tap do |files|
-          limiters.each do |limiter|
-            puts "Limiter [#{limiter.type}] -> (#{limiter.only.inspect}) match against: " if GitHooks.debug?
+          limiters.each do |type, limiter|
+            puts "Limiter [#{type}] -> (#{limiter.only.inspect}) match against: " if GitHooks.debug?
             limiter.limit(files)
           end
         end

data/lib/githooks/repository/config.rb

@@ -133,7 +133,7 @@ module GitHooks
     private
 
       def repo_path
-        @repository.root_path
+        @repository.path
       end
 
       def git(*args)

data/lib/githooks/repository/diff_index_entry.rb

@@ -18,8 +18,8 @@ module GitHooks
 
       def self.from_file_path(path, tracked = false)
         path = Pathname.new(path)
-        entry_line = sprintf(":%06o %06o %040x %040x %s\t%s",
-                             0, path.stat.mode, 0, 0, (tracked ? '^' : '?'), path.to_s)
+        entry_line = format(":%06o %06o %040x %040x %s\t%s",
+                            0, path.stat.mode, 0, 0, (tracked ? '^' : '?'), path.to_s)
         new(entry_line)
       end
 

data/lib/githooks/repository.rb

@@ -59,15 +59,17 @@ module GitHooks
       instance.public_send(method, *args, &block)
     end
 
-    attr_reader :root_path
+    attr_reader :path, :hooks
+    alias_method :path, :path
 
     def initialize(path = Dir.getwd)
-      @root_path = get_root_path(path)
+      @path  = get_root_path(path)
+      @hooks = Pathname.new(@path).join('.git', 'hooks')
     end
     protected :initialize
 
     def config
-      @config ||= Repository::Config.new(root_path)
+      @config ||= Repository::Config.new(path)
     end
 
     def get_root_path(path)
@@ -140,10 +142,13 @@ module GitHooks
         cmd << (options.delete(:ref) || 'HEAD')
       end
 
-      git(*cmd.compact.compact).output_lines.collect do |diff_data|
+      git(*cmd.flatten.compact).output_lines.collect do |diff_data|
         DiffIndexEntry.new(diff_data).to_repo_file
       end
-    rescue
+    rescue StandardError => e
+      puts 'Error Encountered while acquiring manifest'
+      puts "Command: git #{cmd.flatten.compact.join(' ')}"
+      puts "Error: #{e.class.name}: #{e.message}: #{e.backtrace[0..5].join("\n\t")}"
       exit! 1
     end
 

data/lib/githooks/runner.rb

@@ -27,75 +27,68 @@ require_relative 'repository'
 require_relative 'system_utils'
 
 module GitHooks
-  module Runner
-    # rubocop:disable CyclomaticComplexity, MethodLength, AbcSize, PerceivedComplexity
-    def run(options = {})
-      options = Thor::CoreExt::HashWithIndifferentAccess.new(options)
-
-      options['staged'] = options['staged'].nil? ? true : options['staged']
+  class Runner # rubocop:disable Metrics/ClassLength
+    attr_reader :repository, :script, :hook_path, :repo_path, :options
+    private :repository, :script, :hook_path, :repo_path, :options
 
-      repo    = options['repo']   ||= Repository.root_path
-      script  = options['script'] ||= Repository.instance(repo).config.script
-      libpath = options['path']   ||= Repository.instance(repo).config.path
-      args    = options['args']   ||= []
+    def initialize(options = {}) # rubocop:disable Metrics/AbcSize
+      @repo_path  = Pathname.new(options.delete('repo') || Repository.path)
+      @repository = Repository.instance(@repo_path)
+      @hook_path  = acquire_hooks_path(options.delete('path') || @repository.config.path || @repository.path)
+      @script     = options.delete('script') || @repository.config.script
+      @options    = IndifferentAccessOpenStruct.new(options)
 
       GitHooks.verbose = !!ENV['GITHOOKS_VERBOSE']
       GitHooks.debug   = !!ENV['GITHOOKS_DEBUG']
+    end
 
-      if options['skip-pre']
+    # rubocop:disable CyclomaticComplexity, MethodLength, AbcSize, PerceivedComplexity
+    def run
+      options.staged = options.staged.nil? ? true : options.staged
+
+      if options.skip_pre
         puts 'Skipping PreRun Executables'
       else
-        run_externals('pre-run-execute', repo, args)
+        run_externals('pre-run-execute')
       end
 
-      if script && !(options['ignore-script'] || GitHooks.ignore_script)
+      if script && !(options.ignore_script || GitHooks.ignore_script)
         command = "#{script} #{Pathname.new($0)} #{Shellwords.join(ARGV)};"
         puts "Kernel#exec(#{command.inspect})" if GitHooks.verbose
         exec(command)
-      elsif libpath
-        load_tests(libpath, options['skip-bundler'])
-        start(options)
+      elsif hook_path
+        load_tests(hook_path, options.skip_bundler)
+        start
       else
-        puts %q"I can't figure out what to run - specify either path or script to give me a hint..."
+        puts %q"I can't figure out what to run! Specify either path or script to give me a hint..."
       end
 
-      if options['skip-post']
+      if options.skip_post
         puts 'Skipping PostRun Executables'
       else
-        run_externals('post-run-execute', repo, args)
+        run_externals('post-run-execute')
       end
     rescue GitHooks::Error::NotAGitRepo => e
       puts "Unable to find a valid git repo in #{repo}."
       puts 'Please specify path to repo via --repo <path>' if GitHooks::SCRIPT_NAME == 'githooks'
       raise e
     end
-    module_function :run
-
-    def attach(options = {})
-      repo_path  = options[:repo] || Repository.root_path
-      repo_path  = Pathname.new(repo_path) unless repo_path.nil?
-      repo_hooks = repo_path.join('.git', 'hooks')
-      entry_path = options[:script] || options[:path]
 
-      hook_phases = options[:hooks]
-      hook_phases ||= Hook::VALID_PHASES
-
-      bootstrapper = options[:bootstrap]
-      bootstrapper = Pathname.new(bootstrapper).realpath unless bootstrapper.nil?
-      entry_path   = Pathname.new(entry_path).realdirpath
-
-      repo = Repository.instance(repo_path)
+    def attach
+      entry_path   = Pathname.new(options.script || options.path).realdirpath
+      hook_phases  = options.hooks || Hook::VALID_PHASES
+      bootstrapper = Pathname.new(options.bootstrap).realpath if options.bootstrap
 
       if entry_path.directory?
-        if path = repo.config['path'] # rubocop:disable AssignmentInCondition
+        if path = repository.config['path'] # rubocop:disable AssignmentInCondition
           fail Error::AlreadyAttached, "Repository [#{repo_path}] already attached to path #{path} - Detach to continue."
         end
-        repo.config.set('path', entry_path)
+        repository.config.set('path', entry_path)
       elsif entry_path.executable?
-        if path = repo.config['script'] # rubocop:disable AssignmentInCondition
+        if path = repository.config['script'] # rubocop:disable AssignmentInCondition
           fail Error::AlreadyAttached, "Repository [#{repo_path}] already attached to script #{path}. Detach to continue."
         end
-        repo.config.set('script', entry_path)
+        repository.config.set('script', entry_path)
       else
         fail ArgumentError, "Provided path '#{entry_path}' is neither a directory nor an executable file."
       end
@@ -105,49 +98,35 @@ module GitHooks
       gitrunner ||= (GitHooks::BIN_PATH + 'githooks-runner').realpath
 
       hook_phases.each do |hook|
-        hook = (repo_hooks + hook).to_s
+        hook = (@repository.hooks + hook).to_s
         puts "Linking #{gitrunner} -> #{hook}" if GitHooks.verbose
         FileUtils.ln_sf gitrunner.to_s, hook
       end
     end
-    module_function :attach
-
-    def detach(repo_path, hook_phases)
-      repo_path   ||= Repository.root_path
-      repo_hooks    = Pathname.new(repo_path).join('.git', 'hooks')
-      hook_phases ||= Hook::VALID_PHASES
 
-      repo = Repository.instance(repo_path)
-
-      hook_phases.each do |hook|
-        next unless (repo_hook = (repo_hooks + hook)).symlink?
-        puts "Removing hook '#{hook}' from repository at: #{repo_path}" if GitHooks.verbose
+    def detach(hook_phases = nil)
+      (hook_phases || Hook::VALID_PHASES).each do |hook|
+        next unless (repo_hook = (@repository.hooks + hook)).symlink?
+        puts "Removing hook '#{hook}' from repository at: #{repository.path}" if GitHooks.verbose
         FileUtils.rm_f repo_hook
       end
 
-      active_hooks = Hook::VALID_PHASES.select { |hook| (repo_hooks + hook).exist? }
+      active_hooks = Hook::VALID_PHASES.select { |hook| (@repository.hooks + hook).exist? }
 
       if active_hooks.empty?
         puts 'All hooks detached. Removing configuration section.'
-        repo.config.remove_section(repo_path: repo_path)
+        repo.config.remove_section(repo_path: repository.path)
       else
         puts "Keeping configuration for active hooks: #{active_hooks.join(', ')}"
       end
     end
-    module_function :detach
-
-    def list(repo_path)
-      repo_path  ||= Pathname.new(Repository.root_path)
 
-      repo = Repository.instance(repo_path)
-      script  = repo.config.script
-      libpath = repo.config.path
-
-      unless script || libpath
+    def list
+      unless script || hook_path
         fail Error::NotAttached, 'Repository currently not configured. Usage attach to setup for use with githooks.'
       end
 
-      if (executables = repo.config.pre_run_execute).size > 0
+      if (executables = repository.config.pre_run_execute).size > 0
         puts 'PreRun Executables (in execution order):'
         puts executables.collect { |exe| "  #{exe}" }.join("\n")
         puts
@@ -159,13 +138,13 @@ module GitHooks
         puts
       end
 
-      if libpath
+      if hook_path
         puts 'Main Testing Library with Tests (in execution order):'
         puts '  Tests loaded from:'
-        puts "    #{libpath}"
+        puts "    #{hook_path}"
         puts
 
-        SystemUtils.quiet { load_tests(libpath, true) }
+        SystemUtils.quiet { load_tests(hook_path, true) }
 
         %w{ pre-commit commit-msg }.each do |phase|
           next unless Hook.phases[phase]
@@ -173,7 +152,7 @@ module GitHooks
           puts "  Phase #{phase.camelize}:"
           Hook.phases[phase].sections.each_with_index do |section, section_index|
             printf "    %3d: %s\n", section_index + 1, section.title
-            section.all.each_with_index do |action, action_index|
+            section.actions.each_with_index do |action, action_index|
               printf "      %3d: %s\n", action_index + 1, action.title
               action.limiters.each_with_index do |limiter, limiter_index|
                 type, value = limiter.type.inspect, limiter.only
@@ -187,7 +166,7 @@ module GitHooks
         puts
       end
 
-      if (executables = repo.config.post_run_execute).size > 0
+      if (executables = repository.config.post_run_execute).size > 0
         puts 'PostRun Executables (in execution order):'
         executables.each do |exe|
           puts "  #{exe}"
@@ -195,16 +174,26 @@ module GitHooks
         puts
       end
     rescue Error::NotAGitRepo
-      puts "Unable to find a valid git repo in #{repo}."
+      puts "Unable to find a valid git repo in #{repository}."
       puts 'Please specify path to repo via --repo <path>' if GitHooks::SCRIPT_NAME == 'githooks'
       raise
     end
-    module_function :list
 
   private
 
-    def run_externals(which, repo_path, args)
-      Repository.instance(repo_path).config[which].all? do |executable|
+    def acquire_hooks_path(path)
+      path = Pathname.new(path) unless path.is_a? Pathname
+      path.tap do # return input path by default
+        return path if path.include? 'hooks'
+        return path if path.include? '.hooks'
+        return p if (p = path.join('hooks')).exist? # rubocop:disable Lint/UselessAssignment
+        return p if (p = path.join('.hooks')).exist? # rubocop:disable Lint/UselessAssignment
+      end
+    end
+
+    def run_externals(which)
+      args = options.args || []
+      repository.config[which].all? { |executable|
         command = SystemUtils::Command.new(File.basename(executable), bin_path: executable)
 
         puts "#{which.camelize}: #{command.build_command(args)}" if GitHooks.verbose
@@ -217,20 +206,19 @@ module GitHooks
           end
         end
         r.status.success?
-      end || fail(TestsFailed, "Failed #{which.camelize} executables - giving up")
+      } || fail(TestsFailed, "Failed #{which.camelize} executables - giving up")
     end
-    module_function :run_externals
 
-    def start(options = {}) # rubocop:disable  CyclomaticComplexity,  MethodLength
-      phase = options[:hook] || GitHooks.hook_name || 'pre-commit'
+    def start # rubocop:disable  CyclomaticComplexity,  MethodLength
+      phase = options.hook || GitHooks.hook_name || 'pre-commit'
       puts "PHASE: #{phase}" if GitHooks.debug
 
       if (active_hook = Hook.phases[phase])
-        active_hook.args            = options.delete(:args)
-        active_hook.staged          = options.delete(:staged)
-        active_hook.untracked       = options.delete(:untracked)
-        active_hook.tracked         = options.delete(:tracked)
-        active_hook.repository_path = options.delete(:repo)
+        active_hook.args            = options.args
+        active_hook.staged          = options.staged
+        active_hook.untracked       = options.untracked
+        active_hook.tracked         = options.tracked
+        active_hook.repository_path = repository.path
       else
         fail Error::InvalidPhase, "Hook '#{phase}' is not defined - have you registered any tests for this hook yet?"
       end
@@ -268,26 +256,39 @@ module GitHooks
 
       exit(success ? 0 : 1)
     end
-    module_function :start
 
-    def load_tests(path, skip_bundler = false)
-      hooks_root = Pathname.new(path).realpath
-      hooks_path = (p = (hooks_root.join('hooks'))).exist? ? p : (hooks_root.join('.hooks'))
-      hooks_libs = hooks_root.join('libs')
-      gemfile    = hooks_root.join('Gemfile')
+    def load_tests(hooks_path, skip_bundler = false)
+      # hooks stored locally in the repo_root should have their libs, init and
+      # gemfile stored in the hooks directory itself, whereas hooks stored
+      # in a separate repository should have have them all stored relative
+      # to the separate hooks directory.
+      if hook_path.to_s.start_with? repository.path
+        hook_data_path = acquire_hooks_path(repository.path)
+      else
+        hook_data_path = acquire_hooks_path(hook_path)
+      end
+
+      hooks_libs = hook_data_path.join('lib')
+      hooks_init = hook_data_path.join('hooks_init.rb')
+      gemfile    = hook_data_path.join('Gemfile')
+
+      GitHooks.hooks_root = hook_data_path
 
-      if gemfile.exist? && !skip_bundler
+      if gemfile.exist? && !(skip_bundler.nil? ? ENV.include?('GITHOOKS_SKIP_BUNDLER') : skip_bundler)
         puts "loading Gemfile from: #{gemfile}" if GitHooks.verbose
 
         begin
-          ENV['BUNDLE_GEMFILE'] = (hooks_root + 'Gemfile').to_s
+          ENV['BUNDLE_GEMFILE'] = gemfile.to_s
 
           # stupid RVM polluting my environment without asking via it's
           # executable-hooks gem preloading bundler. hence the following ...
           if defined? Bundler
-            [:@settings, :@bundle_path, :@configured, :@definition, :@load].each do |var|
+            [:@bundle_path, :@configured, :@definition, :@load].each do |var|
               ::Bundler.instance_variable_set(var, nil)
             end
+            # bundler tests for @settings using defined? - which means we need
+            # to forcibly remove it.
+            Bundler.send(:remove_instance_variable, :@settings)
           else
             require 'bundler'
           end
@@ -304,13 +305,18 @@ module GitHooks
 
       $LOAD_PATH.unshift hooks_libs.to_s
 
-      Dir["#{hooks_path}/**/*.rb"].each do |lib|
-        lib.gsub!('.rb', '')
-        puts "Loading: #{lib}" if GitHooks.verbose
-        require lib
+      if hooks_init.exist?
+        puts "Loading hooks from #{hooks_init} ..." if GitHooks.verbose?
+        require hooks_init.sub_ext('').to_s
+      else
+        puts 'Loading hooks brute-force style ...' if GitHooks.verbose?
+        Dir["#{hooks_path}/**/*.rb"].each do |lib|
+          lib.gsub!('.rb', '')
+          puts "  -> #{lib}" if GitHooks.verbose
+          require lib
+        end
       end
     end
-    module_function :load_tests
 
     # rubocop:enable CyclomaticComplexity, MethodLength, AbcSize, PerceivedComplexity
   end

data/lib/githooks/section.rb

@@ -21,10 +21,10 @@ require 'delegate'
 
 module GitHooks
   class Section < DelegateClass(Array)
-    attr_reader :name, :hook, :success, :actions, :benchmark
+    attr_reader :name, :hook, :success, :actions, :benchmark, :limiters
+
     alias_method :title, :name
     alias_method :success?, :success
-    alias_method :all, :actions
 
     class << self
       def key_from_name(name)
@@ -36,6 +36,7 @@ module GitHooks
       @name      = name.to_s.titleize
       @success   = true
       @actions   = []
+      @limiters  = hook.limiters
       @hook      = hook
       @benchmark = 0
 
@@ -85,12 +86,6 @@ module GitHooks
       success? ? text.success! : text.failure!
     end
 
-    def action(title, &block)
-      fail ArgumentError, 'expected block, received none' unless block_given?
-      @actions << Action.new(title, self, &block)
-      self
-    end
-
     def run
       running!
       begin
@@ -101,5 +96,36 @@ module GitHooks
         finished!
       end
     end
+
+    ## DSL
+
+    def config_path
+      GitHooks.hooks_root.join('configs')
+    end
+
+    def config_file(*path_components)
+      config_path.join(*path_components)
+    end
+
+    def lib_path
+      GitHooks.hooks_root.join('lib')
+    end
+
+    def lib_file(*path_components)
+      lib_path.join(*path_components)
+    end
+
+    def limit(type)
+      unless @limiters.include? type
+        @limiters[type] ||= Repository::Limiter.new(type)
+      end
+      @limiters[type]
+    end
+
+    def action(title, &block)
+      fail ArgumentError, 'expected block, received none' unless block_given?
+      @actions << Action.new(title, self, &block)
+      self
+    end
   end
 end

data/lib/githooks/system_utils.rb

@@ -14,8 +14,8 @@ module GitHooks
 
     def find_bin(name)
       # rubocop:disable MultilineBlockChain, Blocks
-      ENV['PATH'].split(/:/).collect {
-        |path| Pathname.new(path) + name.to_s
+      ENV['PATH'].split(/:/).collect { |path|
+        Pathname.new(path) + name.to_s
       }.select { |path|
         path.exist? && path.executable?
       }.collect(&:to_s)
@@ -67,10 +67,12 @@ module GitHooks
         LANG LC_ALL SHELL SHLVL TERM TMPDIR USER
         SSH_USER SSH_AUTH_SOCK
         GEM_HOME GEM_PATH MY_RUBY_HOME
-      )
+        GIT_DIR GIT_AUTHOR_DATE GIT_INDEX_FILE GIT_AUTHOR_NAME GIT_PREFIX GIT_AUTHOR_EMAIL
+      ) unless defined? ENV_WHITELIST
 
       class Result
-        attr_reader :output, :error, :status
+        attr_accessor :output, :error
+        attr_reader :status
         def initialize(output, error, status)
           @output = output.strip
           @error  = error.strip
@@ -135,7 +137,7 @@ module GitHooks
       def prep_env(env = {})
         Hash[env].each_with_object([]) do |(k, v), array|
           array << %Q|#{k}="#{v}"| if ENV_WHITELIST.include? k
-        end.join(' ')
+        end
       end
 
       def execute(*args, &_block) # rubocop:disable MethodLength, CyclomaticComplexity, AbcSize, PerceivedComplexity
@@ -154,27 +156,39 @@ module GitHooks
         command.push options.delete(:post_run) if options[:post_run]
         command = shellwords(command.flatten.join(';'))
 
-        environment = prep_env(options.delete(:env) || ENV)
+        environment = prep_env(options.delete(:env) || ENV).join(' ')
 
         error_file = Tempfile.new('ghstderr')
+
+        script_file = Tempfile.new('ghscript')
+        script_file.puts "exec 2>#{error_file.path}"
+        script_file.puts command.join(' ')
+
+        script_file.rewind
+
         begin
-          real_command = %Q{
-            /usr/bin/env -i #{environment} bash -c '
-              ( #{command.join(' ').gsub("'", %q|'"'"'|)}) 2>#{error_file.path}
-            '
-          }
+          real_command = "/usr/bin/env -i #{environment} bash #{script_file.path}"
 
-          $stderr.puts real_command if GitHooks.debug?
+          if GitHooks.verbose?
+            $stderr.puts "Command Line  :\n----\n#{real_command}\n----\n"
+            $stderr.puts "Command Script:\n----\n#{script_file.read}\n----\n"
+          end
 
           output = %x{ #{real_command} }
           result = Result.new(output, error_file.read, $?)
 
-          if GitHooks.verbose? && result.failure?
-            STDERR.puts "Command failed with exit code [#{result.status.exitstatus}]",
-                        "ENVIRONMENT:\n\t#{environment}\n\n",
-                        "COMMAND:\n\t#{command.join(' ')}\n\n",
-                        "OUTPUT:\n-----\n#{result.output}\n-----\n\n",
-                        "ERROR:\n-----\n#{result.error}\n-----\n\n"
+          if GitHooks.verbose?
+            if result.failure?
+              STDERR.puts "Command failed with exit code [#{result.status.exitstatus}]",
+                          "ENVIRONMENT:\n\t#{environment}\n\n",
+                          "COMMAND:\n\t#{command.join(' ')}\n\n",
+                          "OUTPUT:\n-----\n#{result.output}\n-----\n\n",
+                          "ERROR:\n-----\n#{result.error}\n-----\n\n"
+            else
+              STDERR.puts "Command succeeded with exit code [#{result.status.exitstatus}]",
+                          "OUTPUT:\n-----\n#{result.output}\n-----\n\n",
+                          "ERROR:\n-----\n#{result.error}\n-----\n\n"
+            end
           end
 
           sanitize = [ :strip, :non_printable ]
@@ -182,8 +196,11 @@ module GitHooks
           sanitize << :empty_lines if options.delete(:strip_empty_lines)
           result.sanitize!(*sanitize)
 
-          block_given? ? yield(result) : result
+          result.tap { yield(result) if block_given? }
         ensure
+          script_file.close
+          script_file.unlink
+
           error_file.close
           error_file.unlink
         end

data/lib/githooks/version.rb

@@ -18,5 +18,5 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 =end
 
 module GitHooks
-  VERSION = '1.3.2'
+  VERSION = '1.4.1' unless defined? VERSION
 end