rails_git_hooks 0.6.1 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '039dc0fb243e8ce670d6cadeb3c3e398cc6441276953c9a0c1e8f8541864256e'
-  data.tar.gz: 26a46c6776054ec41554c60ad4ea06f48c14f703cd9c396735f2888b6b0f329b
+  metadata.gz: b95455f85a5e5f3789055e84fc610dcfa199f593d3fc34e5dfb94b781b0ad050
+  data.tar.gz: d2f37971fb832ba3c0e2b3651c7d27b4ca8a7665d6fdac879a43eac8ca38b022
 SHA512:
-  metadata.gz: 589952d05b4bbc277efc18f59a02bdd51ba2edeae20b26fb1b093186bdd57413a4949e25987b291b546b06f29b2c81cff394901cd6c6dd9527a1fd1c0f3f0101
-  data.tar.gz: d79a92159cd66cf640b1fc80a29ade822fd6e3215be50915aec2609301f7edd71a13b1b83252e4b94adbb95feed759f1dfb78eb80e1f23abd800419992a6a24f
+  metadata.gz: 93b5d01ffd6b14ed1d94543a41e95286afbcaa1f808d9c1d4045dd193e9de3a9f02b3b8a5d5374eadaea450028b28ee89a09c1af20869e30cd8cdeeb8620f259
+  data.tar.gz: 549b45c9aeb5f9607c5aa779d4fdf71196d7d08525f79cfde5e3bf2c3a7df107aa34e397258d4218e45a026e6ed474ab6bb4fc906174af0876eb61ba5cd4e44b

data/CHANGELOG.md

@@ -4,11 +4,39 @@ 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.6.1] (latest)
+## [0.7.1]
+
+### Added
+
+- **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
+
+- **Overcommit-style layout:** Hook templates live in `templates/hooks/` (was `lib/rails_git_hooks/templates/`). `rake sync_hooks` copies them to `hooks/` for manual install.
+- **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.
+
+## [0.6.1]
 
 ### Changed
 
-- **Default install** now installs **commit-msg** and **pre-commit** only (Jira ticket prefix + default-branch protection + RuboCop). Pre-push remains opt-in: `rails_git_hooks install pre-push`.
+- **Default install** now installs **commit-msg** and **pre-commit** only (Jira ticket prefix + default-branch protection; RuboCop opt-in). Pre-push remains opt-in: `rails_git_hooks install pre-push`.
 - README: quick start and commands table updated for default (commit-msg + pre-commit); Jira project key / `JIRA_PROJECT_KEY` for manual install; pre-push install instruction.
 
 ## [0.6.0]

data/README.md

@@ -1,164 +1,230 @@
-# Git Hooks
+# Rails Git Hooks
 
 [![Gem Version](https://badge.fury.io/rb/rails_git_hooks.svg)](https://badge.fury.io/rb/rails_git_hooks)
 [![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)
 
-> Automate Jira ticket prefixes and RuboCop checks with git hooks. Built for Rails and Ruby projects.
+Git hooks for Rails and Ruby projects with built-in defaults, optional sparse overrides, and Overcommit-style per-check policies.
 
----
+## What changed
 
-## What you get
+The project now uses a **code-first hook runtime**:
 
-| Hook | What it does |
-|------|--------------|
-| **commit-msg** | Prepends `[TICKET-123]` to commit messages when your branch name contains a Jira ticket. |
-| **pre-commit** | Blocks commits to `master`/`main` and runs RuboCop on staged `.rb` files. |
-| **pre-push** | Runs the full test suite (`bundle exec rspec`) before push; aborts 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`
 
-Hooks can be disabled temporarily (e.g. for quick WIP commits or CI) without uninstalling.
+## 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**
+### 1. Install the gem
 
 ```bash
 gem install rails_git_hooks
 ```
 
-Or with Bundler — add to your `Gemfile`:
+Or add it to your `Gemfile`:
 
 ```ruby
 gem "rails_git_hooks"
 ```
 
-Then:
+Then install dependencies:
 
 ```bash
 bundle install
-bundle exec rails_git_hooks install
 ```
 
-This installs **commit-msg** (Jira ticket prefix) and **pre-commit** (blocks commits on `master`/`main` + RuboCop on staged `.rb` files) by default.
+### 2. Install hooks
+
+From your project root:
 
-**2. Set your Jira project key**
+```bash
+bundle exec rails_git_hooks install
+```
 
-Replace the default by passing your project key at install time or via env:
+This installs `commit-msg` and `pre-commit` by default.
+
+### 3. Inspect available checks
 
 ```bash
-rails_git_hooks install --jira MYPROJ
-# or
-export GIT_HOOKS_JIRA_PROJECT=MYPROJ
-rails_git_hooks install
+bundle exec rails_git_hooks list
 ```
 
-Default is `APD` if not set. For manual install: replace `JIRA_PROJECT_KEY` in the commit-msg script with your key (e.g. `APD`).
+### 4. Override behavior only when needed
 
-To also run the full test suite before push:  
-`rails_git_hooks install pre-push`
+Enable RuboCop:
 
-> **Tip:** If the pre-commit hook doesn’t run, make it executable: `chmod +x .git/hooks/pre-commit`
+```bash
+bundle exec rails_git_hooks enable rubocop-check
+```
 
----
+Make debugger statements fail instead of warn:
 
-## Commands
+```bash
+bundle exec rails_git_hooks set debugger-check on_fail fail
+```
 
-Run from your project root (inside a git repo).
+Disable migrations warnings:
 
-| Command | Description |
-|---------|-------------|
-| `rails_git_hooks install [HOOK...] [--jira PROJECT]` | Install hooks. No args = install default (commit-msg + pre-commit). |
-| `rails_git_hooks list` | List available hook names. |
-| `rails_git_hooks disable HOOK [HOOK...] [whitespace-check]` | Disable hooks (use `*` for all) or the whitespace-check. |
-| `rails_git_hooks enable HOOK [HOOK...] [whitespace-check]` | Re-enable hooks or enable whitespace-check. |
-| `rails_git_hooks disabled` | Show which hooks are currently disabled. |
+```bash
+bundle exec rails_git_hooks disable migrations-check
+```
 
-**Examples**
+Show effective config:
 
 ```bash
-# Install everything with custom Jira key
-rails_git_hooks install --jira MYPROJ
+bundle exec rails_git_hooks show-config
+```
+
+## Config model
+
+You do **not** need a config file for the defaults to work.
 
-# Install only specific hooks
-rails_git_hooks install pre-commit commit-msg --jira APD
+If you want overrides, create one:
 
-# Temporarily disable pre-commit (e.g. for a quick fix)
-rails_git_hooks disable pre-commit
+```bash
+bundle exec rails_git_hooks init
+```
+
+This creates `.rails_git_hooks.yml`. The file is sparse: only your changes are stored there.
 
-# Disable all hooks
-rails_git_hooks disable *
+Example:
 
-# Turn them back on
-rails_git_hooks enable pre-commit
+```yaml
+PreCommit:
+  DebuggerCheck:
+    on_fail: fail
 
-# Enable rejection of trailing whitespace and conflict markers in staged files (off by default)
-rails_git_hooks enable whitespace-check
+  RuboCop:
+    enabled: true
+    quiet: true
+    include:
+      - "app/**/*.rb"
+      - "lib/**/*.rb"
+    exclude:
+      - "db/schema.rb"
 ```
 
-Disabled state is stored in `.git/rails_git_hooks_disabled` and persists until you run `enable`.
+### Supported per-check options
 
----
+| 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 |
 
-## Hooks in detail
+## Dependency model
 
-### commit-msg — Jira ticket prefix
+Checks can declare dependencies such as:
 
-If your branch name contains a Jira ticket (e.g. `task/APD-1234/fix-bug`), the hook prepends `[APD-1234] ` to the commit message unless it’s already there.
+- executables like `bundle`
+- Ruby libraries like `rubocop`
+- required files
 
-**Example**
+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.
 
-- Branch: `task/APD-1234/fix-bug`
-- You run: `git commit -m 'fix bug'`
-- Result: **`[APD-1234] fix bug`**
+## Default checks
 
-Set the Jira project key at install time with `--jira PROJECT` or `GIT_HOOKS_JIRA_PROJECT`.
+### `commit-msg`
 
----
+- `jira-prefix`
+  - enabled by default
+  - prefixes commit messages with `[TICKET-123]` when the branch name contains a Jira-style ticket ID
 
-### pre-commit — Default branch protection + RuboCop
+### `pre-commit`
 
-1. **Blocks commits on `master` / `main`** — You must commit from a feature branch; direct commits to the default branch are rejected.
-2. **Runs RuboCop** on staged `.rb` files. If there are offenses, the commit is aborted.
-3. **Trailing whitespace / conflict markers** (off by default) — When enabled, rejects commits that add trailing spaces/tabs or `<<<<<<<` / `=======` / `>>>>>>>` in staged files. Enable with: `rails_git_hooks enable whitespace-check`. Disable with: `rails_git_hooks disable whitespace-check`.
+- `default-branch`
+  - enabled by default
+  - fails on `master` / `main`
 
-Requires the `rubocop` gem in your project. If the hook doesn’t run, ensure it’s executable: `chmod +x .git/hooks/pre-commit`.
+- `debugger-check`
+  - enabled by default
+  - warns on debugger statements in Ruby, JavaScript/TypeScript, and Python
 
----
+- `yaml-format-check`
+  - enabled by default
+  - warns on invalid `.yml` / `.yaml`
 
-### pre-push — Run tests before push
+- `json-format-check`
+  - enabled by default
+  - warns on invalid `.json`
 
-Runs `bundle exec rspec` before every `git push`. If the test suite fails, the push is aborted so you don’t break CI.
+- `migrations-check`
+  - enabled by default
+  - warns when schema/data schema files appear to be missing after migrations
 
-Requires the `rspec` gem (or for Minitest, edit the hook to use `bundle exec rake test`). If the hook doesn’t run, ensure it’s executable: `chmod +x .git/hooks/pre-push`.
+- `whitespace-check`
+  - disabled by default
+  - fails on trailing whitespace and merge conflict markers
 
----
+- `rubocop-check`
+  - disabled by default
+  - runs RuboCop on staged Ruby files
+  - default dependency behavior warns if `rubocop` is missing
 
-## Manual installation (without the gem)
+### `pre-push`
 
-If you don’t want to use the gem, copy the scripts from `hooks/` into `.git/hooks`. The `hooks/` directory is synced from the gem templates via `rake sync_hooks` in development.
+- `run-tests`
+  - enabled by default when `pre-push` is installed
+  - runs `bundle exec rspec`
 
-| File | Notes |
-|------|--------|
-| [commit-msg](hooks/commit-msg) | Replace `JIRA_PROJECT_KEY` in the script with your Jira project key (e.g. `APD`). |
-| [pre-commit](hooks/pre-commit) | Requires the `rubocop` gem in the repo where you use it. |
-| [pre-push](hooks/pre-push) | Runs `bundle exec rspec`; edit to use `bundle exec rake test` for Minitest. |
+## 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
 
 ```bash
 bundle install
-bundle exec rake              # run specs (default task)
+bundle exec rake              # run specs
 bundle exec rake build        # build the gem
-bundle exec rake install      # install the gem locally
-bundle exec rake sync_hooks   # copy templates to hooks/
+bundle exec rake install      # install locally
 ```
 
----
-
 ## 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