rabbitt-githooks 1.3.0 → 1.3.2

data/lib/githooks/repository/diff_index_entry.rb

@@ -1,6 +1,5 @@
 require 'ostruct'
 require 'pathname'
-require 'githooks/repository/file'
 
 module GitHooks
   class Repository
@@ -31,7 +30,8 @@ module GitHooks
         super parse_data(entry)
       end
 
-      def parse_data(entry) # rubocop:disable MethodLength
+      # rubocop:disable MultilineOperationIndentation
+      def parse_data(entry) # rubocop:disable MethodLength, AbcSize
         data = Hash[
           DIFF_STRUCTURE_REGEXP.names.collect(&:to_sym).zip(
             entry.match(DIFF_STRUCTURE_REGEXP).captures
@@ -53,6 +53,7 @@ module GitHooks
           score: data[:score].to_i
         }
       end
+      # rubocop:enable MultilineOperationIndentation
 
       def to_repo_file
         Repository::File.new(self)

data/lib/githooks/repository/file.rb

@@ -17,16 +17,15 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 =end
 
-require 'ostruct'
 require 'delegate'
 
-# allow for reloading of class
-unless defined? DiffIndexEntryDelegateClass
-  DiffIndexEntryDelegateClass = DelegateClass(GitHooks::Repository::DiffIndexEntry)
-end
-
 module GitHooks
   class Repository
+    # allow for reloading of class
+    unless defined? DiffIndexEntryDelegateClass
+      DiffIndexEntryDelegateClass = DelegateClass(DiffIndexEntry)
+    end
+
     class File < DiffIndexEntryDelegateClass
       def initialize(entry)
         unless entry.is_a? Repository::DiffIndexEntry
@@ -68,7 +67,7 @@ module GitHooks
         end
       end
 
-      def match(type, selector)
+      def match(type, selector) # rubocop:disable AbcSize
         value = attribute_value(type)
         return selector.call(value) if selector.respond_to? :call
 
@@ -122,6 +121,14 @@ module GitHooks
         return [] unless fd
         strip_newlines ? fd.readlines.collect(&:chomp!) : fd.readlines
       end
+
+      def <=>(other)
+        path.to_s <=> other.path.to_s
+      end
+
+      def ==(other)
+        path.to_s == other.path.to_s
+      end
     end
   end
 end

data/lib/githooks/runner.rb

@@ -17,23 +17,23 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 =end
 
+require 'thor'
 require 'fileutils'
-require 'githooks/terminal_colors'
 require 'shellwords'
-require 'thor'
+
+require_relative 'error'
+require_relative 'hook'
+require_relative 'repository'
+require_relative 'system_utils'
 
 module GitHooks
   module Runner
-    extend TerminalColors
-
-    MARK_SUCCESS = '✓'
-    MARK_FAILURE = 'X'
-    MARK_UNKNOWN = '?'
-
-    def run(options = {}) # rubocop:disable CyclomaticComplexity, MethodLength
-      # unfreeze options
+    # rubocop:disable CyclomaticComplexity, MethodLength, AbcSize, PerceivedComplexity
+    def run(options = {})
       options = Thor::CoreExt::HashWithIndifferentAccess.new(options)
 
+      options['staged'] = options['staged'].nil? ? true : options['staged']
+
       repo    = options['repo']   ||= Repository.root_path
       script  = options['script'] ||= Repository.instance(repo).config.script
       libpath = options['path']   ||= Repository.instance(repo).config.path
@@ -56,7 +56,7 @@ module GitHooks
         load_tests(libpath, options['skip-bundler'])
         start(options)
       else
-        puts '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']
@@ -64,17 +64,17 @@ module GitHooks
       else
         run_externals('post-run-execute', repo, args)
       end
-    rescue GitHooks::Error::NotAGitRepo
+    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 = {}) # rubocop:disable CyclomaticComplexity, MethodLength
+    def attach(options = {})
       repo_path  = options[:repo] || Repository.root_path
       repo_path  = Pathname.new(repo_path) unless repo_path.nil?
-      repo_hooks = repo_path + '.git' + 'hooks'
-
+      repo_hooks = repo_path.join('.git', 'hooks')
       entry_path = options[:script] || options[:path]
 
       hook_phases = options[:hooks]
@@ -114,7 +114,7 @@ module GitHooks
 
     def detach(repo_path, hook_phases)
       repo_path   ||= Repository.root_path
-      repo_hooks    = Pathname.new(repo_path) + '.git' + 'hooks'
+      repo_hooks    = Pathname.new(repo_path).join('.git', 'hooks')
       hook_phases ||= Hook::VALID_PHASES
 
       repo = Repository.instance(repo_path)
@@ -136,7 +136,7 @@ module GitHooks
     end
     module_function :detach
 
-    def list(repo_path) # rubocop:disable Style/CyclomaticComplexity, Style/MethodLength
+    def list(repo_path)
       repo_path  ||= Pathname.new(Repository.root_path)
 
       repo = Repository.instance(repo_path)
@@ -149,9 +149,7 @@ module GitHooks
 
       if (executables = repo.config.pre_run_execute).size > 0
         puts 'PreRun Executables (in execution order):'
-        executables.each do |exe|
-          puts "  #{exe}"
-        end
+        puts executables.collect { |exe| "  #{exe}" }.join("\n")
         puts
       end
 
@@ -196,9 +194,10 @@ module GitHooks
         end
         puts
       end
-    rescue GitHooks::Error::NotAGitRepo
+    rescue Error::NotAGitRepo
       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
     end
     module_function :list
 
@@ -206,7 +205,7 @@ module GitHooks
 
     def run_externals(which, repo_path, args)
       Repository.instance(repo_path).config[which].all? do |executable|
-        command = SystemUtils::Command.new(File.basename(executable), path: executable)
+        command = SystemUtils::Command.new(File.basename(executable), bin_path: executable)
 
         puts "#{which.camelize}: #{command.build_command(args)}" if GitHooks.verbose
         unless (r = command.execute(*args)).status.success?
@@ -222,7 +221,7 @@ module GitHooks
     end
     module_function :run_externals
 
-    def start(options = {}) # rubocop:disable Style/CyclomaticComplexity, Style/MethodLength
+    def start(options = {}) # rubocop:disable  CyclomaticComplexity,  MethodLength
       phase = options[:hook] || GitHooks.hook_name || 'pre-commit'
       puts "PHASE: #{phase}" if GitHooks.debug
 
@@ -237,21 +236,22 @@ module GitHooks
       end
 
       success        = active_hook.run
-      section_length = active_hook.sections.max { |s| s.title.length }
+      section_length = active_hook.sections.maximum { |s| s.title.length }
       sections       = active_hook.sections.select { |section| !section.actions.empty? }
 
+      # TODO: refactor to show this in realtime instead of after the hooks have run
       sections.each do |section|
         hash_tail_length = (section_length - section.title.length)
         printf "===== %s %s===== (%ds)\n", section.colored_name(phase), ('=' * hash_tail_length), section.benchmark
-
         section.actions.each_with_index do |action, index|
-          printf "  %d. [ %s ] %s (%ds)\n", (index + 1), action.state_symbol, action.colored_title, action.benchmark
+          printf "  %d. [ %s ] %s (%ds)\n", (index + 1), action.status_symbol, action.colored_title, action.benchmark
 
           action.errors.each do |error|
-            printf "    %s %s\n", color_bright_red(MARK_FAILURE), error
+            printf "    %s %s\n", GitHooks::FAILURE_SYMBOL, error
           end
 
-          state_string = ( action.success? ? color_bright_green(MARK_SUCCESS) : color_bright_yellow(MARK_UNKNOWN))
+          state_string = action.success? ? GitHooks::SUCCESS_SYMBOL : GitHooks::UNKNOWN_SYMBOL
+
           action.warnings.each do |warning|
             printf "    %s %s\n", state_string, warning
           end
@@ -270,11 +270,11 @@ module GitHooks
     end
     module_function :start
 
-    def load_tests(path, skip_bundler = false) # rubocop:disable MethodLength,Style/CyclomaticComplexity
+    def load_tests(path, skip_bundler = false)
       hooks_root = Pathname.new(path).realpath
-      hooks_path = (p = (hooks_root + 'hooks')).exist? ? p : (hooks_root + '.hooks')
-      hooks_libs = hooks_root + 'libs'
-      gemfile    = hooks_root + 'Gemfile'
+      hooks_path = (p = (hooks_root.join('hooks'))).exist? ? p : (hooks_root.join('.hooks'))
+      hooks_libs = hooks_root.join('libs')
+      gemfile    = hooks_root.join('Gemfile')
 
       if gemfile.exist? && !skip_bundler
         puts "loading Gemfile from: #{gemfile}" if GitHooks.verbose
@@ -286,16 +286,16 @@ module GitHooks
           # executable-hooks gem preloading bundler. hence the following ...
           if defined? Bundler
             [:@settings, :@bundle_path, :@configured, :@definition, :@load].each do |var|
-              Bundler.instance_variable_set(var, nil)
+              ::Bundler.instance_variable_set(var, nil)
             end
           else
             require 'bundler'
           end
-          Bundler.require(:default)
+          ::Bundler.require(:default)
         rescue LoadError
-          puts %Q|Unable to load bundler - please make sure it's installed.|
+          puts %q"Unable to load bundler - please make sure it's installed."
           raise # rubocop:disable SignalException
-        rescue Bundler::GemNotFound => e
+        rescue ::Bundler::GemNotFound => e
           puts "Error: #{e.message}"
           puts 'Did you bundle install your Gemfile?'
           raise # rubocop:disable SignalException
@@ -311,5 +311,7 @@ module GitHooks
       end
     end
     module_function :load_tests
+
+    # rubocop:enable CyclomaticComplexity, MethodLength, AbcSize, PerceivedComplexity
   end
 end

data/lib/githooks/section.rb

@@ -21,8 +21,6 @@ require 'delegate'
 
 module GitHooks
   class Section < DelegateClass(Array)
-    include TerminalColors
-
     attr_reader :name, :hook, :success, :actions, :benchmark
     alias_method :title, :name
     alias_method :success?, :success
@@ -49,7 +47,7 @@ module GitHooks
     # overrides previous action method to only return
     # actions that have a non-empty manifest
     def actions
-      @actions.select { |action| !action.manifest.empty? }
+      @actions.reject { |action| action.manifest.empty? }
     end
     alias_method :__getobj__, :actions
 
@@ -63,40 +61,36 @@ module GitHooks
     end
 
     def completed?
-      @actions.all? { |action| action.finished? }
+      @actions.all?(&:finished?)
     end
 
     def wait_count
-      @actions.select { |action| action.waiting? }.size
+      @actions.select(&:waiting?).size
     end
 
     def name(phase = GitHooks::HOOK_NAME)
-      phase = (phase || GitHooks::HOOK_NAME).to_s.gsub('-', '_').camelize
-      "#{phase} :: #{@name}"
+      "#{(phase || GitHooks::HOOK_NAME).to_s.camelize} :: #{@name}"
+    end
+
+    def colored_name(phase = GitHooks::HOOK_NAME)
+      status_colorize name(phase)
     end
 
     def key_name
       self.class.key_from_name(@name)
     end
 
-    def colored_name(phase = GitHooks::HOOK_NAME)
-      status_colorize name(phase)
+    def status_colorize(text)
+      return text.unknown! unless finished? && completed?
+      success? ? text.success! : text.failure!
     end
 
-    def action(title, options = {}, &block)
-      fail ArgumentError, 'Missing required block to #perform' unless block_given?
+    def action(title, &block)
+      fail ArgumentError, 'expected block, received none' unless block_given?
       @actions << Action.new(title, self, &block)
       self
     end
 
-    def status_colorize(text)
-      if finished? && completed?
-        success? ? color_bright_green(text) : color_bright_red(text)
-      else
-        color_dark_cyan(text)
-      end
-    end
-
     def run
       running!
       begin

data/lib/githooks/system_utils.rb

@@ -1,7 +1,8 @@
-# encoding: utf-8
+# sublime: x_syntax Packages/Ruby/Ruby.tmLanguage
+# sublime: translate_tabs_to_spaces true; tab_size 2
+
 require 'pathname'
-require 'open3'
-require 'ostruct'
+require 'tempfile'
 require 'shellwords'
 
 module GitHooks
@@ -22,7 +23,7 @@ module GitHooks
     end
     module_function :find_bin
 
-    def with_path(path, &block)
+    def with_path(path, &_block)
       fail ArgumentError, 'Missing required block' unless block_given?
       begin
         cwd = Dir.getwd
@@ -34,7 +35,7 @@ module GitHooks
     end
     module_function :with_path
 
-    def quiet(&block)
+    def quiet(&_block)
       od, ov = GitHooks.debug, GitHooks.verbose
       GitHooks.debug, GitHooks.verbose = false, false
       yield
@@ -43,67 +44,151 @@ module GitHooks
     end
     module_function :quiet
 
+    def command(name)
+      (@commands ||= {})[name] ||= begin
+        Command.new(name).tap { |cmd|
+          define_method("command_#{cmd.name}") { |*args| cmd.execute(*args) }
+          alias_method cmd.method, "command_#{cmd.name}"
+        }
+      end
+    end
+    module_function :command
+
+    def commands(*names)
+      names.each { |name| command(name) }
+    end
+    module_function :commands
+
     class Command
       include Shellwords
 
-      attr_reader :aliases, :path, :name
-      def initialize(name, options = {})
-        @name = name
-        @path = options.delete(:path) || SystemUtils.which(name)
+      ENV_WHITELIST = %w(
+        PATH HOME LDFLAGS CPPFLAGS DISPLAY EDITOR
+        LANG LC_ALL SHELL SHLVL TERM TMPDIR USER
+        SSH_USER SSH_AUTH_SOCK
+        GEM_HOME GEM_PATH MY_RUBY_HOME
+      )
+
+      class Result
+        attr_reader :output, :error, :status
+        def initialize(output, error, status)
+          @output = output.strip
+          @error  = error.strip
+          @status = status
+        end
 
-        @aliases = options.delete(:aliases) || []
-        @aliases << name
-        @aliases.collect! { |alias_name| normalize(alias_name) }
-        @aliases.uniq!
+        def output_lines(prefix = nil)
+          @output.split(/\n/).collect { |line|
+            prefix ? "#{prefix}: #{line}" : line
+          }
+        end
+
+        def error_lines(prefix = nil)
+          @error.split(/\n/).collect { |line|
+            prefix ? "#{prefix}: #{line}" : line
+          }
+        end
+
+        def sanitize!(*args)
+          @output.sanitize!(*args)
+          @error.sanitize!(*args)
+        end
+
+        def success?
+          status? ? @status.success? : false
+        end
+
+        def failure?
+          !success?
+        end
+
+        def status?
+          !!@status
+        end
+
+        def exitstatus
+          status? ? @status.exitstatus : -1
+        end
+        alias_method :code, :exitstatus
+      end
+
+      attr_reader :run_path, :bin_path, :name
+
+      def initialize(name, options = {})
+        @bin_path = options.delete(:bin_path) || SystemUtils.which(name) || name
+        @run_path = options.delete(:chdir)
+        @name     = name.to_s.gsub(/([\W-]+)/, '_')
       end
 
-      def command_path
-        path || name.to_s
+      def method
+        @name.to_sym
       end
 
-      def build_command(args, options = {})
-        change_to_path = options['path'] || options[:path]
+      def build_command(args, options)
+        Array(args).unshift(command_path(options))
+      end
 
-        args = [args].flatten
-        args.collect! { |arg| arg.is_a?(Repository::File) ? arg.path.to_s : arg }
-        args.collect!(&:to_s)
+      def command_path(options = {})
+        options.delete(:use_name) ? name : bin_path.to_s
+      end
 
-        command = shelljoin([command_path] | args)
-        command = ("cd #{shellescape(change_to_path.to_s)} ; " + command) unless change_to_path.nil?
-        command
+      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
 
-      def execute(*args, &block) # rubocop:disable MethodLength, CyclomaticComplexity
-        options = args.extract_options
-        strip_empty_lines = !!options.delete(:strip_empty_lines)
+      def execute(*args, &_block) # rubocop:disable MethodLength, CyclomaticComplexity, AbcSize, PerceivedComplexity
+        options = args.extract_options!
 
         command = build_command(args, options)
-        result = OpenStruct.new(output: nil, error: nil, status: nil).tap do |r|
-          puts "#{Dir.getwd} $ #{command}" if GitHooks.debug
-
-          r.output, r.error, r.status = if RUBY_ENGINE == 'jruby'
-            _, o, e, t = Open3.popen3('/usr/bin/env', 'sh', '-c', command)
-            [o.read, e.read, t.value]
-          else
-            Open3.capture3(command)
-          end
-
-          if strip_empty_lines
-            r.output = r.output.strip_empty_lines!
-            r.error  = r.error.strip_empty_lines!
+        command.unshift("cd #{run_path} ;") if run_path
+        command.unshift('sudo') if options.delete(:use_sudo)
+        command = Array(command.flatten.join(' '))
+
+        command.unshift options.delete(:pre_pipe)  if options[:pre_pipe]
+        command.push options.delete(:post_pipe) if options[:post_pipe]
+        command = Array(command.flatten.join('|'))
+
+        command.unshift options.delete(:pre_run)  if options[:pre_run]
+        command.push options.delete(:post_run) if options[:post_run]
+        command = shellwords(command.flatten.join(';'))
+
+        environment = prep_env(options.delete(:env) || ENV)
+
+        error_file = Tempfile.new('ghstderr')
+        begin
+          real_command = %Q{
+            /usr/bin/env -i #{environment} bash -c '
+              ( #{command.join(' ').gsub("'", %q|'"'"'|)}) 2>#{error_file.path}
+            '
+          }
+
+          $stderr.puts real_command if GitHooks.debug?
+
+          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"
           end
-        end
 
-        puts result.inspect if GitHooks.debug
+          sanitize = [ :strip, :non_printable ]
+          sanitize << :colors unless options.delete(:color)
+          sanitize << :empty_lines if options.delete(:strip_empty_lines)
+          result.sanitize!(*sanitize)
 
-        block_given? ? yield(result) : result
+          block_given? ? yield(result) : result
+        ensure
+          error_file.close
+          error_file.unlink
+        end
       end
       alias_method :call, :execute
-
-      def normalize(name)
-        name.to_s.gsub(/[^a-z_]+/, '_')
-      end
-      private :normalize
     end
   end
 end