rails_git_hooks 0.7.0 → 0.7.1

data/lib/rails_git_hooks/runtime/dependency_checker.rb

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

data/lib/rails_git_hooks/runtime/file_matcher.rb

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

data/lib/rails_git_hooks/runtime/override_config.rb

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

data/lib/rails_git_hooks/runtime/policy_resolver.rb

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

data/lib/rails_git_hooks/runtime/repository.rb

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

data/lib/rails_git_hooks/runtime/runner.rb

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

data/lib/rails_git_hooks/runtime.rb

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

data/lib/rails_git_hooks/version.rb

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

data/lib/rails_git_hooks.rb

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

data/templates/hooks/commit-msg

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

data/templates/hooks/pre-commit

@@ -1,27 +1,13 @@
 #!/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')
+hooks_dir = File.dirname(File.expand_path(__FILE__))
+begin
+  require 'bundler/setup'
+rescue LoadError, StandardError
+  nil
 end
 
-module RailsGitHooks
-end
-RailsGitHooks.const_set(:GIT_DIR, git_dir.freeze)
-hooks_dir = File.dirname(File.expand_path(__FILE__))
+require File.join(hooks_dir, 'rails_git_hooks', 'runtime')
 
-load File.join(hooks_dir, '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')
+exit GitHooks::Runtime.execute(:pre_commit, argv: ARGV, stdin: $stdin.read)

data/templates/hooks/pre-push

@@ -1,23 +1,13 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-#
-# Runs the full test suite before push. Push is aborted if tests fail.
-# Logic in templates/shared/pre_push/.
-
-# 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-push')
+hooks_dir = File.dirname(File.expand_path(__FILE__))
+begin
+  require 'bundler/setup'
+rescue LoadError, StandardError
+  nil
 end
 
-module RailsGitHooks
-end
-RailsGitHooks.const_set(:GIT_DIR, git_dir.freeze)
-hooks_dir = File.dirname(File.expand_path(__FILE__))
+require File.join(hooks_dir, 'rails_git_hooks', 'runtime')
 
-load File.join(hooks_dir, 'pre_push', 'run_tests.rb')
+exit GitHooks::Runtime.execute(:pre_push, argv: ARGV, stdin: $stdin.read)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_git_hooks
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Nikita Nazarov
@@ -64,19 +64,40 @@ files:
 - README.md
 - bin/rails_git_hooks
 - lib/rails_git_hooks.rb
+- lib/rails_git_hooks/checks.rb
+- lib/rails_git_hooks/checks/base.rb
+- lib/rails_git_hooks/checks/commit_msg.rb
+- lib/rails_git_hooks/checks/commit_msg/jira_prefix.rb
+- lib/rails_git_hooks/checks/pre_commit.rb
+- lib/rails_git_hooks/checks/pre_commit/debugger_check.rb
+- lib/rails_git_hooks/checks/pre_commit/default_branch.rb
+- lib/rails_git_hooks/checks/pre_commit/json_format_check.rb
+- lib/rails_git_hooks/checks/pre_commit/migrations_check.rb
+- lib/rails_git_hooks/checks/pre_commit/rubocop.rb
+- lib/rails_git_hooks/checks/pre_commit/whitespace_check.rb
+- lib/rails_git_hooks/checks/pre_commit/yaml_format_check.rb
+- lib/rails_git_hooks/checks/pre_push.rb
+- lib/rails_git_hooks/checks/pre_push/run_tests.rb
 - lib/rails_git_hooks/cli.rb
-- lib/rails_git_hooks/constants.rb
-- lib/rails_git_hooks/installer.rb
+- lib/rails_git_hooks/config/constants.rb
+- lib/rails_git_hooks/config/defaults.yml
+- lib/rails_git_hooks/config/defaults_loader.rb
+- lib/rails_git_hooks/core/check_definition.rb
+- lib/rails_git_hooks/core/check_result.rb
+- lib/rails_git_hooks/core/error.rb
+- lib/rails_git_hooks/install/installer.rb
+- lib/rails_git_hooks/runtime.rb
+- lib/rails_git_hooks/runtime/check_registry.rb
+- lib/rails_git_hooks/runtime/dependency_checker.rb
+- lib/rails_git_hooks/runtime/file_matcher.rb
+- lib/rails_git_hooks/runtime/override_config.rb
+- lib/rails_git_hooks/runtime/policy_resolver.rb
+- lib/rails_git_hooks/runtime/repository.rb
+- lib/rails_git_hooks/runtime/runner.rb
 - 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/constants.rb

@@ -1,21 +0,0 @@
-# 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