rails_git_hooks 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b990407e471e8f6dddf8df8741a8ac6de92955bc44470b1b45a19b93644b542
-  data.tar.gz: ed3f378f82db9a1dc81dcf58d90f02d12da0ff32c05697ecc2f1dbb92f8db2ca
+  metadata.gz: b95455f85a5e5f3789055e84fc610dcfa199f593d3fc34e5dfb94b781b0ad050
+  data.tar.gz: d2f37971fb832ba3c0e2b3651c7d27b4ca8a7665d6fdac879a43eac8ca38b022
 SHA512:
-  metadata.gz: 0b1aa8a31af84e697e05f56d94ff3427a0afa82e0dfabe4de21e5f0ec865f7ba6c7ddd0537f058e852281a415f68b26a063fd6ef8e71f0d0f1a0b7f9c718aa04
-  data.tar.gz: 966f4fbd5dcfac4ce1e4a9ad1d8a3f8209f0d2885030ece2d916c5598e2324aeac348f7bc8e9690e60bd3676fc995e264e0c2e2b1fd80e51cd1563d4cf3bb4d0
+  metadata.gz: 93b5d01ffd6b14ed1d94543a41e95286afbcaa1f808d9c1d4045dd193e9de3a9f02b3b8a5d5374eadaea450028b28ee89a09c1af20869e30cd8cdeeb8620f259
+  data.tar.gz: 549b45c9aeb5f9607c5aa779d4fdf71196d7d08525f79cfde5e3bf2c3a7df107aa34e397258d4218e45a026e6ed474ab6bb4fc906174af0876eb61ba5cd4e44b

data/CHANGELOG.md

@@ -4,11 +4,27 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
-## [0.7.0] (latest)
+## [0.7.1]
 
 ### Added
 
-- **Pre-commit debugger check** — Warns (does not block) when staged files contain debugger statements: Ruby (`binding.pry`, `debugger`, `byebug`, `binding.irb`), JavaScript/TypeScript (`.js`, `.jsx`, `.ts`, `.tsx`, `.mjs`, `.cjs` — `debugger`), Python (`breakpoint()`, `pdb.set_trace()`, `ipdb.set_trace()`). On by default with pre-commit.
+- **Code-first runtime architecture** — Hook behavior now lives in Ruby classes with a central runner, registry, policy resolver, dependency checker, and sparse override config loader.
+- **Sparse override config** — Added optional `.rails_git_hooks.yml` with Overcommit-style per-check overrides for `enabled`, `quiet`, `on_fail`, `on_warn`, `on_missing_dependency`, `include`, `exclude`, and `command`.
+- **Thin hook bootstraps** — `templates/hooks/*` now dispatch into the embedded `rails_git_hooks` runtime instead of loading copied script files per check.
+- **Pre-commit YAML format check** — Warns (does not block) when any staged `.yml` or `.yaml` file fails to parse (invalid YAML). Reports file and line from the parser. On by default with pre-commit.
+- **Pre-commit JSON format check** — Warns (does not block) when any staged `.json` file fails to parse (invalid JSON). Reports file and parser message. On by default with pre-commit.
+- **Pre-commit migrations check** — Warns (does not block) when: (a) migration file(s) are staged but neither `db/schema.rb` nor `db/structure.sql` is staged; (b) data migration file(s) in `db/data/` or `db/data_migrate/` are staged but `db/data_schema.rb` is not. **On by default.** Disable with `rails_git_hooks disable migrations-check`.
+- **Defaults YAML** — `lib/rails_git_hooks/config/defaults.yml` holds default settings for every check and hook. `DefaultsLoader` reads it; `OverrideConfig` uses it as the base when merging with `.rails_git_hooks.yml`. Edit the YAML to change built-in defaults.
+
+### Changed
+
+- **CLI redesign** — Replaced per-check flag-file commands with generic config-driven commands: `install`, `list`, `init`, `enable`, `disable`, `set`, and `show-config`.
+- **Manual install layout** — Manual install is via `bundle exec rails_git_hooks install` only; dropped `rake sync_hooks` and the repo `hooks/` tree.
+- **Dependency handling** — Checks can now declare executables, Ruby libraries, files, and install hints, with centralized `on_missing_dependency` policy handling.
+- **Runtime install** — Installer copies all runtime files (including `config/defaults.yml`), not only `*.rb`, into `.git/hooks/rails_git_hooks/`.
+- **Removed `hooks/` directory** — `/hooks/` added to `.gitignore`. README manual-install section updated.
+
+## [0.7.0]
 
 ### Changed
 
@@ -16,10 +32,6 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - **Constants:** Extracted `lib/rails_git_hooks/constants.rb` (GEM_ROOT, HOOKS_DIR, DEFAULT_HOOKS, FEATURE_FLAG_FILES). Installer and CLI use it. Single source of truth; no config file.
 - Gemspec includes `templates/**/*`. Version set to 0.7.0.
 
-### Fixed
-
-- **Hook scripts** — `RailsGitHooks::GIT_DIR` was set inside a `module` body, where the script’s local `git_dir` is out of scope (Ruby scope gate), causing `NameError` when hooks ran. All three hooks (commit-msg, pre-commit, pre-push) now set the constant via `RailsGitHooks.const_set(:GIT_DIR, git_dir.freeze)` from the script scope.
-
 ## [0.6.1]
 
 ### Changed

data/README.md

@@ -4,40 +4,40 @@
 [![Build Status](https://github.com/NikitaNazarov1/rails_git_hooks/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/NikitaNazarov1/rails_git_hooks/actions/workflows/tests.yml?query=branch%3Amain)
 [![RuboCop](https://github.com/NikitaNazarov1/rails_git_hooks/actions/workflows/rubocop.yml/badge.svg?branch=main)](https://github.com/NikitaNazarov1/rails_git_hooks/actions/workflows/rubocop.yml?query=branch%3Amain)
 
-Most useful git hooks for Rails and Ruby. Install only what you need. Turn hooks off anytime without uninstalling.
+Git hooks for Rails and Ruby projects with built-in defaults, optional sparse overrides, and Overcommit-style per-check policies.
 
----
+## What changed
 
-## What’s included
+The project now uses a **code-first hook runtime**:
 
-| Hook | Description |
-|------|-------------|
-| **commit-msg** | Adds `[TICKET-123]` to commit messages when your branch name contains a Jira ticket. |
-| **pre-commit** | Blocks commits to `master`/`main`. Warns about debugger statements (Ruby, JS/TS, Python). Optional: RuboCop, trailing-whitespace/conflict checks. |
-| **pre-push** | Runs `bundle exec rspec` before push and blocks push if tests fail. |
+- checks declare their defaults in Ruby
+- hook scripts are thin bootstraps
+- `.rails_git_hooks.yml` is optional and contains only overrides
+- checks can be configured with `enabled`, `quiet`, `on_fail`, `on_warn`, `on_missing_dependency`, `include`, and `exclude`
 
-- **Installed by default:** `commit-msg` and `pre-commit` (branch protection + debugger warnings; RuboCop and whitespace checks are off).
-- **Optional:** `pre-push`, RuboCop, and whitespace/conflict checks — enable when you want them.
+## Included hooks
 
----
+| Git hook | Purpose |
+|---|---|
+| `commit-msg` | Prefix commit messages with Jira-style ticket IDs from the current branch |
+| `pre-commit` | Run commit-time checks like branch protection, debugger detection, format validation, and optional code quality checks |
+| `pre-push` | Run the test suite before push |
 
 ## Quick start
 
 ### 1. Install the gem
 
-**Standalone:**
-
 ```bash
 gem install rails_git_hooks
 ```
 
-**With Bundler** — add to your `Gemfile`:
+Or add it to your `Gemfile`:
 
 ```ruby
 gem "rails_git_hooks"
 ```
 
-Then:
+Then install dependencies:
 
 ```bash
 bundle install
@@ -45,107 +45,176 @@ bundle install
 
 ### 2. Install hooks
 
-From your project root (inside the git repo):
+From your project root:
 
 ```bash
 bundle exec rails_git_hooks install
 ```
 
-This installs **commit-msg** and **pre-commit** (default-branch protection only). No Jira project key needed — the hook detects ticket IDs like `APD-123` or `PROJ-456` from the branch name.
+This installs `commit-msg` and `pre-commit` by default.
 
-### 3. Optional: add more
+### 3. Inspect available checks
 
 ```bash
-# Run tests before every push
-rails_git_hooks install pre-push
+bundle exec rails_git_hooks list
+```
 
-# Run RuboCop on staged .rb files before commit
-rails_git_hooks enable rubocop-check
+### 4. Override behavior only when needed
+
+Enable RuboCop:
+
+```bash
+bundle exec rails_git_hooks enable rubocop-check
+```
+
+Make debugger statements fail instead of warn:
 
-# Reject trailing whitespace and conflict markers in staged files
-rails_git_hooks enable whitespace-check
+```bash
+bundle exec rails_git_hooks set debugger-check on_fail fail
 ```
 
-**Tip:** If a hook doesn’t run, make it executable: `chmod +x .git/hooks/<hook-name>`
+Disable migrations warnings:
 
----
+```bash
+bundle exec rails_git_hooks disable migrations-check
+```
 
-## Command reference
+Show effective config:
 
-All commands are run from the project root.
+```bash
+bundle exec rails_git_hooks show-config
+```
 
-| Command | Description |
-|---------|-------------|
-| `rails_git_hooks install [HOOK...]` | Install hooks. No arguments = install default (commit-msg + pre-commit). |
-| `rails_git_hooks list` | List available hook names. |
-| `rails_git_hooks disable HOOK [...]` | Disable hooks or options (use `*` for all). |
-| `rails_git_hooks enable HOOK [...]` | Re-enable hooks or enable optional checks. |
-| `rails_git_hooks disabled` | Show currently disabled hooks. |
+## Config model
+
+You do **not** need a config file for the defaults to work.
 
-**Common examples:**
+If you want overrides, create one:
 
 ```bash
-rails_git_hooks install                    # default hooks
-rails_git_hooks install pre-push          # add pre-push
-rails_git_hooks disable pre-commit        # turn off pre-commit temporarily
-rails_git_hooks disable *                 # turn off all
-rails_git_hooks enable pre-commit         # turn pre-commit back on
-rails_git_hooks enable rubocop-check      # run RuboCop on staged .rb files
-rails_git_hooks enable whitespace-check   # reject trailing ws & conflict markers
+bundle exec rails_git_hooks init
 ```
 
-Disabled state is stored in `.git/rails_git_hooks_disabled` and persists until you run `enable`.
+This creates `.rails_git_hooks.yml`. The file is sparse: only your changes are stored there.
 
----
+Example:
 
-## Hooks in detail
+```yaml
+PreCommit:
+  DebuggerCheck:
+    on_fail: fail
+
+  RuboCop:
+    enabled: true
+    quiet: true
+    include:
+      - "app/**/*.rb"
+      - "lib/**/*.rb"
+    exclude:
+      - "db/schema.rb"
+```
 
-### commit-msg — Jira ticket prefix
+### Supported per-check options
 
-**What it does:** If the branch name contains a Jira-style ticket (e.g. `task/APD-1234/fix-bug`), the hook prepends `[APD-1234]` to the commit message — unless the message already starts with that format. Works with any project key (2–5 letters + digits); no config.
+| Option | Meaning |
+|---|---|
+| `enabled` | Enable or disable a check |
+| `quiet` | Hide normal output unless the check warns or fails |
+| `on_fail` | Map a check failure to `fail`, `warn`, or `pass` |
+| `on_warn` | Map a warning to `warn`, `fail`, or `pass` |
+| `on_missing_dependency` | Control behavior when required tools/libraries are missing |
+| `include` | File paths or glob patterns that the check should apply to |
+| `exclude` | File paths or glob patterns to remove from the included set |
+| `command` | Override the command used by command-based checks |
 
-**Example:**
+## Dependency model
 
-- Branch: `task/APD-1234/fix-bug`
-- Command: `git commit -m 'fix bug'`
-- Result: **`[APD-1234] fix bug`**
+Checks can declare dependencies such as:
 
----
+- executables like `bundle`
+- Ruby libraries like `rubocop`
+- required files
 
-### pre-commit — Branch protection and optional checks
+If a dependency is missing, the runner produces a structured result and applies the check’s `on_missing_dependency` policy. This makes missing-tool behavior consistent across all checks.
 
-**Always on (when installed):**
+## Default checks
 
-- Blocks commits to `master` or `main`. You must commit from a feature branch.
-- **Debugger check** — Warns (does not block) when staged files contain debugger statements: Ruby (`binding.pry`, `debugger`, `byebug`, `binding.irb`), JavaScript/TypeScript (`.js`, `.jsx`, `.ts`, `.tsx` — `debugger`), Python (`breakpoint()`, `pdb.set_trace()`, `ipdb.set_trace()`).
+### `commit-msg`
 
-**Optional (off by default):**
+- `jira-prefix`
+  - enabled by default
+  - prefixes commit messages with `[TICKET-123]` when the branch name contains a Jira-style ticket ID
 
-1. **RuboCop** — Run RuboCop on staged `.rb` files; commit fails if there are offenses.  
-   `rails_git_hooks enable rubocop-check` / `disable rubocop-check`. Requires the `rubocop` gem.
+### `pre-commit`
 
-2. **Whitespace & conflict markers** — Reject commits that add trailing spaces/tabs or `<<<<<<<` / `=======` / `>>>>>>>` in staged files.  
-   `rails_git_hooks enable whitespace-check` / `disable whitespace-check`.
+- `default-branch`
+  - enabled by default
+  - fails on `master` / `main`
 
----
+- `debugger-check`
+  - enabled by default
+  - warns on debugger statements in Ruby, JavaScript/TypeScript, and Python
 
-### pre-push — Run tests before push
+- `yaml-format-check`
+  - enabled by default
+  - warns on invalid `.yml` / `.yaml`
 
-Runs `bundle exec rspec` before every `git push`. If the suite fails, the push is aborted. Not installed by default; add with `rails_git_hooks install pre-push`. For Minitest, edit the hook to use `bundle exec rake test`.
+- `json-format-check`
+  - enabled by default
+  - warns on invalid `.json`
 
----
+- `migrations-check`
+  - enabled by default
+  - warns when schema/data schema files appear to be missing after migrations
 
-## Manual installation (without the gem)
+- `whitespace-check`
+  - disabled by default
+  - fails on trailing whitespace and merge conflict markers
 
-Copy the **entire** `hooks/` directory into your repo’s `.git/hooks/` (so the hook scripts and the `pre_commit/`, `commit_msg/`, `pre_push/` subdirs are all under `.git/hooks/`). Run `rake sync_hooks` to regenerate `hooks/` from `templates/hooks/` and `templates/shared/`.
+- `rubocop-check`
+  - disabled by default
+  - runs RuboCop on staged Ruby files
+  - default dependency behavior warns if `rubocop` is missing
 
-| Script | Notes |
-|--------|--------|
-| [commit-msg](hooks/commit-msg) | Jira-style ticket prefix; no config. |
-| [pre-commit](hooks/pre-commit) | Branch protection + debugger warnings; optional RuboCop (requires `rubocop` gem). |
-| [pre-push](hooks/pre-push) | Runs `bundle exec rspec`; edit for Minitest if needed. |
+### `pre-push`
 
----
+- `run-tests`
+  - enabled by default when `pre-push` is installed
+  - runs `bundle exec rspec`
+
+## CLI reference
+
+| Command | Description |
+|---|---|
+| `rails_git_hooks install [HOOK...]` | Install hook scripts into `.git/hooks` |
+| `rails_git_hooks list` | List available git hooks and check keys |
+| `rails_git_hooks init` | Create `.rails_git_hooks.yml` |
+| `rails_git_hooks enable CHECK_NAME` | Set `enabled: true` for a check override |
+| `rails_git_hooks disable CHECK_NAME` | Set `enabled: false` for a check override |
+| `rails_git_hooks set CHECK_NAME OPTION VALUE` | Set a single override option |
+| `rails_git_hooks show-config` | Print effective merged configuration |
+
+Examples:
+
+```bash
+rails_git_hooks install
+rails_git_hooks install pre-push
+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
+```
+
+## Manual installation
+
+From your project (with the gem in the Gemfile or installed), run:
+
+```bash
+bundle exec rails_git_hooks install
+```
+
+This installs the thin hook bootstraps and the embedded `rails_git_hooks` runtime into `.git/hooks/`.
 
 ## Development
 
@@ -154,11 +223,8 @@ bundle install
 bundle exec rake              # run specs
 bundle exec rake build        # build the gem
 bundle exec rake install      # install locally
-bundle exec rake sync_hooks   # copy templates (hooks + shared subdirs) → hooks/
 ```
 
----
-
 ## License
 
 MIT. See [LICENSE](LICENSE).

data/lib/rails_git_hooks/checks/base.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+require 'yaml'
+
+module GitHooks
+  module Checks
+    class Base
+      class << self
+        attr_reader :definition
+
+        def check_definition(key:, hook:, description:, config_name: name.split('::').last, **options)
+          @definition = CheckDefinition.new(
+            key: key,
+            config_name: config_name,
+            hook: hook,
+            klass: self,
+            description: description,
+            **options
+          )
+        end
+      end
+
+      attr_reader :config, :context
+
+      def initialize(config:, context:)
+        @config = config
+        @context = context
+      end
+
+      private
+
+      def repo
+        context.fetch(:repo)
+      end
+
+      def applicable_files
+        context.fetch(:applicable_files, [])
+      end
+
+      def argv
+        context.fetch(:argv, [])
+      end
+
+      def stdin
+        context.fetch(:stdin, '')
+      end
+
+      def capture(*command)
+        Open3.capture2e(*command, chdir: repo.root)
+      end
+    end
+  end
+end

data/lib/rails_git_hooks/checks/commit_msg/jira_prefix.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module GitHooks
+  module Checks
+    module CommitMsg
+      class JiraPrefix < Base
+        TICKET_PATTERN = /([A-Z]{2,5}-\d+)/.freeze
+
+        check_definition key: 'jira-prefix',
+                         hook: :commit_msg,
+                         description: 'Prefix commit messages with ticket id from branch'
+
+        def run
+          message_file = argv.first
+          return CheckResult.pass unless message_file && File.file?(message_file)
+
+          branch = repo.current_branch
+          ticket = branch[TICKET_PATTERN, 1]
+          return CheckResult.pass unless ticket
+
+          message = File.read(message_file)
+          prefix = "[#{ticket}]"
+          return CheckResult.pass if message.lstrip.start_with?(prefix)
+
+          File.write(message_file, "#{prefix} #{message}")
+          CheckResult.pass
+        end
+      end
+    end
+  end
+end

data/lib/rails_git_hooks/checks/commit_msg.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module GitHooks
+  module Checks
+    module CommitMsg
+    end
+  end
+end
+
+require_relative 'commit_msg/jira_prefix'

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module GitHooks
+  module Checks
+    module PreCommit
+      class DebuggerCheck < Base
+        DEBUGGER_PATTERNS = {
+          '.rb' => [/\bbinding\.pry\b/, /\bbinding\.irb\b/, /\bdebugger\b/, /\bbyebug\b/],
+          '.js' => [/\bdebugger\s*;?/],
+          '.jsx' => [/\bdebugger\s*;?/],
+          '.ts' => [/\bdebugger\s*;?/],
+          '.tsx' => [/\bdebugger\s*;?/],
+          '.mjs' => [/\bdebugger\s*;?/],
+          '.cjs' => [/\bdebugger\s*;?/],
+          '.py' => [/\bbreakpoint\s*\(\s*\)/, /\bpdb\.set_trace\s*\(\s*\)/, /\bipdb\.set_trace\s*\(\s*\)/]
+        }.freeze
+
+        check_definition key: 'debugger-check',
+                         hook: :pre_commit,
+                         description: 'Warn on debugger statements',
+                         file_based: true,
+                         on_fail: :warn
+
+        def run
+          warnings = []
+
+          applicable_files.each do |path|
+            next unless File.file?(path)
+
+            patterns = DEBUGGER_PATTERNS[File.extname(path)]
+            next unless patterns
+
+            File.read(path).lines.each_with_index do |line, index|
+              warnings << "#{path}:#{index + 1}: debugger statement" if patterns.any? { |pattern| line.match?(pattern) }
+            end
+          end
+
+          warnings.empty? ? CheckResult.pass : CheckResult.fail(messages: warnings.uniq)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module GitHooks
+  module Checks
+    module PreCommit
+      class DefaultBranch < Base
+        check_definition key: 'default-branch',
+                         hook: :pre_commit,
+                         description: 'Prevent commits on default branch'
+
+        def run
+          branch = repo.current_branch
+          return CheckResult.pass unless %w[master main].include?(branch)
+
+          CheckResult.fail(messages: ["Commits on '#{branch}' are not allowed. Create a feature branch."])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module GitHooks
+  module Checks
+    module PreCommit
+      class JSONFormatCheck < Base
+        check_definition key: 'json-format-check',
+                         hook: :pre_commit,
+                         description: 'Warn on invalid JSON',
+                         file_based: true,
+                         on_fail: :warn
+
+        def run
+          warnings = []
+
+          applicable_files.each do |path|
+            next unless File.file?(path)
+            next unless File.extname(path) == '.json'
+
+            JSON.parse(File.read(path))
+          rescue JSON::ParserError => e
+            warnings << "#{path}: #{e.message}"
+          end
+
+          warnings.empty? ? CheckResult.pass : CheckResult.fail(messages: warnings)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module GitHooks
+  module Checks
+    module PreCommit
+      class MigrationsCheck < Base
+        check_definition key: 'migrations-check',
+                         hook: :pre_commit,
+                         description: 'Warn on missing schema files after migrations',
+                         file_based: true,
+                         on_fail: :warn
+
+        def run
+          messages = []
+          migration_files = applicable_files.grep(%r{\Adb/migrate/.*\.rb\z})
+          schema_staged = applicable_files.include?('db/schema.rb') || applicable_files.include?('db/structure.sql')
+
+          if migration_files.any? && !schema_staged
+            messages << 'Migration file(s) are staged but neither db/schema.rb nor db/structure.sql is staged.'
+            messages << 'Run `rails db:migrate` and add db/schema.rb (or db/structure.sql) to your commit.'
+            migration_files.each { |path| messages << "- #{path}" }
+          end
+
+          data_migration_files = applicable_files.grep(%r{\Adb/(data/|data_migrate/).*\.rb\z})
+          data_schema_staged = applicable_files.include?('db/data_schema.rb')
+          if data_migration_files.any? && !data_schema_staged
+            messages << 'Data migration file(s) are staged but db/data_schema.rb is not staged.'
+            messages << 'Run your data migrate task and add db/data_schema.rb to your commit.'
+            data_migration_files.each { |path| messages << "- #{path}" }
+          end
+
+          messages.empty? ? CheckResult.pass : CheckResult.fail(messages: messages)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module GitHooks
+  module Checks
+    module PreCommit
+      class RuboCop < Base
+        check_definition key: 'rubocop-check',
+                         hook: :pre_commit,
+                         description: 'Run RuboCop on staged Ruby files',
+                         file_based: true,
+                         enabled: false,
+                         quiet: true,
+                         dependencies: { 'executables' => ['bundle'], 'libraries' => ['rubocop'] },
+                         command: %w[bundle exec rubocop],
+                         install_hint: 'Add `gem "rubocop"` to your Gemfile and run bundle install'
+
+        def run
+          ruby_files = applicable_files.select { |path| File.extname(path) == '.rb' && File.file?(path) }
+          return CheckResult.pass if ruby_files.empty?
+
+          output, status = capture(*Array(config['command']), *ruby_files)
+          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_commit/whitespace_check.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module GitHooks
+  module Checks
+    module PreCommit
+      class WhitespaceCheck < Base
+        check_definition key: 'whitespace-check',
+                         hook: :pre_commit,
+                         description: 'Reject trailing whitespace and conflict markers',
+                         file_based: true,
+                         enabled: false
+
+        def run
+          errors = []
+
+          applicable_files.each do |path|
+            next unless File.file?(path)
+
+            File.read(path).lines.each_with_index do |line, index|
+              errors << "#{path}:#{index + 1}: trailing whitespace" if line.match?(/[ \t]\z/)
+              stripped = line.strip
+              errors << "#{path}:#{index + 1}: conflict marker" if stripped.start_with?('<<<<<<<', '=======', '>>>>>>>')
+            end
+          end
+
+          errors.empty? ? CheckResult.pass : CheckResult.fail(messages: errors.uniq)
+        end
+      end
+    end
+  end
+end