Clang-Format

import clang_format

from clang_format import get_executable

from clang_format import git_clang_format, clang_format_diff

# Format a single file
clang-format main.cpp

# Format with specific style
clang-format -style=Google main.cpp

# Format in-place
clang-format -i main.cpp

# Format multiple files
clang-format *.cpp *.h

# Git integration - format staged changes
git-clang-format

# Format specific lines from diff
clang-format-diff.py

import clang_format
import subprocess

# Get path to clang-format executable
exe_path = clang_format.get_executable('clang-format')
print(f"clang-format executable: {exe_path}")

# Use subprocess to run clang-format programmatically
result = subprocess.run([
    exe_path, 
    '-style=LLVM', 
    'source.cpp'
], capture_output=True, text=True)

formatted_code = result.stdout

repos:
- repo: https://github.com/pre-commit/mirrors-clang-format
  rev: v21.1.0
  hooks:
  - id: clang-format
    types_or: [c++, c, cuda]

def get_executable(name):
    """
    Get the full path to the specified executable.
    
    Parameters:
    - name: str, name of the executable (e.g., "clang-format")
    
    Returns:
    str: Full path to the executable in the package's data/bin directory
    """

import clang_format
import subprocess

# Get executable path
exe_path = clang_format.get_executable('clang-format')

# Use with subprocess for custom formatting
result = subprocess.run([
    exe_path, 
    '-style=file',  # Use .clang-format file
    '-i',           # Format in-place
    'source.cpp'
], check=True)

def clang_format():
    """
    Execute clang-format with command-line arguments from sys.argv.
    
    This function processes sys.argv[1:] as arguments and exits with
    the subprocess return code. Intended for console script usage.
    
    Raises:
    SystemExit: Always exits with subprocess return code
    """

import sys
import clang_format

# Programmatically set arguments
sys.argv = ['clang-format', '-style=Google', 'main.cpp']

# Execute (will exit process)
clang_format.clang_format()

def main():
    """
    Main entry point for git-clang-format integration.
    
    Processes command-line arguments and executes git-aware formatting,
    applying clang-format selectively to changed lines in git repositories.
    
    Returns:
    int: Exit code (0 for no changes, 1 for changes applied)
    """

from clang_format import git_clang_format

import sys
from clang_format import git_clang_format

# Set arguments for git integration
sys.argv = ['git-clang-format', '--diff', 'HEAD~1']

# Execute git-aware formatting
result = git_clang_format.main()
print(f"Exit code: {result}")

def main():
    """
    Main entry point for diff-based selective formatting.
    
    Reads unified diff from stdin and applies clang-format only to 
    the changed lines, supporting selective formatting workflows.
    
    Returns:
    int: Status code (1 if differences found, subprocess return code on failure)
    """

from clang_format import clang_format_diff

import sys
import io
from clang_format import clang_format_diff

# Prepare diff input
diff_content = """--- a/example.cpp
+++ b/example.cpp
@@ -1,3 +1,4 @@
 int main() {
-  return 0;
+    return 0;
+    // Comment
 }
"""

# Redirect stdin and execute
old_stdin = sys.stdin
sys.stdin = io.StringIO(diff_content)
sys.argv = ['clang-format-diff.py', '-i']

result = clang_format_diff.main()
sys.stdin = old_stdin

clang-format [options] [files...]

git clang-format [git-options]

clang-format-diff.py [diff-options]

# Install in CI environment
pip install clang-format

# Check formatting in CI
clang-format --dry-run --Werror *.cpp *.h

# Install with pipx for isolated usage
pipx install clang-format

# Format before commit
git add .
git clang-format
git commit -m "Apply clang-format"

import clang_format
import subprocess
import os

def format_project_files():
    """Format all C++ files in project."""
    exe_path = clang_format.get_executable('clang-format')
    
    for root, dirs, files in os.walk('.'):
        for file in files:
            if file.endswith(('.cpp', '.h', '.cc', '.hpp')):
                filepath = os.path.join(root, file)
                subprocess.run([exe_path, '-i', filepath], check=True)
                print(f"Formatted: {filepath}")

# Usage
format_project_files()