rabbitt-githooks 1.2.7 → 1.3.0

data/lib/githooks/core_ext/process.rb

@@ -1,7 +1,9 @@
-class Process::Status
-  def failed?
-    !success?
+module Process
+  class Status
+    def failed?
+      !success?
+    end
+    alias_method :fail?, :failed?
+    alias_method :failure?, :failed?
   end
-  alias_method :fail?, :failed?
-  alias_method :failure?, :failed?
 end

data/lib/githooks/hook.rb

@@ -63,19 +63,24 @@ module GitHooks
     end
 
     attr_reader :sections, :phase, :repository, :repository_path
-    attr_accessor :args, :unstaged, :untracked
+    attr_accessor :args, :staged, :untracked, :tracked
 
     def initialize(phase)
       @phase     = phase
-      @sections  = []
+      @sections  = {}
       @commands  = []
       @args      = []
-      @unstaged  = false
+      @staged    = true
+      @tracked   = false
       @untracked = false
 
       repository_path = Dir.getwd # rubocop:disable UselessAssignment
     end
 
+    def [](name)
+      @sections[name]
+    end
+
     def repository_path=(path)
       @repository = Repository.new(path)
     end
@@ -86,7 +91,7 @@ module GitHooks
 
     def run
       # only run sections that have actions matching files in the manifest
-      runable_sections = @sections.select { |section| !section.actions.empty? }
+      runable_sections = sections.select { |section| !section.actions.empty? }
       runable_sections.collect { |section| section.run }.all?
     end
 
@@ -111,6 +116,10 @@ module GitHooks
       @commands.select { |command| command.aliases.include? name.to_s }.first
     end
 
+    def sections
+      @sections.values
+    end
+
     # DSL methods
 
     def command(name, options = {})
@@ -123,7 +132,14 @@ module GitHooks
     end
 
     def section(name, &block)
-      @sections << Section.new(name, self, &block)
+      key_name = Section.key_from_name(name)
+      return @sections[key_name] unless block_given?
+
+      if @sections.include? key_name
+        @sections[key_name].instance_eval(&block)
+      else
+        @sections[key_name] ||= Section.new(name, self, &block)
+      end
       self
     end
 
@@ -141,8 +157,9 @@ module GitHooks
 
       def manifest
         @files ||= repo.manifest(
-          untracked: hook.untracked,
-          unstaged:  hook.unstaged
+          staged:    hook.staged,
+          tracked:   hook.tracked,
+          untracked: hook.untracked
         )
       end
 

data/lib/githooks/repository.rb

@@ -22,7 +22,7 @@ require 'singleton'
 require 'open3'
 
 module GitHooks
-  class Repository
+  class Repository # rubocop:disable ClassLength
     autoload :Config,         'githooks/repository/config'
     autoload :File,           'githooks/repository/file'
     autoload :Limiter,        'githooks/repository/limiter'
@@ -34,12 +34,12 @@ module GitHooks
       renamed:   'R', retyped:   'T',
       unknown:   'U', unmerged:  'X',
       broken:    'B', untracked: '?',
-      any:       '*'
+      any:       '*', tracked:   '^'
     }.freeze unless defined? CHANGE_TYPE_SYMBOLS
 
     CHANGE_TYPES = CHANGE_TYPE_SYMBOLS.invert.freeze unless defined? CHANGE_TYPES
 
-    DEFAULT_DIFF_INDEX_OPTIONS = { staged: true, ref: 'HEAD' } unless defined? DEFAULT_DIFF_INDEX_OPTIONS
+    DEFAULT_DIFF_INDEX_OPTIONS = { staged: true } unless defined? DEFAULT_DIFF_INDEX_OPTIONS
 
     @__instance__ = {}
     @__mutex__    = Mutex.new
@@ -91,28 +91,39 @@ module GitHooks
     end
 
     def manifest(options = {})
-      ref       = options.delete(:ref) || 'HEAD'
-      unstaged  = options.delete(:unstaged)
-      untracked = options.delete(:untracked)
+      ref = options.delete(:ref)
 
-      return staged_manifest(ref: ref) unless unstaged || untracked
+      return staged_manifest(ref: ref) if options.delete(:staged)
 
-      [].tap do |files|
-        files.push(*unstaged_manifest(ref: ref)) if unstaged
-        files.push(*untracked_manifest) if untracked
-      end
+      files = unstaged_manifest(ref: ref)
+
+      tracked_manifest(ref: ref).each do |file|
+        files << file unless files.index { |f| f.path.to_s == file.path.to_s }
+      end if options.delete(:tracked)
+
+      untracked_manifest(ref: ref).each do |file|
+        files << file unless files.index { |f| f.path.to_s == file.path.to_s }
+      end if options.delete(:untracked)
+
+      files.sort_by! { |f| f.path.to_s }
+      files.uniq { |f| f.path.to_s }
     end
 
     def staged_manifest(options = {})
-      diff_index(options.merge(unstaged: false))
+      diff_index(options.merge(staged: true))
     end
     alias_method :commit_manifest, :staged_manifest
 
     def unstaged_manifest(options = {})
-      diff_index(options.merge(unstaged: true))
+      diff_index(options.merge(staged: false))
     end
 
-    def untracked_manifest
+    def tracked_manifest(*)
+      files = git_command('ls-files', '--exclude-standard').output.strip.split(/\s*\n\s*/)
+      files.collect { |path| DiffIndexEntry.from_file_path(path, true).to_repo_file }
+    end
+
+    def untracked_manifest(*)
       files = git_command('ls-files', '--others', '--exclude-standard').output.strip.split(/\s*\n\s*/)
       files.collect { |path| DiffIndexEntry.from_file_path(path).to_repo_file }
     end
@@ -122,11 +133,17 @@ module GitHooks
     def diff_index(options = {})
       options = DEFAULT_DIFF_INDEX_OPTIONS.merge(options)
 
-      cmd = %w(diff-index -C -M -B)
-      cmd << '--cached' unless options[:unstaged]
-      cmd << options.delete(:ref) || 'HEAD'
+      if $stdout.tty? && !options[:staged]
+        cmd = %w(diff-files -C -M -B)
+      else
+        cmd = %w(diff-index -C -M -B)
+        cmd << '--cached' if options[:staged]
+        cmd << (options.delete(:ref) || 'HEAD')
+      end
+
+      cmd.compact!
 
-      raw_output = git_command(*cmd).output.strip
+      raw_output = git_command(*cmd.compact).output.strip
       raw_output.split(/\n/).collect { |data| DiffIndexEntry.new(data).to_repo_file }
     end
 

data/lib/githooks/repository/config.rb

@@ -22,149 +22,156 @@ require 'singleton'
 require 'open3'
 
 module GitHooks
-  class Repository::Config # rubocop:disable ClassLength
-    OPTIONS = {
-      'path' => { type: :path, multiple: false },
-      'script' => { type: :path, multiple: false },
-      'pre-run-execute' => { type: :path, multiple: true },
-      'post-run-execute' => { type: :path, multiple: true }
-    }
-
-    def initialize(path = Dir.getwd)
-      @repository = Repository.instance(path)
-    end
-
-    OPTIONS.keys.each do |name|
-      method_name = name.gsub(/-/, '_')
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def #{method_name}(options = {})
-          result = get('#{name}', options)
-          OPTIONS['#{name}'][:multiple] ? [result].flatten.compact : result
-        end
-      EOS
-    end
+  class Repository
+    class Config # rubocop:disable ClassLength
+      OPTIONS = {
+        'path' => { type: :path, multiple: false },
+        'script' => { type: :path, multiple: false },
+        'pre-run-execute' => { type: :path, multiple: true },
+        'post-run-execute' => { type: :path, multiple: true }
+      }
+
+      def initialize(path = Dir.getwd)
+        @repository = Repository.instance(path)
+      end
 
-    def [](option)
-      send(option.gsub('-', '_'))
-    end
+      OPTIONS.keys.each do |name|
+        method_name = name.gsub(/-/, '_')
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{method_name}(options = {})
+            result = get('#{name}', options)
+            OPTIONS['#{name}'][:multiple] ? [result].flatten.compact : result
+          end
+        EOS
+      end
 
-    def set(option, value, options = {}) # rubocop:disable CyclomaticComplexity, MethodLength
-      unless OPTIONS.keys.include? option
-        fail ArgumentError, "Unexpected option '#{option}': expected one of: #{OPTIONS.keys.join(', ')}"
+      def [](option)
+        send(option.gsub('-', '_'))
       end
 
-      repo      = options.delete(:repo_path) || repo_path
-      global    = (opt = options.delete(:global)).nil? ? false : opt
-      var_type  = "--#{OPTIONS[option][:type]}"
-      add_type  = OPTIONS[option][:multiple] ? '--add' : '--replace-all'
-      overwrite = !!options.delete(:overwrite)
-
-      if option == 'path'
-        new_path = Pathname.new(value)
-        errors = []
-        errors << 'path must be a real location' unless new_path.exist?
-        errors << 'path must be a directory' unless new_path.directory?
-        errors << 'path must have a hooks directory in it' unless (new_path + 'hooks').exist?
-
-        if errors.size > 0
-          puts "Unable to change githooks path for [#{repo}]:"
-          errors.each { |error| puts "  #{error}" }
-          fail ArgumentError
+      def set(option, value, options = {}) # rubocop:disable CyclomaticComplexity, MethodLength
+        unless OPTIONS.keys.include? option
+          fail ArgumentError, "Unexpected option '#{option}': expected one of: #{OPTIONS.keys.join(', ')}"
+        end
+
+        repo      = options.delete(:repo_path) || repo_path
+        global    = (opt = options.delete(:global)).nil? ? false : opt
+        var_type  = "--#{OPTIONS[option][:type]}"
+        add_type  = OPTIONS[option][:multiple] ? '--add' : '--replace-all'
+        overwrite = !!options.delete(:overwrite)
+
+        if option == 'path'
+          new_path = Pathname.new(value)
+          errors = []
+          errors << 'path must be a real location' unless new_path.exist?
+          errors << 'path must be a directory' unless new_path.directory?
+          unless (new_path + 'hooks').exist? || (new_path + '.hooks').exist?
+            errors << 'path must have a hooks or .hooks directory in it'
+          end
+
+          if errors.size > 0
+            puts "Unable to change githooks path for [#{repo}]:"
+            errors.each { |error| puts "  #{error}" }
+            fail ArgumentError
+          end
+        else
+          fail ArgumentError unless Pathname.new(value).executable?
         end
-      else
-        fail ArgumentError unless Pathname.new(value).executable?
-      end
 
-      value = Pathname.new(value).realpath.to_s
+        value = Pathname.new(value).realpath.to_s
 
-      if overwrite && !self[option].nil? && !self[option].empty?
-        puts "Overwrite requested for option '#{option}'" if GitHooks.verbose
-        unset(option, repo_path: repo, global: global)
-      end
+        if overwrite && !self[option].nil? && !self[option].empty?
+          puts "Overwrite requested for option '#{option}'" if GitHooks.verbose
+          unset(option, repo_path: repo, global: global)
+        end
 
-      option = "githooks.#{repo}.#{option}"
-      git_command(global ? '--global' : '--local', var_type, add_type, option, value, path: repo).tap do |result|
-        puts "Added option #{option} with value #{value}" if result.status.success?
+        option = "githooks.#{repo}.#{option}"
+        git_command(global ? '--global' : '--local', var_type, add_type, option, value, path: repo).tap do |result|
+          puts "Added option #{option} with value #{value}" if result.status.success?
+        end
       end
-    end
 
-    def remove_section(options = {})
-      repo   = options.delete(:repo_path) || repo_path
-      global = (opt = options.delete(:global)).nil? ? false : opt
-      option = "githooks.#{repo}"
-      git_command(global ? '--global' : '--local', '--remove-section', option, path: repo)
-    end
-
-    def unset(option, *args)
-      unless OPTIONS.keys.include? option
-        fail ArgumentError, "Unexpected option '#{option}': expected one of: #{OPTIONS.keys.join(', ')}"
+      def remove_section(options = {})
+        repo   = options.delete(:repo_path) || repo_path
+        global = (opt = options.delete(:global)).nil? ? false : opt
+        option = "githooks.#{repo}"
+        git_command(global ? '--global' : '--local', '--remove-section', option, path: repo)
       end
 
-      options = args.extract_options
-      repo    = options.delete(:repo_path) || repo_path
-      global  = (opt = options.delete(:global)).nil? ? false : opt
-      option  = "githooks.#{repo}.#{option}"
+      def unset(option, *args) # rubocop:disable Style/CyclomaticComplexity
+        unless OPTIONS.keys.include? option
+          fail ArgumentError, "Unexpected option '#{option}': expected one of: #{OPTIONS.keys.join(', ')}"
+        end
 
-      value_regex = args.first
+        options = args.extract_options
+        repo    = options.delete(:repo_path) || repo_path
+        global  = (opt = options.delete(:global)).nil? ? false : opt
+        option  = "githooks.#{repo}.#{option}"
 
-      if options.delete(:all) || value_regex.nil?
-        git_command(global ? '--global' : '--local', '--unset-all', option, path: repo)
-      else
-        git_command(global ? '--global' : '--local', '--unset', option, value_regex, path: repo)
-      end.tap do |result|
-        puts "Unset option #{option.git_option_path_split.last}" if result.status.success?
-      end
-    end
+        value_regex = args.first
 
-    def get(option, options = {})
-      unless OPTIONS.keys.include? option
-        fail ArgumentError, "Unexpected option '#{option}': expected one of: #{OPTIONS.keys.join(', ')}"
+        if options.delete(:all) || value_regex.nil?
+          git_command(global ? '--global' : '--local', '--unset-all', option, path: repo)
+        else
+          git_command(global ? '--global' : '--local', '--unset', option, value_regex, path: repo)
+        end.tap do |result|
+          puts "Unset option #{option.git_option_path_split.last}" if result.status.success?
+        end
       end
 
-      repo     = options[:repo_path] || repo_path
-      githooks = list(options)['githooks']
+      def get(option, options = {})
+        unless OPTIONS.keys.include? option
+          fail ArgumentError, "Unexpected option '#{option}': expected one of: #{OPTIONS.keys.join(', ')}"
+        end
 
-      githooks[repo][option] if githooks && githooks[repo] && githooks[repo][option]
-    end
+        repo     = options[:repo_path] || repo_path
+        githooks = list(options)['githooks']
 
-    def list(options = {}) # rubocop:disable MethodLength, CyclomaticComplexity
-      repo   = options.delete(:repo_path) || repo_path
-      global = (opt = options.delete(:global)).nil? ? false : opt
+        githooks[repo][option] if githooks && githooks[repo] && githooks[repo][option]
+      end
 
-      config_list = git_command('--list', global ? '--global' : '--local', path: repo).output.split(/\n/)
-      config_list.inject({}) do |hash, line|
-        key, value = line.split(/\s*=\s*/)
-        key_parts = key.git_option_path_split
+      def list(options = {})
+        config(options.delete(:repo_path) || repo_path)
+      end
 
-        ptr = hash[key_parts.shift] ||= {} # rubocop:disable IndentationWidth
-        while key_parts.size > 1 && (part = key_parts.shift)
-          ptr = ptr[part] ||= {} # rubocop:disable IndentationWidth
-        end
+    private
 
-        key = key_parts.shift
-        case ptr[key]
-          when nil then ptr[key] = value
-          when Array then ptr[key] << value
-          else ptr[key] = [ptr[key], value].flatten
-        end
+      def repo_path
+        @repository.root_path
+      end
 
-        hash
+      def git_command(*args)
+        args = ['config', *args].flatten
+        @repository.git_command(*args)
       end
-    end
 
-  private
+      def config(path = nil) # rubocop:disable MethodLength, CyclomaticComplexity
+        path ||= repo_path
 
-    def repo_path
-      @repository.root_path
-    end
+        raw_config = git_command('--list', path: path).output.split("\n")
+        raw_config.sort.uniq.inject({}) do |hash, line|
+          key, value = line.split(/\s*=\s*/)
+          key_parts = key.git_option_path_split
 
-    def git_command(*args)
-      args = ['config', *args].flatten
-      @repository.git_command(*args)
-    end
+          ptr = hash[key_parts.shift] ||= {} # rubocop:disable IndentationWidth
+          while key_parts.size > 1 && (part = key_parts.shift)
+            ptr = ptr[part] ||= {} # rubocop:disable IndentationWidth
+          end
+
+          key = key_parts.shift
+          case ptr[key]
+            when nil then ptr[key] = value
+            when Array then ptr[key] << value
+            else ptr[key] = [ptr[key], value].flatten
+          end
 
-    def git
-      @repository.git
+          hash
+        end
+      end
+
+      def git
+        @repository.git
+      end
     end
   end
 end