rails_git_hooks 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '039dc0fb243e8ce670d6cadeb3c3e398cc6441276953c9a0c1e8f8541864256e'
-  data.tar.gz: 26a46c6776054ec41554c60ad4ea06f48c14f703cd9c396735f2888b6b0f329b
+  metadata.gz: 3b990407e471e8f6dddf8df8741a8ac6de92955bc44470b1b45a19b93644b542
+  data.tar.gz: ed3f378f82db9a1dc81dcf58d90f02d12da0ff32c05697ecc2f1dbb92f8db2ca
 SHA512:
-  metadata.gz: 589952d05b4bbc277efc18f59a02bdd51ba2edeae20b26fb1b093186bdd57413a4949e25987b291b546b06f29b2c81cff394901cd6c6dd9527a1fd1c0f3f0101
-  data.tar.gz: d79a92159cd66cf640b1fc80a29ade822fd6e3215be50915aec2609301f7edd71a13b1b83252e4b94adbb95feed759f1dfb78eb80e1f23abd800419992a6a24f
+  metadata.gz: 0b1aa8a31af84e697e05f56d94ff3427a0afa82e0dfabe4de21e5f0ec865f7ba6c7ddd0537f058e852281a415f68b26a063fd6ef8e71f0d0f1a0b7f9c718aa04
+  data.tar.gz: 966f4fbd5dcfac4ce1e4a9ad1d8a3f8209f0d2885030ece2d916c5598e2324aeac348f7bc8e9690e60bd3676fc995e264e0c2e2b1fd80e51cd1563d4cf3bb4d0

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.6.1] (latest)
+## [0.7.0] (latest)
+
+### 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.
+
+### 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.
+
+### 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
 
-- **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,34 +1,37 @@
-# 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.
+Most useful git hooks for Rails and Ruby. Install only what you need. Turn hooks off anytime without uninstalling.
 
 ---
 
-## What you get
+## What’s included
 
-| 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. |
+| 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. |
 
-Hooks can be disabled temporarily (e.g. for quick WIP commits or CI) without uninstalling.
+- **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.
 
 ---
 
 ## Quick start
 
-**1. Install the gem**
+### 1. Install the gem
+
+**Standalone:**
 
 ```bash
 gem install rails_git_hooks
 ```
 
-Or with Bundler — add to your `Gemfile`:
+**With Bundler** — add to your `Gemfile`:
 
 ```ruby
 gem "rails_git_hooks"
@@ -38,63 +41,57 @@ Then:
 
 ```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. Set your Jira project key**
+### 2. Install hooks
 
-Replace the default by passing your project key at install time or via env:
+From your project root (inside the git repo):
 
 ```bash
-rails_git_hooks install --jira MYPROJ
-# or
-export GIT_HOOKS_JIRA_PROJECT=MYPROJ
-rails_git_hooks install
+bundle exec rails_git_hooks install
 ```
 
-Default is `APD` if not set. For manual install: replace `JIRA_PROJECT_KEY` in the commit-msg script with your key (e.g. `APD`).
+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.
+
+### 3. Optional: add more
 
-To also run the full test suite before push:  
-`rails_git_hooks install pre-push`
+```bash
+# Run tests before every push
+rails_git_hooks install pre-push
 
-> **Tip:** If the pre-commit hook doesn’t run, make it executable: `chmod +x .git/hooks/pre-commit`
+# Run RuboCop on staged .rb files before commit
+rails_git_hooks enable rubocop-check
+
+# Reject trailing whitespace and conflict markers in staged files
+rails_git_hooks enable whitespace-check
+```
+
+**Tip:** If a hook doesn’t run, make it executable: `chmod +x .git/hooks/<hook-name>`
 
 ---
 
-## Commands
+## Command reference
 
-Run from your project root (inside a git repo).
+All commands are run from the project root.
 
 | Command | Description |
 |---------|-------------|
-| `rails_git_hooks install [HOOK...] [--jira PROJECT]` | Install hooks. No args = install default (commit-msg + pre-commit). |
+| `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 [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. |
+| `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. |
 
-**Examples**
+**Common examples:**
 
 ```bash
-# Install everything with custom Jira key
-rails_git_hooks install --jira MYPROJ
-
-# Install only specific hooks
-rails_git_hooks install pre-commit commit-msg --jira APD
-
-# Temporarily disable pre-commit (e.g. for a quick fix)
-rails_git_hooks disable pre-commit
-
-# Disable all hooks
-rails_git_hooks disable *
-
-# Turn them back on
-rails_git_hooks enable pre-commit
-
-# Enable rejection of trailing whitespace and conflict markers in staged files (off by default)
-rails_git_hooks enable whitespace-check
+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
 ```
 
 Disabled state is stored in `.git/rails_git_hooks_disabled` and persists until you run `enable`.
@@ -105,45 +102,48 @@ Disabled state is stored in `.git/rails_git_hooks_disabled` and persists until y
 
 ### commit-msg — Jira ticket prefix
 
-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.
+**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.
 
-**Example**
+**Example:**
 
 - Branch: `task/APD-1234/fix-bug`
-- You run: `git commit -m 'fix bug'`
+- Command: `git commit -m 'fix bug'`
 - Result: **`[APD-1234] fix bug`**
 
-Set the Jira project key at install time with `--jira PROJECT` or `GIT_HOOKS_JIRA_PROJECT`.
-
 ---
 
-### pre-commit — Default branch protection + RuboCop
+### pre-commit — Branch protection and optional checks
+
+**Always on (when installed):**
+
+- 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()`).
 
-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`.
+**Optional (off by default):**
 
-Requires the `rubocop` gem in your project. If the hook doesn’t run, ensure it’s executable: `chmod +x .git/hooks/pre-commit`.
+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.
+
+2. **Whitespace & conflict markers** — Reject commits that add trailing spaces/tabs or `<<<<<<<` / `=======` / `>>>>>>>` in staged files.  
+   `rails_git_hooks enable whitespace-check` / `disable whitespace-check`.
 
 ---
 
 ### pre-push — Run tests before push
 
-Runs `bundle exec rspec` before every `git push`. If the test suite fails, the push is aborted so you don’t break CI.
-
-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`.
+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`.
 
 ---
 
 ## Manual installation (without the gem)
 
-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.
+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/`.
 
-| 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. |
+| 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. |
 
 ---
 
@@ -151,10 +151,10 @@ If you don’t want to use the gem, copy the scripts from `hooks/` into `.git/ho
 
 ```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
+bundle exec rake sync_hooks   # copy templates (hooks + shared subdirs) → hooks/
 ```
 
 ---

data/lib/rails_git_hooks/cli.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 require 'rails_git_hooks'
-require 'optparse'
 
 module GitHooks
   class CLI
+    FEATURE_FLAG_TOKENS = GitHooks::Constants::FEATURE_FLAG_FILES.keys.freeze
+
     def self.run(argv = ARGV)
       new.run(argv)
     end
@@ -33,14 +34,8 @@ module GitHooks
     private
 
     def run_install(args)
-      jira = nil
-      OptionParser.new do |opts|
-        opts.on('--jira PROJECT', 'Jira project key (e.g. APD)') { |v| jira = v }
-      end.parse!(args)
-      hooks = args
-
-      installer = Installer.new(jira_project: jira)
-      installed = installer.install(*hooks)
+      installer = Installer.new
+      installed = installer.install(*args)
       puts "Installed hooks: #{installed.join(', ')}"
     rescue GitHooks::Error => e
       warn "Error: #{e.message}"
@@ -48,46 +43,52 @@ module GitHooks
     end
 
     def run_list
-      dir = GitHooks::Installer::HOOKS_DIR
-      hooks = Dir.children(dir).select { |f| File.file?(File.join(dir, f)) }
-      puts "Available hooks: #{hooks.join(', ')}"
+      puts "Available hooks: #{Installer.available_hook_names.join(', ')}"
     end
 
-    def run_disable(args) # rubocop:disable Metrics/AbcSize
-      tokens = args.reject { |a| a.start_with?('-') }
+    def run_disable(args)
+      tokens = parse_tokens(args)
       if tokens.empty?
-        warn 'Usage: rails_git_hooks disable HOOK [HOOK...] [whitespace-check]'
+        warn 'Usage: rails_git_hooks disable HOOK [HOOK...] [whitespace-check] [rubocop-check]'
         warn "Use '*' to disable all hooks."
         exit 1
       end
       installer = Installer.new
-      hook_names = tokens - ['whitespace-check']
-      installer.disable_whitespace_check if tokens.include?('whitespace-check')
+      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?
-      disabled = hook_names + (tokens.include?('whitespace-check') ? ['whitespace-check'] : [])
-      puts "Disabled: #{disabled.join(', ')}"
+      puts "Disabled: #{(hook_names + feature_flags).join(', ')}"
     rescue GitHooks::Error => e
       warn "Error: #{e.message}"
       exit 1
     end
 
     def run_enable(args)
-      tokens = args.reject { |a| a.start_with?('-') }
+      tokens = parse_tokens(args)
       if tokens.empty?
-        warn 'Usage: rails_git_hooks enable HOOK [HOOK...] [whitespace-check]'
+        warn 'Usage: rails_git_hooks enable HOOK [HOOK...] [whitespace-check] [rubocop-check]'
         exit 1
       end
       installer = Installer.new
-      hook_names = tokens - ['whitespace-check']
-      installer.enable_whitespace_check if tokens.include?('whitespace-check')
+      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?
-      enabled = hook_names + (tokens.include?('whitespace-check') ? ['whitespace-check'] : [])
-      puts "Enabled: #{enabled.join(', ')}"
+      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?('-') }
+    end
+
+    def split_tokens(tokens)
+      feature_flags = tokens & FEATURE_FLAG_TOKENS
+      hook_names = tokens - FEATURE_FLAG_TOKENS
+      [hook_names, feature_flags]
+    end
+
     def run_disabled
       installer = Installer.new
       list = installer.disabled_hooks
@@ -106,17 +107,17 @@ module GitHooks
         rails_git_hooks - Install git hooks for Jira commit prefix and RuboCop
 
         Usage:
-          rails_git_hooks install [HOOK...] [--jira PROJECT_KEY]
-          rails_git_hooks disable HOOK [HOOK...] [whitespace-check]   (use * for all hooks)
-          rails_git_hooks enable HOOK [HOOK...] [whitespace-check]
+          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 --help
 
         Commands:
           install   Install hooks into current repo's .git/hooks.
-          disable   Disable hooks or whitespace-check (trailing ws/conflict markers in pre-commit).
-          enable    Re-enable disabled hooks or enable whitespace-check.
+          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.
 
@@ -125,8 +126,9 @@ module GitHooks
           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      # reject trailing ws/conflict markers (off by default)
-          rails_git_hooks install commit-msg pre-commit --jira MYPROJ
+          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 install commit-msg pre-commit
       HELP
     end
   end

data/lib/rails_git_hooks/constants.rb

@@ -0,0 +1,21 @@
+# 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
+    SHARED_DIR = File.expand_path('templates/shared', GEM_ROOT).freeze
+
+    DISABLED_FILE = 'rails_git_hooks_disabled'
+
+    # Default hooks when install is run with no arguments.
+    DEFAULT_HOOKS = %w[commit-msg pre-commit].freeze
+
+    # Pre-commit feature flag file names (keys = CLI tokens).
+    FEATURE_FLAG_FILES = {
+      'whitespace-check' => 'rails_git_hooks_whitespace_check',
+      'rubocop-check' => 'rails_git_hooks_rubocop'
+    }.freeze
+  end
+end

data/lib/rails_git_hooks/installer.rb

@@ -1,32 +1,28 @@
 # frozen_string_literal: true
 
+require 'fileutils'
+
 module GitHooks
   class Installer
-    HOOKS_DIR = File.expand_path('templates', __dir__).freeze
-    # Default: Jira commit-msg + pre-commit (default-branch protection + RuboCop).
-    # Use install(*available_hooks) or pass names for more.
-    DEFAULT_HOOKS = %w[commit-msg pre-commit].freeze
-
-    def initialize(git_dir: nil, jira_project: nil)
+    def initialize(git_dir: nil)
       @git_dir = git_dir || find_git_dir
-      @jira_project = jira_project || ENV['GIT_HOOKS_JIRA_PROJECT'] || 'APD'
     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)
 
-      hooks = hook_names.empty? ? DEFAULT_HOOKS : hook_names
+      copy_shared_files(target_dir)
+
+      hooks = hook_names.empty? ? Constants::DEFAULT_HOOKS : hook_names
       installed = []
 
       hooks.each do |name|
-        src = File.join(HOOKS_DIR, name)
+        src = File.join(Constants::HOOKS_DIR, name)
         next unless File.file?(src)
 
         dest = File.join(target_dir, name)
-        content = read_template(name)
-        content = content.gsub('JIRA_PROJECT_KEY', @jira_project) if name == 'commit-msg'
-        write_hook(dest, content)
+        write_hook(dest, read_template(name))
         make_executable(dest)
         installed << name
       end
@@ -34,14 +30,16 @@ module GitHooks
       installed
     end
 
-    def available_hooks
-      Dir.children(HOOKS_DIR).select { |f| File.file?(File.join(HOOKS_DIR, f)) }
+    def self.available_hook_names
+      Dir.children(Constants::HOOKS_DIR).select { |f| File.file?(File.join(Constants::HOOKS_DIR, f)) }
     end
 
-    DISABLED_FILE = 'rails_git_hooks_disabled'
+    def available_hooks
+      self.class.available_hook_names
+    end
 
     def disabled_file_path
-      File.join(@git_dir, DISABLED_FILE)
+      File.join(@git_dir, Constants::DISABLED_FILE)
     end
 
     def disabled_hooks
@@ -71,24 +69,51 @@ module GitHooks
       hook_names
     end
 
-    WHITESPACE_CHECK_FILE = 'rails_git_hooks_whitespace_check'
-
     def enable_whitespace_check
-      path = File.join(@git_dir, WHITESPACE_CHECK_FILE)
-      File.write(path, '')
+      enable_feature_flag('whitespace-check')
     end
 
     def disable_whitespace_check
-      path = File.join(@git_dir, WHITESPACE_CHECK_FILE)
-      FileUtils.rm_f(path)
+      disable_feature_flag('whitespace-check')
     end
 
     def whitespace_check_enabled?
-      File.exist?(File.join(@git_dir, WHITESPACE_CHECK_FILE))
+      feature_flag_enabled?('whitespace-check')
+    end
+
+    def enable_rubocop_check
+      enable_feature_flag('rubocop-check')
+    end
+
+    def disable_rubocop_check
+      disable_feature_flag('rubocop-check')
+    end
+
+    def rubocop_check_enabled?
+      feature_flag_enabled?('rubocop-check')
     end
 
     private
 
+    def enable_feature_flag(name)
+      file = Constants::FEATURE_FLAG_FILES[name]
+      return unless file
+
+      File.write(File.join(@git_dir, file), '')
+    end
+
+    def disable_feature_flag(name)
+      file = Constants::FEATURE_FLAG_FILES[name]
+      return unless file
+
+      FileUtils.rm_f(File.join(@git_dir, file))
+    end
+
+    def feature_flag_enabled?(name)
+      file = Constants::FEATURE_FLAG_FILES[name]
+      file && File.exist?(File.join(@git_dir, file))
+    end
+
     def find_git_dir
       dir = Dir.pwd
       loop do
@@ -102,8 +127,21 @@ module GitHooks
       end
     end
 
+    def copy_shared_files(target_dir)
+      return unless Dir.exist?(Constants::SHARED_DIR)
+
+      Dir.glob(File.join(Constants::SHARED_DIR, '**', '*')).each do |src|
+        next unless File.file?(src)
+
+        rel = src.sub(%r{\A#{Regexp.escape(Constants::SHARED_DIR)}/}, '')
+        dest = File.join(target_dir, rel)
+        FileUtils.mkdir_p(File.dirname(dest))
+        File.write(dest, File.read(src))
+      end
+    end
+
     def read_template(name)
-      path = File.join(HOOKS_DIR, name)
+      path = File.join(Constants::HOOKS_DIR, name)
       File.read(path)
     end
 

data/lib/rails_git_hooks/version.rb

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

data/lib/rails_git_hooks.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'rails_git_hooks/version'
+require_relative 'rails_git_hooks/constants'
 require_relative 'rails_git_hooks/installer'
 
 module GitHooks

data/templates/hooks/commit-msg

@@ -0,0 +1,23 @@
+#!/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')
+end
+
+module RailsGitHooks
+end
+RailsGitHooks.const_set(:GIT_DIR, git_dir.freeze)
+hooks_dir = File.dirname(File.expand_path(__FILE__))
+
+load File.join(hooks_dir, 'commit_msg', 'jira_prefix.rb')

data/templates/hooks/pre-commit

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# Blocks commits on default branch (master/main). Warns on debugger statements (Ruby/JS/TS/Python).
+# Optionally runs RuboCop and whitespace/conflict checks.
+# Logic is in templates/shared/pre_commit/ for easier maintenance and adding new checks.
+
+# 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?('pre-commit')
+end
+
+module RailsGitHooks
+end
+RailsGitHooks.const_set(:GIT_DIR, git_dir.freeze)
+hooks_dir = File.dirname(File.expand_path(__FILE__))
+
+load File.join(hooks_dir, 'pre_commit', 'whitespace_check.rb')
+load File.join(hooks_dir, 'pre_commit', 'default_branch.rb')
+load File.join(hooks_dir, 'pre_commit', 'debugger_check.rb')
+load File.join(hooks_dir, 'pre_commit', 'rubocop_check.rb')

data/{lib/rails_git_hooks/templates → templates/hooks}/pre-push

@@ -3,9 +3,9 @@
 
 #
 # Runs the full test suite before push. Push is aborted if tests fail.
-# Uses `bundle exec rspec`. For Minitest, edit to use `bundle exec rake test`.
+# Logic in templates/shared/pre_push/.
 
-# Git runs hooks with CWD = repo root; find .git from here
+# 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)
@@ -15,7 +15,9 @@ if File.exist?(disabled_file)
   exit 0 if disabled.include?('*') || disabled.include?('pre-push')
 end
 
-require 'english'
+module RailsGitHooks
+end
+RailsGitHooks.const_set(:GIT_DIR, git_dir.freeze)
+hooks_dir = File.dirname(File.expand_path(__FILE__))
 
-system('bundle exec rspec')
-exit $CHILD_STATUS.to_s[-1].to_i
+load File.join(hooks_dir, 'pre_push', 'run_tests.rb')

data/templates/shared/commit_msg/jira_prefix.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Prepends [TICKET] to commit message when branch name contains a Jira-style ticket.
+# No config needed; works with any project key (2–5 letters + digits).
+
+commit_message_file = ARGV[0]
+branch_name = `git branch --no-color 2> /dev/null`[/^\* (.+)/, 1].to_s
+original_commit_message = File.read(commit_message_file).strip
+
+branch_ticket_pattern = /([A-Z]{2,5}-\d+)/i
+skip_if_already_prefixed = /\A\[[A-Z]{2,5}-\d+\]/i
+
+if (m = branch_name.match(branch_ticket_pattern))
+  jira_ticket = m.captures.first
+
+  unless original_commit_message.match?(skip_if_already_prefixed) || original_commit_message.include?(jira_ticket)
+    message = "[#{jira_ticket}] #{original_commit_message}"
+    File.open(commit_message_file, 'w') { |f| f.write message }
+  end
+end

data/templates/shared/pre_commit/debugger_check.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Warns when staged files contain debugger statements (Ruby, JavaScript/TypeScript, Python).
+# Does not block the commit. Expects RailsGitHooks::GIT_DIR to be set by the loader.
+
+# [ extension => [ [ regex, label ], ... ] ]
+DEBUGGER_PATTERNS = {
+  '.rb' => [
+    [/\bbinding\.pry\b/, 'binding.pry'],
+    [/\bbinding\.irb\b/, 'binding.irb'],
+    [/\bdebugger\b/, 'debugger'],
+    [/\bbyebug\b/, 'byebug']
+  ],
+  '.js' => [[/\bdebugger\s*;?/, 'debugger']],
+  '.jsx' => [[/\bdebugger\s*;?/, 'debugger']],
+  '.ts' => [[/\bdebugger\s*;?/, 'debugger']],
+  '.tsx' => [[/\bdebugger\s*;?/, 'debugger']],
+  '.mjs' => [[/\bdebugger\s*;?/, 'debugger']],
+  '.cjs' => [[/\bdebugger\s*;?/, 'debugger']],
+  '.py' => [
+    [/\bbreakpoint\s*\(\s*\)/, 'breakpoint()'],
+    [/\bpdb\.set_trace\s*\(\s*\)/, 'pdb.set_trace()'],
+    [/\bipdb\.set_trace\s*\(\s*\)/, 'ipdb.set_trace()']
+  ]
+}.freeze
+
+staged = `git diff --cached --name-only`.split("\n").map(&:strip).reject(&:empty?)
+warnings = []
+
+staged.each do |path|
+  next unless File.file?(path)
+
+  ext = File.extname(path)
+  patterns = DEBUGGER_PATTERNS[ext]
+  next unless patterns
+
+  File.read(path).lines.each_with_index do |line, i|
+    patterns.each do |regex, label|
+      warnings << "#{path}:#{i + 1}: #{label}" if line.match?(regex)
+    end
+  end
+end
+
+unless warnings.empty?
+  warn 'Warning (debugger check):'
+  warnings.uniq.each { |e| warn "  #{e}" }
+end
+# Does not exit 1 — commit is never blocked by this check

data/templates/shared/pre_commit/default_branch.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Prevent commits on default branch (master/main).
+
+branch = `git rev-parse --abbrev-ref HEAD`.strip
+if %w[master main].include?(branch)
+  warn "Commits on '#{branch}' are not allowed. Create a feature branch."
+  exit 1
+end

data/templates/shared/pre_commit/rubocop_check.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# RuboCop on staged .rb files (off by default; enable with rails_git_hooks enable rubocop-check).
+# Expects RailsGitHooks::GIT_DIR to be set by the loader.
+
+git_dir = RailsGitHooks::GIT_DIR
+rubocop_check_file = File.join(git_dir, 'rails_git_hooks_rubocop')
+if File.exist?(rubocop_check_file)
+  require 'english'
+  require 'rubocop'
+
+  ADDED_OR_MODIFIED = /A|AM|^M/.freeze
+
+  changed_files = `git status --porcelain`.split(/\n/)
+                                          .select { |file_name_with_status| file_name_with_status =~ ADDED_OR_MODIFIED }
+                                          .map { |file_name_with_status| file_name_with_status.split(' ')[1] }
+                                          .select { |file_name| File.extname(file_name) == '.rb' }
+                                          .join(' ')
+
+  unless changed_files.empty?
+    system("rubocop #{changed_files}")
+    exit $CHILD_STATUS.to_s[-1].to_i
+  end
+end

data/templates/shared/pre_commit/whitespace_check.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Trailing whitespace / conflict markers (off by default; enable with rails_git_hooks enable whitespace-check).
+# Expects RailsGitHooks::GIT_DIR to be set by the loader.
+
+git_dir = RailsGitHooks::GIT_DIR
+whitespace_check_file = File.join(git_dir, 'rails_git_hooks_whitespace_check')
+if File.exist?(whitespace_check_file)
+  staged = `git diff --cached --name-only`.split("\n").map(&:strip).reject(&:empty?)
+  errors = []
+  staged.each do |path|
+    next unless File.file?(path)
+
+    File.read(path).lines.each_with_index do |line, i|
+      errors << "#{path}:#{i + 1}: trailing whitespace" if line.match?(/[ \t]\z/)
+      stripped = line.strip
+      errors << "#{path}:#{i + 1}: conflict marker" if stripped.start_with?('<<<<<<<', '=======', '>>>>>>>')
+    end
+  end
+  unless errors.empty?
+    warn 'Commit rejected (whitespace/conflict check):'
+    errors.uniq.each { |e| warn "  #{e}" }
+    exit 1
+  end
+end

data/templates/shared/pre_push/run_tests.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Runs the full test suite before push; aborts push if tests fail.
+# Uses bundle exec rspec. For Minitest, edit to use bundle exec rake test.
+
+require 'english'
+
+system('bundle exec rspec')
+exit $CHILD_STATUS.to_s[-1].to_i

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_git_hooks
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Nikita Nazarov
@@ -65,11 +65,18 @@ files:
 - bin/rails_git_hooks
 - lib/rails_git_hooks.rb
 - lib/rails_git_hooks/cli.rb
+- lib/rails_git_hooks/constants.rb
 - lib/rails_git_hooks/installer.rb
-- lib/rails_git_hooks/templates/commit-msg
-- lib/rails_git_hooks/templates/pre-commit
-- lib/rails_git_hooks/templates/pre-push
 - lib/rails_git_hooks/version.rb
+- templates/hooks/commit-msg
+- templates/hooks/pre-commit
+- templates/hooks/pre-push
+- templates/shared/commit_msg/jira_prefix.rb
+- templates/shared/pre_commit/debugger_check.rb
+- templates/shared/pre_commit/default_branch.rb
+- templates/shared/pre_commit/rubocop_check.rb
+- templates/shared/pre_commit/whitespace_check.rb
+- templates/shared/pre_push/run_tests.rb
 homepage: https://github.com/NikitaNazarov1/rails_git_hooks
 licenses:
 - MIT

data/lib/rails_git_hooks/templates/commit-msg

@@ -1,32 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# Git commit-msg hook: if branch name contains a Jira ticket (e.g. APD-1234),
-# prepends "[APD-1234] " to commit messages unless already present.
-# JIRA_PROJECT_KEY is replaced at install time by git_hooks; for manual install, replace it with your project key.
-
-# Git runs hooks with CWD = repo root; find .git from here
-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')
-end
-
-commit_message_file = ARGV[0]
-branch_name = `git branch --no-color 2> /dev/null`[/^\* (.+)/, 1].to_s
-original_commit_message = File.read(commit_message_file).strip
-
-pattern = /(JIRA_PROJECT_KEY-\d+)/i
-
-if (m = branch_name.match(pattern))
-  jira_number = m.captures.first
-
-  exit 0 if original_commit_message.include?(jira_number)
-
-  message = "[#{jira_number}] #{original_commit_message}"
-  File.open(commit_message_file, 'w') { |f| f.write message }
-end

data/lib/rails_git_hooks/templates/pre-commit

@@ -1,58 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# Runs RuboCop on staged .rb files. Commit is aborted if RuboCop reports offenses.
-
-# Git runs hooks with CWD = repo root; find .git from here
-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?('pre-commit')
-end
-
-# Trailing whitespace / conflict markers check (disabled by default; enable with .git/rails_git_hooks_whitespace_check)
-whitespace_check_file = File.join(git_dir, 'rails_git_hooks_whitespace_check')
-if File.exist?(whitespace_check_file)
-  staged = `git diff --cached --name-only`.split("\n").map(&:strip).reject(&:empty?)
-  errors = []
-  staged.each do |path|
-    next unless File.file?(path)
-
-    File.read(path).lines.each_with_index do |line, i|
-      errors << "#{path}:#{i + 1}: trailing whitespace" if line.match?(/[ \t]\z/)
-      stripped = line.strip
-      errors << "#{path}:#{i + 1}: conflict marker" if stripped.start_with?('<<<<<<<', '=======', '>>>>>>>')
-    end
-  end
-  unless errors.empty?
-    warn 'Commit rejected (whitespace/conflict check):'
-    errors.uniq.each { |e| warn "  #{e}" }
-    exit 1
-  end
-end
-
-# Prevent commits on default branch (master/main)
-branch = `git rev-parse --abbrev-ref HEAD`.strip
-if %w[master main].include?(branch)
-  warn "Commits on '#{branch}' are not allowed. Create a feature branch."
-  exit 1
-end
-
-require 'english'
-require 'rubocop'
-
-ADDED_OR_MODIFIED = /A|AM|^M/.freeze
-
-changed_files = `git status --porcelain`.split(/\n/)
-                                        .select { |file_name_with_status| file_name_with_status =~ ADDED_OR_MODIFIED }
-                                        .map { |file_name_with_status| file_name_with_status.split(' ')[1] }
-                                        .select { |file_name| File.extname(file_name) == '.rb' }
-                                        .join(' ')
-
-system("rubocop #{changed_files}") unless changed_files.empty?
-
-exit $CHILD_STATUS.to_s[-1].to_i