Custom Git extensions

Basic Concepts of Git Extensions

Git extensions are essentially supplements and enhancements to Git's functionality. They can be command-line tools, scripts, or plugins used to simplify common tasks or add new features. Git itself provides an extension mechanism that allows users to load extensions via the core.extensions configuration item in git config.

Extensions are typically stored in Git's libexec/git-core directory or in a user-defined path. When executing the git <extname> command, Git automatically searches for the corresponding executable file in the configured paths.

# View Git extension paths
git --exec-path

Creating Custom Git Extensions

Basic Shell Script Extensions

The simplest Git extensions are shell scripts. Create a file named git-custom, add executable permissions, and place it in the PATH:

#!/bin/sh
echo "This is a custom Git extension"
echo "Current branch: $(git branch --show-current)"

After making it executable with chmod +x git-custom, you can call it via git custom.

Python-Based Complex Extensions

For more complex functionality, you can use higher-level languages like Python:

#!/usr/bin/env python3
import subprocess
import sys

def get_commit_stats():
    result = subprocess.run(['git', 'log', '--pretty=format:%h %s'], 
                          capture_output=True, text=True)
    commits = result.stdout.split('\n')
    return {i: commit for i, commit in enumerate(commits, 1)}

if __name__ == '__main__':
    stats = get_commit_stats()
    for num, commit in stats.items():
        print(f"{num}. {commit}")

Practical Use Cases for Extensions

Automated Commit Message Generation

Create a git-ac extension to automatically generate standardized commit messages:

#!/bin/bash
TYPE=$1
SCOPE=$2
DESC=$3

if [ -z "$TYPE" ] || [ -z "$DESC" ]; then
    echo "Usage: git ac <type> [scope] <description>"
    exit 1
fi

if [ -n "$SCOPE" ]; then
    MESSAGE="$TYPE($SCOPE): $DESC"
else
    MESSAGE="$TYPE: $DESC"
fi

git commit -m "$MESSAGE"

Usage example:

git ac feat user "add login functionality"

Enhanced Branch Management

The git-bclean extension is used to clean up merged branches:

#!/usr/bin/env python3
import subprocess

def get_merged_branches():
    result = subprocess.run(['git', 'branch', '--merged'], 
                          capture_output=True, text=True)
    branches = [b.strip() for b in result.stdout.split('\n') 
               if b.strip() and not b.startswith('*')]
    return branches

def delete_branches(branches):
    for branch in branches:
        subprocess.run(['git', 'branch', '-d', branch])

if __name__ == '__main__':
    merged = get_merged_branches()
    if merged:
        print("Deleting merged branches:")
        print('\n'.join(merged))
        delete_branches(merged)
    else:
        print("No merged branches to delete")

Advanced Extension Techniques

Enhancing Extensions with Git Hooks

Combining Git hooks can create more powerful workflows. For example, a pre-commit hook to check code style:

#!/usr/bin/env node
const { execSync } = require('child_process')
const chalk = require('chalk')

try {
  const stagedFiles = execSync('git diff --cached --name-only --diff-filter=ACM')
    .toString()
    .split('\n')
    .filter(Boolean)
  
  if (stagedFiles.some(file => file.endsWith('.js'))) {
    console.log(chalk.blue('Running ESLint on staged files...'))
    execSync('npx eslint --fix ' + stagedFiles.join(' '), { stdio: 'inherit' })
    execSync('git add ' + stagedFiles.join(' '))
  }
} catch (error) {
  console.log(chalk.red('ESLint check failed:'))
  process.exit(1)
}

Extensions Integrating Third-Party APIs

Create extensions that integrate with project management tools, such as automatically creating GitHub issues:

#!/usr/bin/env python3
import requests
import sys
from configparser import ConfigParser

def load_config():
    config = ConfigParser()
    config.read('.git/config')
    return config

def create_github_issue(title, body):
    config = load_config()
    repo_url = config.get('remote "origin"', 'url')
    # Extract owner/repo
    # GitHub API call logic...
    
if __name__ == '__main__':
    if len(sys.argv) < 2:
        print("Usage: git issue <title> [body]")
        sys.exit(1)
    create_github_issue(sys.argv[1], ' '.join(sys.argv[2:]))

Distributing and Sharing Extensions

Distributing via Git Repositories

Place extensions in a standalone Git repository for users to clone and install:

git clone https://github.com/user/git-extensions.git
cd git-extensions
make install  # Copy scripts to ~/bin or /usr/local/bin

Packaging as Homebrew/Linuxbrew Formulas

For macOS/Linux users, create Homebrew formulas:

class GitExt < Formula
  desc "Collection of useful Git extensions"
  homepage "https://github.com/user/git-ext"
  url "https://github.com/user/git-ext/archive/v1.0.0.tar.gz"
  
  def install
    bin.install Dir["bin/*"]
  end
end

Debugging and Testing Git Extensions

Unit Testing Frameworks

Write unit tests for Python extensions:

import unittest
from unittest.mock import patch
from git_bclean import get_merged_branches

class TestGitExtensions(unittest.TestCase):
    @patch('subprocess.run')
    def test_get_merged_branches(self, mock_run):
        mock_run.return_value.stdout = "  master\n* feature\n  develop\n"
        branches = get_merged_branches()
        self.assertEqual(branches, ['master', 'develop'])

if __name__ == '__main__':
    unittest.main()

Debugging Shell Scripts

Use set -x to enable debug mode:

#!/bin/bash
set -x  # Enable debugging
# Extension logic...
set +x  # Disable debugging

Performance Optimization Tips

Reducing Subprocess Calls

Combine multiple Git command calls:

# Inefficient way
branch=$(git branch --show-current)
hash=$(git rev-parse HEAD)

# Efficient way
read -r branch hash <<< $(git rev-parse --abbrev-ref HEAD HEAD)

Implementing Caching Mechanisms

Implement caching for time-consuming operations:

import os
import pickle
from functools import wraps
from datetime import datetime, timedelta

def cache_result(expire_minutes=10):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            cache_file = f"/tmp/git_{func.__name__}.cache"
            if os.path.exists(cache_file):
                with open(cache_file, 'rb') as f:
                    data, timestamp = pickle.load(f)
                    if datetime.now() - timestamp < timedelta(minutes=expire_minutes):
                        return data
            
            result = func(*args, **kwargs)
            with open(cache_file, 'wb') as f:
                pickle.dump((result, datetime.now()), f)
            return result
        return wrapper
    return decorator

Security Considerations

Input Validation

Strictly validate all user inputs:

#!/bin/bash
branch_name=$1

# Validate branch name legality
if ! [[ "$branch_name" =~ ^[a-zA-Z0-9_\-]+$ ]]; then
    echo "Error: Invalid branch name"
    exit 1
fi

git checkout -b "$branch_name"

Permission Management

Check permissions before sensitive operations:

import os
import sys

def check_write_permission():
    if os.access('.git', os.W_OK):
        return True
    print("Error: No write permission to .git directory", file=sys.stderr)
    return False

if not check_write_permission():
    sys.exit(1)