Using the Sprout Method for Safe Code Refactoring in C++

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:

OrderProcessor.hpp

#ifndef SOLUTION_HPP_
#define SOLUTION_HPP_

#include <vector>
#include <chrono>

struct OrderItem {
    double price;
    int quantity;
};

struct Order {
    std::vector<OrderItem> items;
    std::chrono::system_clock::time_point processed_at;
    double order_total = 0.0;
    double surcharge_amount = 0.0;
};

class OrderProcessor {
public:
    bool process_order(Order& order);
    bool process_order_with_surcharge(Order& order, double surcharge_percentage);
};

#endif  // SOLUTION_HPP_

OrderProcessor.cpp

#include "OrderProcessor.hpp"
#include <stdexcept>

bool OrderProcessor::process_order(Order& order) {
    double total_amount = 0.0;
    for (const auto& item : order.items) {
        double item_price = item.price * item.quantity;
        total_amount += item_price;
    }
    
    order.processed_at = std::chrono::system_clock::now();
    order.order_total = total_amount;
    return true;
}

bool OrderProcessor::process_order_with_surcharge(Order& order, double surcharge_percentage) {
    if (surcharge_percentage < 0) {
        throw std::invalid_argument("Surcharge percentage cannot be negative");
    }

    process_order(order);

    double surcharge_amount = order.order_total * (surcharge_percentage / 100.0);
    
    order.processed_at = std::chrono::system_clock::now();
    order.order_total += surcharge_amount;
    order.surcharge_amount = surcharge_amount;
    return true;
}

By creating a new method (process_order_with_surcharge), we encapsulate the additional functionality without altering the existing process_order method. This approach reduces the risk of introducing bugs into the original code and demonstrates the sprout method in action.