rails_git_hooks 0.7.0 → 0.7.2

data/lib/rails_git_hooks/core/check_result.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module GitHooks
+  class CheckResult
+    attr_reader :status, :messages, :reason
+
+    def initialize(status:, messages: [], reason: nil)
+      @status = status.to_sym
+      @messages = Array(messages).compact
+      @reason = reason&.to_sym
+    end
+
+    def self.pass(messages: [])
+      new(status: :pass, messages: messages, reason: :pass)
+    end
+
+    def self.warn(messages:, reason: :warning)
+      new(status: :warn, messages: messages, reason: reason)
+    end
+
+    def self.fail(messages:, reason: :failure)
+      new(status: :fail, messages: messages, reason: reason)
+    end
+
+    def with_status(status)
+      self.class.new(status: status, messages: messages, reason: reason)
+    end
+
+    def pass?
+      status == :pass
+    end
+
+    def warn?
+      status == :warn
+    end
+
+    def fail?
+      status == :fail
+    end
+  end
+end

data/lib/rails_git_hooks/core/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module GitHooks
+  class Error < StandardError; end
+end

data/lib/rails_git_hooks/install/installer.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module GitHooks
+  class Installer
+    def initialize(git_dir: nil)
+      if git_dir
+        @git_dir = git_dir
+        @repo = nil
+      else
+        @repo = Repository.new
+        @git_dir = @repo.git_dir
+      end
+    end
+
+    def install
+      target_dir = File.join(@git_dir, 'hooks')
+      raise GitHooks::Error, "Not a git repository or .git/hooks not found: #{@git_dir}" unless Dir.exist?(target_dir)
+
+      copy_runtime(target_dir)
+
+      hooks = hooks_enabled_in_config.select { |name| self.class.available_hook_names.include?(name) }
+      hooks.each_with_object([]) do |name, installed|
+        dest = File.join(target_dir, name)
+        File.write(dest, File.read(File.join(Constants::HOOKS_DIR, name)))
+        File.chmod(0o755, dest)
+        installed << name
+      end
+    end
+
+    def self.available_hook_names
+      Dir.children(Constants::HOOKS_DIR).select { |name| File.file?(File.join(Constants::HOOKS_DIR, name)) }
+    end
+
+    def available_hooks
+      self.class.available_hook_names
+    end
+
+    private
+
+    def repo_for_config
+      @repo_for_config ||= begin
+        root = File.dirname(@git_dir)
+        Struct.new(:root, :config_path, :local_config_path).new(
+          root,
+          File.join(root, Constants::CONFIG_FILE),
+          File.join(root, Constants::CONFIG_FILE_LOCAL)
+        )
+      end
+    end
+
+    def hooks_enabled_in_config
+      override_config = OverrideConfig.new(repo: repo_for_config)
+      effective = override_config.effective_config(CheckRegistry.all)
+      effective.each_with_object([]) do |(section_name, check_configs), out|
+        hook_name = Constants::SECTION_TO_HOOK[section_name]
+        next unless hook_name && self.class.available_hook_names.include?(hook_name)
+
+        out << hook_name if check_configs.values.any? { |cfg| cfg['enabled'] == true }
+      end.uniq
+    end
+
+    def copy_runtime(target_dir)
+      runtime_dir = File.join(target_dir, Constants::RUNTIME_DIR_NAME)
+      FileUtils.rm_rf(runtime_dir)
+      FileUtils.mkdir_p(runtime_dir)
+
+      Dir.glob(File.join(Constants::RUNTIME_SOURCE_DIR, '**', '*')).each do |src|
+        next unless File.file?(src)
+
+        rel = src.sub(%r{\A#{Regexp.escape(Constants::RUNTIME_SOURCE_DIR)}/}, '')
+        dest = File.join(runtime_dir, rel)
+        FileUtils.mkdir_p(File.dirname(dest))
+        File.write(dest, File.read(src))
+      end
+    end
+  end
+end

data/lib/rails_git_hooks/runtime/check_registry.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module GitHooks
+  class CheckRegistry
+    CHECK_CLASSES = [
+      Checks::PreCommit::DefaultBranch,
+      Checks::PreCommit::DebuggerCheck,
+      Checks::PreCommit::YAMLFormatCheck,
+      Checks::PreCommit::JSONFormatCheck,
+      Checks::PreCommit::MigrationsCheck,
+      Checks::PreCommit::WhitespaceCheck,
+      Checks::PreCommit::RuboCop,
+      Checks::CommitMsg::JiraPrefix,
+      Checks::PrePush::RunTests,
+      Checks::PostCheckout::BundleInstall,
+      Checks::PostCheckout::DbMigrate,
+      Checks::PostMerge::BundleInstall,
+      Checks::PostMerge::DbMigrate
+    ].freeze
+
+    def self.all
+      CHECK_CLASSES.map(&:definition)
+    end
+
+    def self.for(hook_name)
+      all.select { |definition| definition.hook == hook_name.to_sym }
+    end
+
+    def self.find!(key)
+      all.find { |definition| definition.key == key } || raise(GitHooks::Error, "Unknown check: #{key}")
+    end
+  end
+end

data/lib/rails_git_hooks/runtime/dependency_checker.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module GitHooks
+  class DependencyChecker
+    def initialize(repo:)
+      @repo = repo
+    end
+
+    def check(config)
+      dependencies = config.fetch('dependencies', {})
+      missing = []
+
+      Array(dependencies['executables']).each do |name|
+        missing << "missing executable: #{name}" unless executable_available?(name)
+      end
+
+      Array(dependencies['libraries']).each do |name|
+        missing << "missing library: #{name}" unless library_available?(name)
+      end
+
+      Array(dependencies['files']).each do |name|
+        path = File.expand_path(name, @repo.root)
+        missing << "missing file: #{name}" unless File.exist?(path)
+      end
+
+      return CheckResult.pass if missing.empty?
+
+      hint = config['install_hint']
+      messages = missing.dup
+      messages << hint if hint && !hint.empty?
+      CheckResult.fail(messages: messages, reason: :missing_dependency)
+    end
+
+    private
+
+    def executable_available?(name)
+      return File.executable?(File.expand_path(name, @repo.root)) if name.include?(File::SEPARATOR)
+
+      ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).any? do |dir|
+        File.executable?(File.join(dir, name))
+      end
+    end
+
+    def library_available?(name)
+      require name
+      true
+    rescue LoadError
+      false
+    end
+  end
+end

data/lib/rails_git_hooks/runtime/file_matcher.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module GitHooks
+  module FileMatcher
+    FLAGS = File::FNM_PATHNAME | File::FNM_DOTMATCH | File::FNM_EXTGLOB
+
+    module_function
+
+    def filter(paths, include_patterns:, exclude_patterns:)
+      filtered = if include_patterns.empty?
+                   paths
+                 else
+                   paths.select { |path| matches_any?(path, include_patterns) }
+                 end
+
+      filtered.reject { |path| matches_any?(path, exclude_patterns) }
+    end
+
+    def matches_any?(path, patterns)
+      Array(patterns).any? { |pattern| File.fnmatch?(pattern, path, FLAGS) }
+    end
+  end
+end

data/lib/rails_git_hooks/runtime/override_config.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'yaml'
+
+require_relative '../config/defaults_loader'
+
+module GitHooks
+  class OverrideConfig
+    BOOLEAN_OPTIONS = %w[enabled quiet].freeze
+    POLICY_OPTIONS = %w[on_fail on_warn on_missing_dependency].freeze
+
+    def initialize(repo:)
+      @repo = repo
+    end
+
+    def load
+      main = load_file(@repo.config_path)
+      local = load_file(@repo.local_config_path)
+      deep_merge(main, local)
+    end
+
+    def config_for(definition)
+      base = DefaultsLoader.config_for(definition.hook_section, definition.config_name) || definition.default_config
+      data = load
+      section = data.fetch(definition.hook_section, {})
+      merged = deep_merge(base, section.fetch('ALL', {}))
+      deep_merge(merged, section.fetch(definition.config_name, {}))
+    end
+
+    def effective_config(registry)
+      registry.group_by(&:hook_section).transform_values do |definitions|
+        definitions.to_h { |definition| [definition.config_name, config_for(definition)] }
+      end
+    end
+
+    def set_option(definition, option, value)
+      data = load_file(@repo.config_path)
+      section = data[definition.hook_section] ||= {}
+      section[definition.config_name] ||= {}
+
+      normalized = normalize_value(option, value)
+      base = DefaultsLoader.config_for(definition.hook_section, definition.config_name) || definition.default_config
+      default_value = base[option]
+
+      if normalized == default_value
+        section[definition.config_name].delete(option)
+      else
+        section[definition.config_name][option] = normalized
+      end
+
+      cleanup_empty_nodes!(data, definition)
+      write(data)
+    end
+
+    def init
+      return if File.exist?(@repo.config_path)
+
+      File.write(@repo.config_path, <<~YAML)
+        # rails_git_hooks overrides
+        #
+        # Example:
+        # PreCommit:
+        #   RuboCop:
+        #     enabled: true
+        #     on_fail: fail
+      YAML
+    end
+
+    private
+
+    def load_file(path)
+      return {} unless File.exist?(path)
+
+      deep_stringify(YAML.safe_load(File.read(path), aliases: true) || {})
+    end
+
+    def write(data)
+      if data.empty?
+        FileUtils.rm_f(@repo.config_path)
+      else
+        File.write(@repo.config_path, YAML.dump(data))
+      end
+    end
+
+    def cleanup_empty_nodes!(data, definition)
+      section = data.fetch(definition.hook_section, {})
+      section.delete(definition.config_name) if section.fetch(definition.config_name, {}).empty?
+      data.delete(definition.hook_section) if section.empty?
+    end
+
+    def normalize_value(option, value)
+      case option
+      when *BOOLEAN_OPTIONS
+        parse_boolean(value)
+      when *POLICY_OPTIONS
+        value.to_s
+      else
+        value
+      end
+    end
+
+    def parse_boolean(value)
+      return value if [true, false].include?(value)
+
+      case value.to_s
+      when 'true', 'yes', 'on', '1' then true
+      when 'false', 'no', 'off', '0' then false
+      else
+        raise GitHooks::Error, "Invalid boolean value: #{value.inspect}"
+      end
+    end
+
+    def deep_merge(base, override)
+      base.merge(override) do |_key, old, new|
+        old.is_a?(Hash) && new.is_a?(Hash) ? deep_merge(old, new) : new
+      end
+    end
+
+    def deep_stringify(value)
+      case value
+      when Hash
+        value.each_with_object({}) { |(key, nested), out| out[key.to_s] = deep_stringify(nested) }
+      when Array
+        value.map { |nested| deep_stringify(nested) }
+      else
+        value
+      end
+    end
+  end
+end

data/lib/rails_git_hooks/runtime/policy_resolver.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module GitHooks
+  class PolicyResolver
+    VALID_FAIL_POLICIES = %w[fail warn pass].freeze
+    VALID_WARN_POLICIES = %w[warn fail pass].freeze
+
+    def resolve(result, config)
+      policy = policy_for(result, config)
+      return result if policy == result.status.to_s
+
+      result.with_status(policy.to_sym)
+    end
+
+    private
+
+    def policy_for(result, config)
+      case result.reason
+      when :missing_dependency
+        validate(config.fetch('on_missing_dependency', 'warn'), VALID_FAIL_POLICIES)
+      else
+        case result.status
+        when :fail then validate(config.fetch('on_fail', 'fail'), VALID_FAIL_POLICIES)
+        when :warn then validate(config.fetch('on_warn', 'warn'), VALID_WARN_POLICIES)
+        else 'pass'
+        end
+      end
+    end
+
+    def validate(value, valid_values)
+      return value if valid_values.include?(value)
+
+      raise GitHooks::Error, "Invalid policy value: #{value.inspect}"
+    end
+  end
+end

data/lib/rails_git_hooks/runtime/repository.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module GitHooks
+  class Repository
+    attr_reader :root, :git_dir
+
+    def initialize(start_dir = Dir.pwd)
+      @root, @git_dir = resolve_paths(start_dir)
+    end
+
+    def config_path
+      File.join(root, Constants::CONFIG_FILE)
+    end
+
+    def local_config_path
+      File.join(root, Constants::CONFIG_FILE_LOCAL)
+    end
+
+    def hook_runtime_dir(hooks_dir)
+      File.join(hooks_dir, Constants::RUNTIME_DIR_NAME)
+    end
+
+    def git(*args)
+      stdout, status = Open3.capture2e('git', *args, chdir: root)
+      [stdout, status]
+    end
+
+    def git_output(*args)
+      stdout, status = git(*args)
+      raise GitHooks::Error, stdout.strip unless status.success?
+
+      stdout
+    end
+
+    def current_branch
+      git_output('rev-parse', '--abbrev-ref', 'HEAD').strip
+    end
+
+    def staged_files
+      git_output('diff', '--cached', '--name-only').split("\n").map(&:strip).reject(&:empty?)
+    end
+
+    def changed_files(ref1, ref2)
+      git_output('diff', '--name-only', ref1.to_s, ref2.to_s).split("\n").map(&:strip).reject(&:empty?)
+    end
+
+    private
+
+    def resolve_paths(start_dir)
+      dir = File.expand_path(start_dir)
+      loop do
+        git_entry = File.join(dir, '.git')
+        if File.directory?(git_entry)
+          return [dir, git_entry]
+        elsif File.file?(git_entry)
+          git_dir = File.expand_path(File.read(git_entry).strip.sub(/\Agitdir: \s*/, ''), dir)
+          return [dir, git_dir]
+        end
+
+        parent = File.dirname(dir)
+        raise GitHooks::Error, 'Not inside a git repository' if parent == dir
+
+        dir = parent
+      end
+    end
+  end
+end

data/lib/rails_git_hooks/runtime/runner.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module GitHooks
+  class Runner
+    def initialize(repo:, hook_name:, argv:, stdin:)
+      @repo = repo
+      @hook_name = hook_name.to_sym
+      @argv = argv
+      @stdin = stdin
+      @overrides = OverrideConfig.new(repo: repo)
+      @dependencies = DependencyChecker.new(repo: repo)
+      @policy = PolicyResolver.new
+    end
+
+    def run
+      failed = false
+
+      CheckRegistry.for(@hook_name).each do |definition|
+        config = @overrides.config_for(definition)
+        next unless config['enabled']
+
+        context = {
+          repo: @repo,
+          argv: @argv,
+          stdin: @stdin,
+          applicable_files: applicable_files_for(config)
+        }
+
+        raw_result = @dependencies.check(config)
+        raw_result = definition.klass.new(config: config, context: context).run if raw_result.pass?
+        final_result = @policy.resolve(raw_result, config)
+
+        print_result(definition, final_result, quiet: config['quiet'])
+        failed ||= final_result.fail?
+      end
+
+      failed ? 1 : 0
+    end
+
+    private
+
+    def applicable_files_for(config)
+      return [] unless config['file_based']
+
+      FileMatcher.filter(
+        modified_files,
+        include_patterns: Array(config['include']),
+        exclude_patterns: Array(config['exclude'])
+      )
+    end
+
+    def modified_files
+      @modified_files ||= case @hook_name
+                          when :pre_commit then @repo.staged_files
+                          when :post_checkout
+                            argv[2] == '1' ? @repo.changed_files(argv[0], argv[1]) : []
+                          when :post_merge
+                            @repo.changed_files('ORIG_HEAD', 'HEAD')
+                          else []
+                          end
+    end
+
+    def print_result(definition, result, quiet:)
+      return if result.pass? && quiet
+      return if result.pass? && result.messages.empty?
+
+      case result.status
+      when :warn
+        warn ''
+        warn "Warning (#{definition.config_name}):"
+      when :fail
+        warn ''
+        warn "Commit rejected (#{definition.config_name}):"
+      end
+
+      result.messages.each { |message| warn "  #{message}" } unless result.pass?
+      warn '' unless result.pass?
+    end
+  end
+end

data/lib/rails_git_hooks/runtime.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'config/constants'
+require_relative 'core/error'
+require_relative 'core/check_result'
+require_relative 'core/check_definition'
+require_relative 'runtime/repository'
+require_relative 'runtime/file_matcher'
+require_relative 'runtime/dependency_checker'
+require_relative 'runtime/policy_resolver'
+require_relative 'runtime/override_config'
+require_relative 'checks'
+require_relative 'runtime/check_registry'
+require_relative 'runtime/runner'
+
+module GitHooks
+  module Runtime
+    module_function
+
+    def execute(hook_name, argv: [], stdin: '')
+      repo = Repository.new
+      Runner.new(repo: repo, hook_name: hook_name, argv: argv, stdin: stdin).run
+    end
+  end
+end

data/lib/rails_git_hooks/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GitHooks
-  VERSION = '0.7.0'
+  VERSION = '0.7.2'
 end

data/lib/rails_git_hooks.rb

@@ -1,9 +1,17 @@
 # frozen_string_literal: true
 
 require_relative 'rails_git_hooks/version'
-require_relative 'rails_git_hooks/constants'
-require_relative 'rails_git_hooks/installer'
-
-module GitHooks
-  class Error < StandardError; end
-end
+require_relative 'rails_git_hooks/core/error'
+require_relative 'rails_git_hooks/config/constants'
+require_relative 'rails_git_hooks/core/check_result'
+require_relative 'rails_git_hooks/core/check_definition'
+require_relative 'rails_git_hooks/runtime/repository'
+require_relative 'rails_git_hooks/runtime/file_matcher'
+require_relative 'rails_git_hooks/runtime/dependency_checker'
+require_relative 'rails_git_hooks/runtime/policy_resolver'
+require_relative 'rails_git_hooks/runtime/override_config'
+require_relative 'rails_git_hooks/checks'
+require_relative 'rails_git_hooks/runtime/check_registry'
+require_relative 'rails_git_hooks/runtime/runner'
+require_relative 'rails_git_hooks/install/installer'
+require_relative 'rails_git_hooks/runtime'

data/templates/hooks/commit-msg

@@ -1,23 +1,13 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-#
-# Git commit-msg hook: prepends [TICKET] when branch contains a Jira-style ticket.
-# Logic in templates/shared/commit_msg/.
-
-# Bootstrap: resolve .git dir and skip if hook is disabled
-repo_root = Dir.pwd
-git_dir = File.join(repo_root, '.git')
-git_dir = File.expand_path(File.read(git_dir).strip.sub(/\Agitdir: \s*/, ''), repo_root) if File.file?(git_dir)
-disabled_file = File.join(git_dir, 'rails_git_hooks_disabled')
-if File.exist?(disabled_file)
-  disabled = File.read(disabled_file).split("\n").map(&:strip)
-  exit 0 if disabled.include?('*') || disabled.include?('commit-msg')
+hooks_dir = File.dirname(File.expand_path(__FILE__))
+begin
+  require 'bundler/setup'
+rescue LoadError, StandardError
+  nil
 end
 
-module RailsGitHooks
-end
-RailsGitHooks.const_set(:GIT_DIR, git_dir.freeze)
-hooks_dir = File.dirname(File.expand_path(__FILE__))
+require File.join(hooks_dir, 'rails_git_hooks', 'runtime')
 
-load File.join(hooks_dir, 'commit_msg', 'jira_prefix.rb')
+exit GitHooks::Runtime.execute(:commit_msg, argv: ARGV, stdin: $stdin.read)

data/templates/hooks/post-checkout

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+hooks_dir = File.dirname(File.expand_path(__FILE__))
+begin
+  require 'bundler/setup'
+rescue LoadError, StandardError
+  nil
+end
+
+require File.join(hooks_dir, 'rails_git_hooks', 'runtime')
+
+exit GitHooks::Runtime.execute(:post_checkout, argv: ARGV, stdin: $stdin.read)

data/templates/hooks/post-merge

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+hooks_dir = File.dirname(File.expand_path(__FILE__))
+begin
+  require 'bundler/setup'
+rescue LoadError, StandardError
+  nil
+end
+
+require File.join(hooks_dir, 'rails_git_hooks', 'runtime')
+
+exit GitHooks::Runtime.execute(:post_merge, argv: ARGV, stdin: $stdin.read)