rabbitt-githooks 1.2.7

data/lib/githooks/repository.rb

@@ -0,0 +1,152 @@
+# encoding: utf-8
+=begin
+Copyright (C) 2013 Carl P. Corliss
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+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 'singleton'
+require 'open3'
+
+module GitHooks
+  class Repository
+    autoload :Config,         'githooks/repository/config'
+    autoload :File,           'githooks/repository/file'
+    autoload :Limiter,        'githooks/repository/limiter'
+    autoload :DiffIndexEntry, 'githooks/repository/diff_index_entry'
+
+    CHANGE_TYPE_SYMBOLS = {
+      added:     'A', copied:    'C',
+      deleted:   'D', modified:  'M',
+      renamed:   'R', retyped:   'T',
+      unknown:   'U', unmerged:  'X',
+      broken:    'B', untracked: '?',
+      any:       '*'
+    }.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
+
+    @__instance__ = {}
+    @__mutex__    = Mutex.new
+    def self.instance(path = Dir.getwd)
+      path = Pathname.new(path).realpath
+      strpath = path.to_s
+      return @__instance__[strpath] if @__instance__[strpath]
+
+      @__mutex__.synchronize do
+        return @__instance__[strpath] if @__instance__[strpath]
+        @__instance__[strpath] = new(path)
+      end
+    end
+
+    def self.method_missing(method, *args, &block)
+      return super unless instance.public_methods.include? method
+      instance.public_send(method, *args, &block)
+    end
+
+    attr_reader :root_path
+
+    def initialize(path = Dir.getwd)
+      @root_path = get_root_path(path)
+    end
+    protected :initialize
+
+    def config
+      @config ||= Repository::Config.new(root_path)
+    end
+
+    def git_command(*args)
+      git.execute(*args.flatten)
+    end
+
+    def get_root_path(path)
+      git_command('rev-parse', '--show-toplevel', path: path).tap do |result|
+        unless result.status.success? && result.output !~ /not a git repository/i
+          fail Error::NotAGitRepo, "Unable to find a valid git repo in #{path}"
+        end
+      end.output.strip
+    end
+
+    def stash
+      git_command(%w( stash -q --keep-index -a)).status.success?
+    end
+
+    def unstash
+      git_command(%w(stash pop -q)).status.success?
+    end
+
+    def manifest(options = {})
+      ref       = options.delete(:ref) || 'HEAD'
+      unstaged  = options.delete(:unstaged)
+      untracked = options.delete(:untracked)
+
+      return staged_manifest(ref: ref) unless unstaged || untracked
+
+      [].tap do |files|
+        files.push(*unstaged_manifest(ref: ref)) if unstaged
+        files.push(*untracked_manifest) if untracked
+      end
+    end
+
+    def staged_manifest(options = {})
+      diff_index(options.merge(unstaged: false))
+    end
+    alias_method :commit_manifest, :staged_manifest
+
+    def unstaged_manifest(options = {})
+      diff_index(options.merge(unstaged: true))
+    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
+
+  private
+
+    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'
+
+      raw_output = git_command(*cmd).output.strip
+      raw_output.split(/\n/).collect { |data| DiffIndexEntry.new(data).to_repo_file }
+    end
+
+    def git
+      @git ||= SystemUtils::Command.new('git')
+    end
+
+    def while_stashed(&block)
+      fail ArgumentError, 'Missing required block' unless block_given?
+      begin
+        stash
+        yield
+      ensure
+        unstash
+      end
+    end
+
+    def run_while_stashed(cmd)
+      while_stashed { system(cmd) }
+      $? == 0
+    end
+  end
+end

data/lib/githooks/repository/config.rb

@@ -0,0 +1,170 @@
+# encoding: utf-8
+=begin
+Copyright (C) 2013 Carl P. Corliss
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+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 '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
+
+    def [](option)
+      send(option.gsub('-', '_'))
+    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(', ')}"
+      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
+        end
+      else
+        fail ArgumentError unless Pathname.new(value).executable?
+      end
+
+      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
+
+      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
+
+    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(', ')}"
+      end
+
+      options = args.extract_options
+      repo    = options.delete(:repo_path) || repo_path
+      global  = (opt = options.delete(:global)).nil? ? false : opt
+      option  = "githooks.#{repo}.#{option}"
+
+      value_regex = args.first
+
+      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
+
+    def get(option, options = {})
+      unless OPTIONS.keys.include? option
+        fail ArgumentError, "Unexpected option '#{option}': expected one of: #{OPTIONS.keys.join(', ')}"
+      end
+
+      repo     = options[:repo_path] || repo_path
+      githooks = list(options)['githooks']
+
+      githooks[repo][option] if githooks && githooks[repo] && githooks[repo][option]
+    end
+
+    def list(options = {}) # rubocop:disable MethodLength, CyclomaticComplexity
+      repo   = options.delete(:repo_path) || repo_path
+      global = (opt = options.delete(:global)).nil? ? false : opt
+
+      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
+
+        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
+
+        hash
+      end
+    end
+
+  private
+
+    def repo_path
+      @repository.root_path
+    end
+
+    def git_command(*args)
+      args = ['config', *args].flatten
+      @repository.git_command(*args)
+    end
+
+    def git
+      @repository.git
+    end
+  end
+end

data/lib/githooks/repository/diff_index_entry.rb

@@ -0,0 +1,80 @@
+require 'ostruct'
+require 'pathname'
+
+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
+
+    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 initialize(entry)
+      unless entry =~ DIFF_STRUCTURE_REGEXP
+        fail ArgumentError, 'Unable to parse incoming diff entry 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
+      )]
+
+      {
+        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
+
+    class FileState
+      attr_reader :mode, :sha, :path
+
+      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 to_path
+        Pathname.new(@path)
+      end
+    end
+  end
+end

data/lib/githooks/repository/file.rb

@@ -0,0 +1,125 @@
+# encoding: utf-8
+=begin
+Copyright (C) 2013 Carl P. Corliss
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+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::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
+
+    def __getobj__ # rubocop:disable TrivialAccessors
+      @file
+    end
+
+    def inspect
+      attributes = [:name, :path, :type, :mode, :sha, :score].collect do |name|
+        "#{name}=#{attribute_value(name).inspect}"
+      end
+      "#<#{self.class.name} #{attributes.join(' ')} >"
+    end
+
+    def path
+      to.path || from.path
+    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"
+      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
+      end
+    end
+    # rubocop:enable CyclomaticComplexity
+
+    def fd
+      case type
+        when :deleted, :deletion then nil
+        else path.open
+      end
+    end
+
+    def realpath
+      case type
+        when :deleted, :deletion then path
+        else path.realpath
+      end
+    end
+
+    def contains?(string_or_regexp)
+      if string_or_regexp.is_a?(Regexp)
+        contents =~ string_or_regexp
+      else
+        contents.include? string_or_regexp
+      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 contents
+      return unless fd
+      fd.read
+    end
+
+    def lines(strip_newlines = false)
+      return [] unless fd
+      strip_newlines ? fd.readlines.collect(&:chomp!) : fd.readlines
+    end
+  end
+end