A repository demonstrating pre-commit hooks for Java projects with Maven, JUnit 5, Spotless (google-java-format), and Checkstyle.

• Maven project structure with JDK 11 compatibility
• JUnit 5 (latest version) for testing with parameterized tests
• Spotless with google-java-format for automatic code formatting
• Checkstyle with Google Java Style checks
• Pre-commit hooks with lint-staged style functionality (runs only on staged files)
• Dummy test classes to demonstrate the setup

• Java 11 or higher
• Maven 3.6 or higher
• Python 3.6+ (for pre-commit framework)
• pip3 (Python package manager)

Run the automated setup script:

./quick-start.sh

This will automatically:

1. Install pre-commit (if not already installed)
2. Install git hooks
3. Build the project
4. Run pre-commit hooks on all files

git clone <repository-url>
cd pre-commit-hooks-for-java

pip3 install pre-commit

pre-commit install

./verify-setup.sh

This script will:

• Check if pre-commit is installed
• Check if git hooks are installed
• Verify Maven and Java installations
• Run all tests
• Run pre-commit hooks on all files

pre-commit run --all-files

pre-commit-hooks-for-java/
├── src/
│   ├── main/
│   │   └── java/
│   │       └── com/
│   │           └── precommit/
│   │               └── demo/
│   │                   ├── Calculator.java      # Simple calculator class
│   │                   └── StringUtils.java     # String utility class
│   └── test/
│       └── java/
│           └── com/
│               └── precommit/
│                   └── demo/
│                       ├── CalculatorTest.java  # JUnit 5 tests for Calculator
│                       └── StringUtilsTest.java # JUnit 5 tests for StringUtils
├── hooks/
│   ├── spotless-hook.sh      # Spotless formatting check hook
│   └── checkstyle-hook.sh    # Checkstyle check hook
├── pom.xml                   # Maven configuration
├── .pre-commit-config.yaml   # Pre-commit hooks configuration
├── verify-setup.sh           # Setup verification script
└── README.md

# Run all tests
mvn test

# Run tests with coverage
mvn clean test

# Run a specific test class
mvn test -Dtest=CalculatorTest

# Check formatting
mvn spotless:check

# Apply formatting
mvn spotless:apply

# Run checkstyle
mvn checkstyle:check

# Clean and compile
mvn clean compile

# Package the application
mvn clean package

# Run full build with all checks
mvn clean verify

The project uses pre-commit hooks to ensure code quality before commits. The hooks include:

• trailing-whitespace: Removes trailing whitespace
• end-of-file-fixer: Ensures files end with a newline
• check-yaml: Validates YAML file syntax
• check-added-large-files: Prevents committing large files
• check-merge-conflict: Checks for merge conflict markers
• mixed-line-ending: Ensures consistent line endings

• Spotless Format Check: Runs google-java-format on staged Java files only
• Checkstyle: Runs Google Java Style checks on staged Java files only

1. When you run git commit, pre-commit automatically runs configured hooks
2. Java hooks only check staged files (similar to lint-staged in Node.js)
3. If any hook fails, the commit is blocked
4. Fix the issues and try committing again

# Run all hooks on all files
pre-commit run --all-files

# Run a specific hook
pre-commit run spotless-format-check --all-files
pre-commit run checkstyle --all-files

# Run hooks on specific files
pre-commit run --files src/main/java/com/precommit/demo/Calculator.java

1. Make changes to Java files
2. Stage your changes:

   git add src/main/java/com/precommit/demo/Calculator.java

3. Try to commit:

   git commit -m "Add new calculation method"

4. Pre-commit hooks run automatically on staged files
5. If formatting issues are found:

   mvn spotless:apply
   git add .
   git commit -m "Add new calculation method"

A simple calculator demonstrating:

• Basic arithmetic operations (add, subtract, multiply, divide)
• Exception handling (division by zero)
• Javadoc documentation

A string utility class demonstrating:

• String manipulation (reverse, palindrome check)
• Word counting
• Title case conversion

• JUnit 5 annotations (@Test, @BeforeEach, @DisplayName)
• Parameterized tests (@ParameterizedTest, @CsvSource, @ValueSource)
• Assertions (assertEquals, assertThrows, assertTrue, assertFalse)
• Test organization with nested test classes

• maven-compiler-plugin: Compiles Java code with JDK 11
• maven-surefire-plugin: Runs JUnit tests
• spotless-maven-plugin: Formats code with google-java-format
• maven-checkstyle-plugin: Validates code style with Google Java Style

• junit-jupiter-api: JUnit 5 API for writing tests
• junit-jupiter-engine: JUnit 5 test engine
• junit-jupiter-params: Parameterized tests support

1. Lint-staged Style: Pre-commit hooks only run on staged files, not the entire codebase
2. Fast Feedback: Catches formatting and style issues before they enter version control
3. Consistent Code Style: Enforces Google Java Style automatically
4. Comprehensive Testing: Demonstrates various JUnit 5 features
5. Easy to Extend: Simple to add more hooks or modify existing ones

When contributing to this repository:

1. Ensure all tests pass: mvn test
2. Format your code: mvn spotless:apply
3. Check code style: mvn checkstyle:check
4. Commit your changes (pre-commit hooks will run automatically)

See LICENSE file for details.

• Pre-commit Framework
• Spotless
• Checkstyle
• JUnit 5
• Google Java Style Guide