Incremental Java Programmer

Incremental Java Programmer

Overview

Implement new features in Java repositories by analyzing the codebase, generating implementation code, creating comprehensive tests, and ensuring all tests pass before completion.

Workflow

1. Analyze Repository Structure

Understand the Java project structure and build system:

Identify build system:

• Maven: Look for pom.xml in root directory
• Gradle: Look for build.gradle or build.gradle.kts

Examine project structure:

src/
├── main/
│   └── java/
│       └── com/example/project/
│           ├── model/
│           ├── service/
│           ├── controller/
│           └── util/
└── test/
    └── java/
        └── com/example/project/
            ├── model/
            ├── service/
            └── controller/

Extract key information:

• Package structure and naming conventions
• Existing class hierarchy and relationships
• Dependencies from pom.xml or build.gradle
• Testing framework (JUnit 4, JUnit 5, TestNG)
• Code style and patterns used in the project

2. Parse Feature Description

Break down the natural language feature description into actionable components:

Identify feature type:

• New functionality: Adding entirely new capabilities
• Enhancement: Extending existing functionality
• Modification: Changing existing behavior

Extract requirements:

• What classes/methods need to be created or modified
• Input parameters and return types
• Business logic and validation rules
• Error handling requirements
• Integration points with existing code

Example feature description:

"Add a method to calculate the total price of items in a shopping cart,
including tax. The tax rate should be configurable. If the cart is empty,
return 0. The method should throw an exception if the tax rate is negative."

Parsed components:

• Target class: ShoppingCart
• New method: calculateTotalWithTax(double taxRate)
• Return type: double
• Validation: Check for negative tax rate, handle empty cart
• Exception: IllegalArgumentException for negative tax rate

3. Locate Target Files

Find where the implementation should be added:

For new classes:

• Determine appropriate package based on functionality
• Follow existing package structure conventions
• Place in src/main/java/[package-path]/

For existing classes:

• Use Grep to find the target class
• Read the class to understand current structure
• Identify where new methods should be added

For modifications:

• Locate the specific method to modify
• Understand current implementation
• Plan minimal changes to achieve feature

4. Implement Feature Code

Write Java code following project conventions:

Code structure:

/**
 * [Javadoc description of what the method does]
 *
 * @param paramName description of parameter
 * @return description of return value
 * @throws ExceptionType description of when exception is thrown
 */
public ReturnType methodName(ParamType paramName) {
    // Input validation
    if (invalidCondition) {
        throw new IllegalArgumentException("Error message");
    }

    // Business logic
    ReturnType result = performCalculation();

    // Return result
    return result;
}

Best practices:

• Follow existing code style (indentation, naming, formatting)
• Add comprehensive Javadoc comments
• Include input validation
• Handle edge cases
• Use appropriate access modifiers
• Follow SOLID principles
• Avoid code duplication

For new classes:

package com.example.project.service;

import java.util.List;

/**
 * Service class for managing shopping cart operations.
 */
public class ShoppingCartService {

    private final TaxCalculator taxCalculator;

    public ShoppingCartService(TaxCalculator taxCalculator) {
        this.taxCalculator = taxCalculator;
    }

    // Methods here
}

5. Generate Unit Tests

Create comprehensive JUnit tests for the new functionality:

Test class structure:

package com.example.project.service;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import static org.junit.jupiter.api.Assertions.*;

class ShoppingCartServiceTest {

    private ShoppingCartService service;

    @BeforeEach
    void setUp() {
        service = new ShoppingCartService(new TaxCalculator());
    }

    @Test
    @DisplayName("Should calculate total with tax correctly")
    void testCalculateTotalWithTax() {
        // Arrange
        double subtotal = 100.0;
        double taxRate = 0.08;

        // Act
        double result = service.calculateTotalWithTax(subtotal, taxRate);

        // Assert
        assertEquals(108.0, result, 0.01);
    }

    @Test
    @DisplayName("Should throw exception for negative tax rate")
    void testNegativeTaxRate() {
        assertThrows(IllegalArgumentException.class, () -> {
            service.calculateTotalWithTax(100.0, -0.05);
        });
    }

    @Test
    @DisplayName("Should return zero for empty cart")
    void testEmptyCart() {
        double result = service.calculateTotalWithTax(0.0, 0.08);
        assertEquals(0.0, result, 0.01);
    }
}

Test coverage requirements:

• Happy path (normal operation)
• Edge cases (empty inputs, boundary values)
• Error cases (invalid inputs, exceptions)
• Integration with existing code

Test naming conventions:

• Use descriptive test method names
• Follow project's existing test naming pattern
• Use @DisplayName for readable test descriptions

6. Update Existing Tests

Modify existing tests if the feature changes existing behavior:

Identify affected tests:

• Search for tests that call modified methods
• Find tests that assert on changed behavior
• Locate integration tests that may be affected

Update test assertions:

// Before
assertEquals(100.0, cart.getTotal());

// After (if feature adds tax calculation)
assertEquals(108.0, cart.getTotalWithTax(0.08));

Add new test cases:

• Test interactions between new and existing features
• Verify backward compatibility if applicable
• Test integration points