rabbitt-githooks 1.2.7 → 1.3.0

data/lib/githooks/repository/diff_index_entry.rb

@@ -1,79 +1,77 @@
 require 'ostruct'
 require 'pathname'
+require 'githooks/repository/file'
 
 module GitHooks
-  class Repository::DiffIndexEntry < OpenStruct
-    DIFF_STRUCTURE_REGEXP = %r{
-      ^:
-      (?<original_mode>\d+)\s
-      (?<new_mode>\d+)\s
-      (?<original_sha>[a-f\d]+)\s
-      (?<new_sha>[a-f\d]+)\s
-      (?<change_type>.)
-      (?:(?<score>\d+)?)\s
-      (?<file_path>\S+)\s?
-      (?<rename_path>\S+)?
-    }xi unless defined? DIFF_STRUCTURE_REGEXP
+  class Repository
+    class DiffIndexEntry < OpenStruct
+      DIFF_STRUCTURE_REGEXP = %r{
+        ^:
+        (?<original_mode>\d+)\s
+        (?<new_mode>\d+)\s
+        (?<original_sha>[a-f\d]+)\.*\s
+        (?<new_sha>[a-f\d]+)\.*\s
+        (?<change_type>.)
+        (?:(?<score>\d+)?)\s
+        (?<file_path>\S+)\s?
+        (?<rename_path>\S+)?
+      }xi unless defined? DIFF_STRUCTURE_REGEXP
 
-    def self.from_file_path(file_path)
-      file_path = Pathname.new(file_path)
-      new(
-        [
-          0,
-          file_path.stat.mode.to_s(8),
-          0x0,
-          0x0,
-          '?',
-          file_path.to_s
-        ].join(' ').prepend(':')
-      )
-    end
+      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)
+        new(entry_line)
+      end
 
-    def initialize(entry)
-      unless entry =~ DIFF_STRUCTURE_REGEXP
-        fail ArgumentError, 'Unable to parse incoming diff entry data: #{entry}'
+      def initialize(entry)
+        unless entry =~ DIFF_STRUCTURE_REGEXP
+          fail ArgumentError, "Unable to parse incoming diff entry data: #{entry}"
+        end
+        super parse_data(entry)
       end
-      super parse_data(entry)
-    end
 
-    def parse_data(entry) # rubocop:disable MethodLength
-      data = Hash[DIFF_STRUCTURE_REGEXP.names.collect(&:to_sym).zip(
-        entry.match(DIFF_STRUCTURE_REGEXP).captures
-      )]
+      def parse_data(entry) # rubocop:disable MethodLength
+        data = Hash[
+          DIFF_STRUCTURE_REGEXP.names.collect(&:to_sym).zip(
+            entry.match(DIFF_STRUCTURE_REGEXP).captures
+          )
+        ]
 
-      {
-        from:  FileState.new(
-          data[:original_mode].to_i(8),
-          data[:original_sha],
-          data[:file_path].nil? ? nil : Pathname.new(data[:file_path])
-        ),
-        to:    FileState.new(
-          data[:new_mode].to_i(8),
-          data[:new_sha],
-          data[:rename_path].nil? ? nil : Pathname.new(data[:rename_path])
-        ),
-        type:  Repository::CHANGE_TYPES[data[:change_type]],
-        score: data[:score].to_i
-      }
-    end
+        {
+          from:  FileState.new(
+            data[:original_mode].to_i(8),
+            data[:original_sha],
+            data[:file_path].nil? ? nil : Pathname.new(data[:file_path])
+          ),
+          to:    FileState.new(
+            data[:new_mode].to_i(8),
+            data[:new_sha],
+            data[:rename_path].nil? ? nil : Pathname.new(data[:rename_path])
+          ),
+          type:  Repository::CHANGE_TYPES[data[:change_type]],
+          score: data[:score].to_i
+        }
+      end
 
-    def to_repo_file
-      Repository::File.new(self)
-    end
+      def to_repo_file
+        Repository::File.new(self)
+      end
 
-    class FileState
-      attr_reader :mode, :sha, :path
+      class FileState
+        attr_reader :mode, :sha, :path
 
-      def initialize(mode, sha, path)
-        @mode, @sha, @path = mode, sha, path
-      end
+        def initialize(mode, sha, path)
+          @mode, @sha, @path = mode, sha, path
+        end
 
-      def inspect
-        "#<#{self.class.name.split('::').last} mode=#{mode.to_s(8)} path=#{path.to_s.inspect} sha=#{sha.inspect}>"
-      end
+        def inspect
+          "#<#{self.class.name.split('::').last} mode=#{mode.to_s(8)} path=#{path.to_s.inspect} sha=#{sha.inspect}>"
+        end
 
-      def to_path
-        Pathname.new(@path)
+        def to_path
+          Pathname.new(@path)
+        end
       end
     end
   end

data/lib/githooks/repository/file.rb

@@ -26,100 +26,102 @@ unless defined? DiffIndexEntryDelegateClass
 end
 
 module GitHooks
-  class Repository::File < DiffIndexEntryDelegateClass
-    def initialize(entry)
-      unless entry.is_a? Repository::DiffIndexEntry
-        fail ArgumentError, "Expected a Repository::DiffIndexEntry but got a '#{entry.class.name}'"
+  class Repository
+    class File < DiffIndexEntryDelegateClass
+      def initialize(entry)
+        unless entry.is_a? Repository::DiffIndexEntry
+          fail ArgumentError, "Expected a Repository::DiffIndexEntry but got a '#{entry.class.name}'"
+        end
+        @file = entry
       end
-      @file = entry
-    end
 
-    def __getobj__ # rubocop:disable TrivialAccessors
-      @file
-    end
+      def __getobj__ # rubocop:disable TrivialAccessors
+        @file
+      end
 
-    def inspect
-      attributes = [:name, :path, :type, :mode, :sha, :score].collect do |name|
-        "#{name}=#{attribute_value(name).inspect}"
+      def inspect
+        attributes = [:name, :path, :type, :mode, :sha, :score].collect do |name|
+          "#{name}=#{attribute_value(name).inspect}"
+        end
+        "#<#{self.class.name} #{attributes.join(' ')} >"
       end
-      "#<#{self.class.name} #{attributes.join(' ')} >"
-    end
 
-    def path
-      to.path || from.path
-    end
+      def path
+        to.path || from.path
+      end
 
-    def name
-      path.basename.to_s
-    end
+      def name
+        path.basename.to_s
+      end
 
-    # rubocop:disable CyclomaticComplexity
-    def attribute_value(attribute)
-      case attribute
-        when :name then name
-        when :path then path.to_s
-        when :type then type
-        when :mode then to.mode
-        when :sha then to.sha
-        when :score then score
-        else fail ArgumentError,
-                  "Invalid attribute type '#{attribute}' - expected: :name, :path, :type, :mode, :sha, or :score"
+      # rubocop:disable CyclomaticComplexity
+      def attribute_value(attribute)
+        case attribute
+          when :name then name
+          when :path then path.to_s
+          when :type then type
+          when :mode then to.mode
+          when :sha then to.sha
+          when :score then score
+          else fail ArgumentError,
+                    "Invalid attribute type '#{attribute}' - expected: :name, :path, :type, :mode, :sha, or :score"
+        end
       end
-    end
 
-    def match(type, _match)
-      value = attribute_value(type)
-      return _match.call(value) if _match.respond_to? :call
-
-      case type
-        when :name  then _match.is_a?(Regexp) ? value =~ _match : value == _match
-        when :path  then _match.is_a?(Regexp) ? value =~ _match : value == _match
-        when :type  then _match.is_a?(Array) ? _match.include?(value) : _match == value
-        when :mode  then _match & value == _match
-        when :sha   then _match == value
-        when :score then _match == value
+      def match(type, selector)
+        value = attribute_value(type)
+        return selector.call(value) if selector.respond_to? :call
+
+        case type
+          when :name  then selector.is_a?(Regexp) ? value =~ selector : value == selector
+          when :path  then selector.is_a?(Regexp) ? value =~ selector : value == selector
+          when :type  then [*selector].include?(:any) ? true : [*selector].include?(value)
+          when :mode  then selector & value == selector
+          when :sha   then selector == value
+          when :score then selector == value
+        end
       end
-    end
-    # rubocop:enable CyclomaticComplexity
+      # rubocop:enable CyclomaticComplexity
 
-    def fd
-      case type
-        when :deleted, :deletion then nil
-        else path.open
+      def fd
+        case type
+          when :deleted, :deletion then nil
+          else path.open
+        end
       end
-    end
 
-    def realpath
-      case type
-        when :deleted, :deletion then path
-        else path.realpath
+      def realpath
+        case type
+          when :deleted, :deletion then path
+          else path.realpath
+        end
       end
-    end
 
-    def contains?(string_or_regexp)
-      if string_or_regexp.is_a?(Regexp)
-        contents =~ string_or_regexp
-      else
-        contents.include? string_or_regexp
+      def contains?(string_or_regexp)
+        if string_or_regexp.is_a?(Regexp)
+          contents =~ string_or_regexp
+        else
+          contents.include? string_or_regexp
+        end
       end
-    end
 
-    def grep(regexp)
-      lines(true).select_with_index { |line|
-        line =~ regexp
-      }.collect { |num, line|
-        [num + 1, line] # line numbers start from 1, not 0
-      }
-    end
+      def grep(regexp)
+        lines(true).select_with_index { |line|
+          line =~ regexp
+        }.collect { |num, line|
+          [num + 1, line] # line numbers start from 1, not 0
+        }
+      end
 
-    def contents
-      return unless fd
-      fd.read
-    end
+      def contents
+        return unless fd
+        fd.read
+      end
 
-    def lines(strip_newlines = false)
-      return [] unless fd
-      strip_newlines ? fd.readlines.collect(&:chomp!) : fd.readlines
+      def lines(strip_newlines = false)
+        return [] unless fd
+        strip_newlines ? fd.readlines.collect(&:chomp!) : fd.readlines
+      end
     end
   end
 end

data/lib/githooks/repository/limiter.rb

@@ -17,38 +17,47 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 =end
 
 module GitHooks
-  class Repository::Limiter
-    attr_reader :type, :only
+  class Repository
+    class Limiter
+      attr_reader :type, :only
 
-    def initialize(type, options = {})
-      @type   = type
-      @only   = options.delete(:only) || options.delete(:to)
-    end
+      def initialize(type, options = {})
+        @type     = type
+        @only     = options.delete(:only) || options.delete(:to)
+        @inverted = false
+      end
 
-    def only(*args)
-      return @only if args.empty?
-      @only = args.flatten
-    end
-    alias_method :to, :only
-
-    def limit(files)
-      files.select! do |file|
-        match_file(file, @only).tap do |result|
-          if GitHooks.debug?
-            result = (result ? 'success' : 'failure')
-            puts "  #{file.path.to_s} (#{file.attribute_value(@type).inspect}) was a #{result}"
+      def only(*args)
+        return @only if args.empty?
+        @only = args.flatten
+        self
+      end
+      alias_method :to, :only
+
+      def inverted
+        @inverted = true
+      end
+      alias_method :invert, :inverted
+
+      def limit(files)
+        files.select! do |file|
+          match_file(file, @only).tap do |result|
+            if GitHooks.debug?
+              result = (result ? 'success' : 'failure')
+              puts "  #{file.path} (#{file.attribute_value(@type).inspect}) was a #{result}"
+            end
           end
         end
       end
-    end
 
-  private
+    private
 
-    def match_file(file, match_value)
-      if match_value.is_a? Array
-        match_value.any? { |value| file.match(@type, value) }
-      else
-        file.match(@type, match_value)
+      def match_file(file, match_value)
+        if @inverted
+          [*match_value].none? { |value| file.match(@type, value) }
+        else
+          [*match_value].any? { |value| file.match(@type, value) }
+        end
       end
     end
   end

data/lib/githooks/runner.rb

@@ -49,7 +49,7 @@ module GitHooks
       end
 
       if script && !(options['ignore-script'] || GitHooks.ignore_script)
-        command = "#{script} #{Pathname.new($0).to_s} #{Shellwords.join(ARGV)};"
+        command = "#{script} #{Pathname.new($0)} #{Shellwords.join(ARGV)};"
         puts "Kernel#exec(#{command.inspect})" if GitHooks.verbose
         exec(command)
       elsif libpath
@@ -106,7 +106,7 @@ module GitHooks
 
       hook_phases.each do |hook|
         hook = (repo_hooks + hook).to_s
-        puts "Linking #{gitrunner.to_s} -> #{hook}" if GitHooks.verbose
+        puts "Linking #{gitrunner} -> #{hook}" if GitHooks.verbose
         FileUtils.ln_sf gitrunner.to_s, hook
       end
     end
@@ -120,10 +120,9 @@ module GitHooks
       repo = Repository.instance(repo_path)
 
       hook_phases.each do |hook|
-        if (repo_hook = repo_hooks + hook).symlink?
-          puts "Removing hook '#{hook}' from repository at: #{repo_path}" if GitHooks.verbose
-          FileUtils.rm_f repo_hook
-        end
+        next unless (repo_hook = (repo_hooks + hook)).symlink?
+        puts "Removing hook '#{hook}' from repository at: #{repo_path}" if GitHooks.verbose
+        FileUtils.rm_f repo_hook
       end
 
       active_hooks = Hook::VALID_PHASES.select { |hook| (repo_hooks + hook).exist? }
@@ -137,7 +136,7 @@ module GitHooks
     end
     module_function :detach
 
-    def list(repo_path)
+    def list(repo_path) # rubocop:disable Style/CyclomaticComplexity, Style/MethodLength
       repo_path  ||= Pathname.new(Repository.root_path)
 
       repo = Repository.instance(repo_path)
@@ -223,14 +222,15 @@ module GitHooks
     end
     module_function :run_externals
 
-    def start(options = {}) # rubocop:disable MethodLength
+    def start(options = {}) # rubocop:disable Style/CyclomaticComplexity, Style/MethodLength
       phase = options[:hook] || GitHooks.hook_name || 'pre-commit'
       puts "PHASE: #{phase}" if GitHooks.debug
 
-      if active_hook = Hook.phases[phase]
+      if (active_hook = Hook.phases[phase])
         active_hook.args            = options.delete(:args)
-        active_hook.unstaged        = options.delete(:unstaged)
+        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)
       else
         fail Error::InvalidPhase, "Hook '#{phase}' is not defined - have you registered any tests for this hook yet?"
@@ -242,10 +242,10 @@ module GitHooks
 
       sections.each do |section|
         hash_tail_length = (section_length - section.title.length)
-        printf "===== %s %s=====\n", section.colored_name(phase), ('=' * hash_tail_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\n", (index + 1), action.state_symbol, action.colored_title
+          printf "  %d. [ %s ] %s (%ds)\n", (index + 1), action.state_symbol, action.colored_title, action.benchmark
 
           action.errors.each do |error|
             printf "    %s %s\n", color_bright_red(MARK_FAILURE), error
@@ -270,9 +270,9 @@ module GitHooks
     end
     module_function :start
 
-    def load_tests(path, skip_bundler = false) # rubocop:disable MethodLength
+    def load_tests(path, skip_bundler = false) # rubocop:disable MethodLength,Style/CyclomaticComplexity
       hooks_root = Pathname.new(path).realpath
-      hooks_path = hooks_root + 'hooks'
+      hooks_path = (p = (hooks_root + 'hooks')).exist? ? p : (hooks_root + '.hooks')
       hooks_libs = hooks_root + 'libs'
       gemfile    = hooks_root + 'Gemfile'
 
@@ -285,18 +285,15 @@ module GitHooks
           # stupid RVM polluting my environment without asking via it's
           # executable-hooks gem preloading bundler. hence the following ...
           if defined? Bundler
-            [:@bundle_path, :@configured, :@definition, :@load].each do |var|
+            [:@settings, :@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
           Bundler.require(:default)
         rescue LoadError
-          puts '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
           puts "Error: #{e.message}"
@@ -306,6 +303,7 @@ module GitHooks
       end
 
       $LOAD_PATH.unshift hooks_libs.to_s
+
       Dir["#{hooks_path}/**/*.rb"].each do |lib|
         lib.gsub!('.rb', '')
         puts "Loading: #{lib}" if GitHooks.verbose