rails_git_hooks 0.7.0 → 0.7.1

data/lib/rails_git_hooks/checks/pre_commit/yaml_format_check.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module GitHooks
+  module Checks
+    module PreCommit
+      class YAMLFormatCheck < Base
+        check_definition key: 'yaml-format-check',
+                         hook: :pre_commit,
+                         description: 'Warn on invalid YAML',
+                         file_based: true,
+                         on_fail: :warn
+
+        def run
+          warnings = []
+
+          applicable_files.each do |path|
+            next unless File.file?(path)
+            next unless %w[.yml .yaml].include?(File.extname(path))
+
+            YAML.load_file(path)
+          rescue Psych::SyntaxError => e
+            location = e.line ? "#{path}:#{e.line}" : path
+            warnings << "#{location}: #{e.message}"
+          end
+
+          warnings.empty? ? CheckResult.pass : CheckResult.fail(messages: warnings)
+        end
+      end
+    end
+  end
+end

data/lib/rails_git_hooks/checks/pre_commit.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module GitHooks
+  module Checks
+    module PreCommit
+    end
+  end
+end
+
+require_relative 'pre_commit/default_branch'
+require_relative 'pre_commit/debugger_check'
+require_relative 'pre_commit/yaml_format_check'
+require_relative 'pre_commit/json_format_check'
+require_relative 'pre_commit/migrations_check'
+require_relative 'pre_commit/whitespace_check'
+require_relative 'pre_commit/rubocop'

data/lib/rails_git_hooks/checks/pre_push/run_tests.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module GitHooks
+  module Checks
+    module PrePush
+      class RunTests < Base
+        check_definition key: 'run-tests',
+                         hook: :pre_push,
+                         description: 'Run test suite before push',
+                         dependencies: { 'executables' => ['bundle'] },
+                         command: %w[bundle exec rspec],
+                         install_hint: 'Install test dependencies and ensure `bundle exec rspec` runs successfully'
+
+        def run
+          output, status = capture(*Array(config['command']))
+          return CheckResult.pass if status.success?
+
+          messages = output.split("\n").map(&:rstrip).reject(&:empty?)
+          CheckResult.fail(messages: messages)
+        end
+      end
+    end
+  end
+end

data/lib/rails_git_hooks/checks/pre_push.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module GitHooks
+  module Checks
+    module PrePush
+    end
+  end
+end
+
+require_relative 'pre_push/run_tests'

data/lib/rails_git_hooks/checks.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'checks/base'
+require_relative 'checks/pre_commit'
+require_relative 'checks/commit_msg'
+require_relative 'checks/pre_push'

data/lib/rails_git_hooks/cli.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
 require 'rails_git_hooks'
+require 'yaml'
 
 module GitHooks
   class CLI
-    FEATURE_FLAG_TOKENS = GitHooks::Constants::FEATURE_FLAG_FILES.keys.freeze
-
     def self.run(argv = ARGV)
       new.run(argv)
     end
@@ -16,12 +15,16 @@ module GitHooks
         run_install(argv[1..])
       when 'list'
         run_list
+      when 'init'
+        run_init
       when 'disable'
         run_disable(argv[1..])
       when 'enable'
         run_enable(argv[1..])
-      when 'disabled'
-        run_disabled
+      when 'set'
+        run_set(argv[1..])
+      when 'show-config'
+        run_show_config
       when nil, '-h', '--help'
         print_help
       else
@@ -43,91 +46,107 @@ module GitHooks
     end
 
     def run_list
-      puts "Available hooks: #{Installer.available_hook_names.join(', ')}"
+      repo = Repository.new
+      config = OverrideConfig.new(repo: repo)
+
+      puts 'Available hooks:'
+      Installer.available_hook_names.each { |name| puts "  #{name}" }
+      puts
+      puts 'Available checks:'
+      CheckRegistry.all.each do |definition|
+        check_config = config.config_for(definition)
+        puts "  #{definition.key} (#{definition.hook_section}/#{definition.config_name}, enabled=#{check_config['enabled']})"
+      end
+    rescue GitHooks::Error
+      puts 'Available hooks:'
+      Installer.available_hook_names.each { |name| puts "  #{name}" }
+      puts
+      puts 'Available checks:'
+      CheckRegistry.all.each do |definition|
+        puts "  #{definition.key} (#{definition.hook_section}/#{definition.config_name})"
+      end
+    end
+
+    def run_init
+      config = OverrideConfig.new(repo: Repository.new)
+      config.init
+      puts "Initialized #{Constants::CONFIG_FILE}"
     end
 
     def run_disable(args)
-      tokens = parse_tokens(args)
-      if tokens.empty?
-        warn 'Usage: rails_git_hooks disable HOOK [HOOK...] [whitespace-check] [rubocop-check]'
-        warn "Use '*' to disable all hooks."
+      key = args.first
+      if key.nil?
+        warn 'Usage: rails_git_hooks disable CHECK_NAME'
         exit 1
       end
-      installer = Installer.new
-      hook_names, feature_flags = split_tokens(tokens)
-      feature_flags.each { |name| installer.public_send(:"disable_#{name.tr('-', '_')}") }
-      installer.disable(*hook_names) if hook_names.any?
-      puts "Disabled: #{(hook_names + feature_flags).join(', ')}"
-    rescue GitHooks::Error => e
-      warn "Error: #{e.message}"
-      exit 1
+
+      repo = Repository.new
+      definition = CheckRegistry.find!(key)
+      OverrideConfig.new(repo: repo).set_option(definition, 'enabled', false)
+      puts "Disabled: #{key}"
     end
 
     def run_enable(args)
-      tokens = parse_tokens(args)
-      if tokens.empty?
-        warn 'Usage: rails_git_hooks enable HOOK [HOOK...] [whitespace-check] [rubocop-check]'
+      key = args.first
+      if key.nil?
+        warn 'Usage: rails_git_hooks enable CHECK_NAME'
         exit 1
       end
-      installer = Installer.new
-      hook_names, feature_flags = split_tokens(tokens)
-      feature_flags.each { |name| installer.public_send(:"enable_#{name.tr('-', '_')}") }
-      installer.enable(*hook_names) if hook_names.any?
-      puts "Enabled: #{(hook_names + feature_flags).join(', ')}"
-    rescue GitHooks::Error => e
-      warn "Error: #{e.message}"
-      exit 1
-    end
 
-    def parse_tokens(args)
-      args.reject { |a| a.start_with?('-') }
+      repo = Repository.new
+      definition = CheckRegistry.find!(key)
+      OverrideConfig.new(repo: repo).set_option(definition, 'enabled', true)
+      puts "Enabled: #{key}"
     end
 
-    def split_tokens(tokens)
-      feature_flags = tokens & FEATURE_FLAG_TOKENS
-      hook_names = tokens - FEATURE_FLAG_TOKENS
-      [hook_names, feature_flags]
+    def run_set(args)
+      key, option, value = args
+      if key.nil? || option.nil? || value.nil?
+        warn 'Usage: rails_git_hooks set CHECK_NAME OPTION VALUE'
+        exit 1
+      end
+
+      definition = CheckRegistry.find!(key)
+      OverrideConfig.new(repo: Repository.new).set_option(definition, option, value)
+      puts "Updated: #{key} #{option}=#{value}"
     end
 
-    def run_disabled
-      installer = Installer.new
-      list = installer.disabled_hooks
-      if list.empty?
-        puts 'No hooks disabled.'
-      else
-        puts "Disabled hooks: #{list.join(', ')}"
-      end
-    rescue GitHooks::Error => e
-      warn "Error: #{e.message}"
-      exit 1
+    def run_show_config
+      repo = Repository.new
+      config = OverrideConfig.new(repo: repo).effective_config(CheckRegistry.all)
+      puts YAML.dump(config)
     end
 
     def print_help
       puts <<~HELP
-        rails_git_hooks - Install git hooks for Jira commit prefix and RuboCop
+        rails_git_hooks - Install configurable Git hooks
 
         Usage:
           rails_git_hooks install [HOOK...]
-          rails_git_hooks disable HOOK [HOOK...] [whitespace-check] [rubocop-check]   (use * for all hooks)
-          rails_git_hooks enable HOOK [HOOK...] [whitespace-check] [rubocop-check]
-          rails_git_hooks disabled
           rails_git_hooks list
+          rails_git_hooks init
+          rails_git_hooks enable CHECK_NAME
+          rails_git_hooks disable CHECK_NAME
+          rails_git_hooks set CHECK_NAME OPTION VALUE
+          rails_git_hooks show-config
           rails_git_hooks --help
 
         Commands:
           install   Install hooks into current repo's .git/hooks.
-          disable   Disable hooks or whitespace-check / rubocop-check (pre-commit options).
-          enable    Re-enable disabled hooks or enable whitespace-check / rubocop-check.
-          disabled  List currently disabled hooks.
-          list      List available hook names.
+          list      List available hooks and checks.
+          init      Create a sparse #{Constants::CONFIG_FILE} override file.
+          enable    Enable a check in #{Constants::CONFIG_FILE}.
+          disable   Disable a check in #{Constants::CONFIG_FILE}.
+          set       Set a check option like on_fail/on_warn/quiet.
+          show-config Print effective merged configuration.
 
         Examples:
           rails_git_hooks install
-          rails_git_hooks disable pre-commit
-          rails_git_hooks disable *                    # disable all hooks
-          rails_git_hooks enable pre-commit
-          rails_git_hooks enable whitespace-check      # trailing ws/conflict markers (off by default)
-          rails_git_hooks enable rubocop-check         # RuboCop on staged .rb files (off by default)
+          rails_git_hooks enable rubocop-check
+          rails_git_hooks disable migrations-check
+          rails_git_hooks set debugger-check on_fail fail
+          rails_git_hooks set rubocop-check quiet true
+          rails_git_hooks show-config
           rails_git_hooks install commit-msg pre-commit
       HELP
     end

data/lib/rails_git_hooks/config/constants.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module GitHooks
+  # Paths and default config (single source of truth).
+  module Constants
+    GEM_ROOT = File.expand_path('../../..', __dir__)
+    HOOKS_DIR = File.expand_path('templates/hooks', GEM_ROOT).freeze
+    RUNTIME_SOURCE_DIR = File.expand_path('lib/rails_git_hooks', GEM_ROOT).freeze
+    RUNTIME_DIR_NAME = 'rails_git_hooks'
+    CONFIG_FILE = '.rails_git_hooks.yml'
+
+    # Default hooks when install is run with no arguments.
+    DEFAULT_HOOKS = %w[commit-msg pre-commit].freeze
+    HOOK_CONFIG_NAMES = {
+      pre_commit: 'PreCommit',
+      commit_msg: 'CommitMsg',
+      pre_push: 'PrePush'
+    }.freeze
+  end
+end

data/lib/rails_git_hooks/config/defaults.yml

@@ -0,0 +1,127 @@
+# Default config for each check. Overrides live in .rails_git_hooks.yml (sparse).
+# Structure matches .rails_git_hooks.yml: hook section -> check config_name -> options.
+
+PreCommit:
+  DefaultBranch:
+    enabled: true
+    quiet: false
+    on_fail: fail
+    on_warn: warn
+    on_missing_dependency: warn
+    include: []
+    exclude: []
+    dependencies: {}
+    command: []
+    description: Prevent commits on default branch
+    file_based: false
+
+  DebuggerCheck:
+    enabled: true
+    quiet: false
+    on_fail: warn
+    on_warn: warn
+    on_missing_dependency: warn
+    include: []
+    exclude: []
+    dependencies: {}
+    command: []
+    description: Warn on debugger statements
+    file_based: true
+
+  YAMLFormatCheck:
+    enabled: true
+    quiet: false
+    on_fail: warn
+    on_warn: warn
+    on_missing_dependency: warn
+    include: []
+    exclude: []
+    dependencies: {}
+    command: []
+    description: Warn on invalid YAML
+    file_based: true
+
+  JSONFormatCheck:
+    enabled: true
+    quiet: false
+    on_fail: warn
+    on_warn: warn
+    on_missing_dependency: warn
+    include: []
+    exclude: []
+    dependencies: {}
+    command: []
+    description: Warn on invalid JSON
+    file_based: true
+
+  MigrationsCheck:
+    enabled: true
+    quiet: false
+    on_fail: warn
+    on_warn: warn
+    on_missing_dependency: warn
+    include: []
+    exclude: []
+    dependencies: {}
+    command: []
+    description: Warn on missing schema files after migrations
+    file_based: true
+
+  WhitespaceCheck:
+    enabled: false
+    quiet: false
+    on_fail: fail
+    on_warn: warn
+    on_missing_dependency: warn
+    include: []
+    exclude: []
+    dependencies: {}
+    command: []
+    description: Reject trailing whitespace and conflict markers
+    file_based: true
+
+  RuboCop:
+    enabled: false
+    quiet: true
+    on_fail: fail
+    on_warn: warn
+    on_missing_dependency: warn
+    include: []
+    exclude: []
+    dependencies:
+      executables: [bundle]
+      libraries: [rubocop]
+    command: [bundle, exec, rubocop]
+    description: Run RuboCop on staged Ruby files
+    file_based: true
+    install_hint: Add `gem "rubocop"` to your Gemfile and run bundle install
+
+CommitMsg:
+  JiraPrefix:
+    enabled: true
+    quiet: false
+    on_fail: fail
+    on_warn: warn
+    on_missing_dependency: warn
+    include: []
+    exclude: []
+    dependencies: {}
+    command: []
+    description: Prefix commit messages with ticket id from branch
+    file_based: false
+
+PrePush:
+  RunTests:
+    enabled: true
+    quiet: false
+    on_fail: fail
+    on_warn: warn
+    on_missing_dependency: warn
+    include: []
+    exclude: []
+    dependencies:
+      executables: [bundle]
+    command: [bundle, exec, rspec]
+    description: Run test suite before push
+    file_based: false
+    install_hint: Install test dependencies and ensure `bundle exec rspec` runs successfully

data/lib/rails_git_hooks/config/defaults_loader.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module GitHooks
+  class DefaultsLoader
+    DEFAULTS_PATH = File.expand_path('defaults.yml', __dir__)
+
+    class << self
+      def config_for(hook_section, config_name)
+        section = data.fetch(hook_section, {})
+        return nil if section.empty?
+
+        section.fetch(config_name, nil)
+      end
+
+      private
+
+      def data
+        @data ||= load
+      end
+
+      def load
+        return {} unless File.exist?(DEFAULTS_PATH)
+
+        raw = YAML.safe_load(File.read(DEFAULTS_PATH), aliases: true) || {}
+        deep_stringify(raw)
+      end
+
+      def deep_stringify(value)
+        case value
+        when Hash
+          value.each_with_object({}) { |(k, v), out| out[k.to_s] = deep_stringify(v) }
+        when Array
+          value.map { |v| deep_stringify(v) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/rails_git_hooks/core/check_definition.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module GitHooks
+  class CheckDefinition
+    DEFAULTS = {
+      enabled: true,
+      quiet: false,
+      on_fail: :fail,
+      on_warn: :warn,
+      on_missing_dependency: :warn,
+      include: [],
+      exclude: [],
+      dependencies: {},
+      command: nil,
+      file_based: false
+    }.freeze
+
+    attr_reader :key, :config_name, :hook, :klass, :description
+
+    def initialize(key:, config_name:, hook:, klass:, description:, **options)
+      @key = key
+      @config_name = config_name
+      @hook = hook
+      @klass = klass
+      @description = description
+      @options = DEFAULTS.merge(options)
+    end
+
+    def default_config
+      {
+        'enabled' => @options[:enabled],
+        'quiet' => @options[:quiet],
+        'on_fail' => @options[:on_fail].to_s,
+        'on_warn' => @options[:on_warn].to_s,
+        'on_missing_dependency' => @options[:on_missing_dependency].to_s,
+        'include' => Array(@options[:include]),
+        'exclude' => Array(@options[:exclude]),
+        'dependencies' => deep_stringify(@options[:dependencies]),
+        'command' => Array(@options[:command]).compact,
+        'description' => description,
+        'file_based' => @options[:file_based],
+        'install_hint' => @options[:install_hint]
+      }.compact
+    end
+
+    def hook_section
+      Constants::HOOK_CONFIG_NAMES.fetch(hook)
+    end
+
+    private
+
+    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/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,53 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module GitHooks
+  class Installer
+    def initialize(git_dir: nil)
+      @git_dir = git_dir || Repository.new.git_dir
+    end
+
+    def install(*hook_names)
+      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 = hook_names.empty? ? Constants::DEFAULT_HOOKS : hook_names
+      hooks.each_with_object([]) do |name, installed|
+        next unless self.class.available_hook_names.include?(name)
+
+        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 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,29 @@
+# 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
+    ].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