Sprout Method - Reducing Risk of Adding New Features

Welcome to this course. The focus will be "Using Sprout and Wrap Techniques for Refactoring and to Expand Capabilities"! To start off, we will explore the sprout method, a technique that can, among other things, help us safely add new features to existing codebases.

This method is particularly useful when working with established codebases, where the risk of breaking existing functionality is high. By the end of this lesson, we'll understand how to use the sprout method to enhance our code's modularity and testability.

The sprout method is a refactoring technique that involves creating new methods or classes to encapsulate additional functionality. This approach allows us to introduce new features without altering existing code, thereby minimizing the risk of breaking it.

By isolating new behavior in separate methods, we can improve the modularity of our code, making it easier to understand and maintain. The sprout method is particularly effective in scenarios where we need to expand capabilities while preserving the original behavior.

Let's walk through a step-by-step guide on how to apply the sprout method to add new features. We'll use a simple example to illustrate the process:

import model.{Order, OrderItem}
import java.time.LocalDateTime

class OrderProcessor:
  def processOrder(order: Order): (Boolean, Order) =
    val totalAmount = order.items.map(item => item.price * item.quantity).sum
    
    (true, order.copy(
      processedAt = Some(LocalDateTime.now),
      orderTotal = totalAmount
    ))

Suppose we want to add a surcharge to the order total. Instead of modifying the existing processOrder method, we can create a new method called processOrderWithSurcharge:

  def processOrderWithSurcharge(order: Order, surchargePercentage: BigDecimal): (Boolean, Order) =
    if surchargePercentage < 0 then
      throw IllegalArgumentException("Surcharge percentage cannot be negative")

    val (_, processedOrder) = processOrder(order)
    val surchargeAmount = processedOrder.orderTotal * (surchargePercentage / 100)
    
    (true, processedOrder.copy(
      processedAt = Some(LocalDateTime.now),
      orderTotal = processedOrder.orderTotal + surchargeAmount,
      surchargeAmount = surchargeAmount
    ))

By creating a new method, we encapsulate the additional functionality without altering the existing processOrder method. This approach reduces the risk of introducing bugs into the original code.