diff.h

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <sstream>
#include <string>
#include <vector>
 
#include "cppfig/value.h"
 
namespace cppfig {
 
enum class DiffType : std::uint8_t { Added,
                                     Removed,
                                     Modified };
 
struct DiffEntry {
    DiffType type;
    std::string path;
    std::string old_value;
    std::string new_value;
 
    [[nodiscard]] auto TypeString() const -> std::string
    {
        switch (type) {
        case DiffType::Added:
            return "ADDED";
        case DiffType::Removed:
            return "REMOVED";
        case DiffType::Modified:
            return "MODIFIED";
        }
        return "UNKNOWN";  // LCOV_EXCL_LINE
    }
};
 
class ConfigDiff {
public:
    std::vector<DiffEntry> entries;
 
    [[nodiscard]] auto HasDifferences() const -> bool { return !entries.empty(); }
 
    [[nodiscard]] auto Size() const -> std::size_t { return entries.size(); }
 
    [[nodiscard]] auto Filter(DiffType type) const -> std::vector<DiffEntry>
    {
        std::vector<DiffEntry> result;
        for (const auto& entry : entries) {
            if (entry.type == type) {
                result.push_back(entry);
            }
        }
        return result;
    }
 
    [[nodiscard]] auto Added() const -> std::vector<DiffEntry> { return Filter(DiffType::Added); }
 
    [[nodiscard]] auto Removed() const -> std::vector<DiffEntry> { return Filter(DiffType::Removed); }
 
    [[nodiscard]] auto Modified() const -> std::vector<DiffEntry> { return Filter(DiffType::Modified); }
 
    [[nodiscard]] auto ToString() const -> std::string
    {
        if (!HasDifferences()) {
            return "No differences found.\n";
        }
 
        std::ostringstream ss;
        ss << "Configuration differences:\n";
 
        for (const auto& entry : entries) {
            ss << "  [" << entry.TypeString() << "] " << entry.path;
            switch (entry.type) {
            case DiffType::Added:
                ss << " = " << entry.new_value;
                break;
            case DiffType::Removed:
                ss << " (was: " << entry.old_value << ")";
                break;
            case DiffType::Modified:
                ss << ": " << entry.old_value << " -> " << entry.new_value;
                break;
            }
            ss << "\n";
        }
 
        return ss.str();
    }
};
 
namespace detail {
 
    inline void CompareValueRecursive(const Value& base, const Value& target, const std::string& prefix,
                                      ConfigDiff& diff)
    {
        // Check for keys in target that are not in base (added)
        if (target.IsObject()) {
            for (const auto& [key, value] : target.Items()) {
                std::string path = prefix.empty() ? key : prefix + "." + key;
 
                if (!base.IsObject() || !base.Contains(key)) {
                    diff.entries.push_back({ DiffType::Added, path, "", value.Dump() });
                }
                else if (base[key] != value) {
                    if (base[key].IsObject() && value.IsObject()) {
                        CompareValueRecursive(base[key], value, path, diff);
                    }
                    else {
                        diff.entries.push_back({ DiffType::Modified, path, base[key].Dump(), value.Dump() });
                    }
                }
            }
        }
 
        // Check for keys in base that are not in target (removed)
        if (base.IsObject()) {
            for (const auto& [key, value] : base.Items()) {
                std::string path = prefix.empty() ? key : prefix + "." + key;
 
                if (!target.IsObject() || !target.Contains(key)) {
                    diff.entries.push_back({ DiffType::Removed, path, value.Dump(), "" });
                }
            }
        }
    }
 
}  // namespace detail
 
inline auto DiffValues(const Value& base, const Value& target) -> ConfigDiff
{
    ConfigDiff diff;
    detail::CompareValueRecursive(base, target, "", diff);
    return diff;
}
 
inline auto DiffFileFromDefaults(const Value& defaults, const Value& file_values) -> ConfigDiff
{
    return DiffValues(defaults, file_values);
}
 
inline auto DiffDefaultsFromFile(const Value& defaults, const Value& file_values) -> ConfigDiff
{
    return DiffValues(file_values, defaults);
}
 
}  // namespace cppfig