EnvExpander.cpp

Go to the documentation of this file.

/**
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @author     Fabian Reister ( fabian dot reister at kit dot edu )
 * @date       2025
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include "EnvExpander.h"
 
#include <cstdlib>
#include <iostream>
#include <stdexcept>
#include <string>
#include <tuple>
#include <unordered_set>
#include <vector>
 
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/process/environment.hpp>
#include <boost/regex.hpp> // IWYU pragma: keep
 
// these are the individual includes for boost::regex v5
// #include <boost/regex/v5/regex.hpp>
// #include <boost/regex/v5/regex_fwd.hpp>
// #include <boost/regex/v5/regex_replace.hpp>
 
#include <SimoxUtility/algorithm/string/string_tools.h>
 
namespace
{
    // Expand leading `~` in each colon-separated segment to $HOME. This is
    // file-local to keep expandVariables shorter and clearer.
    void
    expandTildeSegments(std::string& text)
    {
        if (text.empty())
        {
            return;
        }
 
        const char* home = std::getenv("HOME");
        bool warnedHome = false;
 
        std::vector<std::string> segments;
        boost::split(segments, text, boost::is_any_of(":"));
        for (auto& seg : segments)
        {
            if (!seg.empty() && seg[0] == '~')
            {
                // Only treat `~` or `~/...` as expansion
                if (seg.size() == 1 || seg[1] == '/')
                {
                    if (home == nullptr)
                    {
                        if (!warnedHome)
                        {
                            std::cerr << "[EnvExpander] Warning: HOME is not defined, cannot "
                                         "expand '~'\n";
                            warnedHome = true;
                        }
                        seg.erase(0, 1); // remove leading '~'
                    }
                    else
                    {
                        std::string h(home);
                        // replace leading '~' with home
                        seg.erase(0, 1);
                        seg.insert(0, h);
                    }
                }
            }
        }
 
        // Rejoin
        std::string joined;
        for (size_t i = 0; i < segments.size(); ++i)
        {
            if (i != 0)
            {
                joined += ':';
            }
            joined += segments[i];
        }
        text = joined;
    }
 
} // anonymous namespace
 
namespace armarx::core::system
{
 
 
    EnvExpander::EnvExpander() : env_(boost::this_process::environment())
    {
    }
 
    void
    EnvExpander::apply(const std::string& input, bool expandExisting)
    {
        // check if we need to expand existing env vars. It could be that there is nothing to do
        if (not simox::alg::contains(input, "="))
        {
            return;
        }
 
        if (expandExisting)
        {
            // version that takes the updated env into account
 
            auto assignments = splitAssignments(input);
 
            for (const auto& assign : assignments)
            {
                auto [name, op, value] = splitOperation(assign);
                auto expanded = expandVariables(value);
                applyOperation(name, op, expanded);
            }
        }
        else
        {
            // version that does not take the updated env into account
 
            std::string expanded = expand(input);
            auto assignments = splitAssignments(expanded);
            for (const auto& assign : assignments)
            {
                auto [name, op, value] = splitOperation(assign);
                applyOperation(name, op, value);
            }
        }
    }
 
    std::string
    EnvExpander::expand(const std::string& input)
    {
        // check if we need to expand existing env vars. It could be that there is nothing to do
        if (not simox::alg::contains(input, "="))
        {
            return input;
        }
 
        auto assignments = splitAssignments(input);
 
        std::vector<std::string> out;
        out.reserve(assignments.size());
 
        for (const auto& assign : assignments)
        {
            auto [name, op, value] = splitOperation(assign);
            auto expanded = expandVariables(value);
 
            std::string rep;
            switch (op)
            {
                case Operation::Replace:
                {
                    rep = name;
                    rep += '=';
                    rep += expanded;
                    break;
                }
                case Operation::Append:
                {
                    // Read current env value and expand its variables as well
                    const char* existing = std::getenv(name.c_str());
                    std::string oldVal = (existing != nullptr) ? existing : std::string();
                    std::string oldExpanded = expandVariables(oldVal);
 
                    rep = name;
                    rep += '=';
                    if (!oldExpanded.empty())
                    {
                        rep += oldExpanded;
                        rep += ':';
                    }
                    rep += expanded;
                    break;
                }
                case Operation::Prepend:
                {
                    const char* existing = std::getenv(name.c_str());
                    std::string oldVal = (existing != nullptr) ? existing : std::string();
                    std::string oldExpanded = expandVariables(oldVal);
 
                    rep = name;
                    rep += '=';
                    rep += expanded;
                    if (!oldExpanded.empty())
                    {
                        rep += ':';
                        rep += oldExpanded;
                    }
                    break;
                }
            }
 
            out.push_back(rep);
        }
 
        // Join with commas
        std::string joined;
        for (size_t i = 0; i < out.size(); ++i)
        {
            if (i != 0)
            {
                joined += ",";
            }
            joined += out[i];
        }
 
        return joined;
    }
 
    std::vector<std::string>
    EnvExpander::splitAssignments(const std::string& input)
    {
        std::vector<std::string> out;
        boost::split(out, input, boost::is_any_of(","));
        return out;
    }
 
    std::tuple<std::string, EnvExpander::Operation, std::string>
    EnvExpander::splitOperation(const std::string& assignment)
    {
        auto pos = assignment.find('=');
        if (pos == std::string::npos)
        {
            throw std::runtime_error("Invalid assignment: " + assignment);
        }
 
        std::string key = assignment.substr(0, pos);
        std::string rhs = assignment.substr(pos + 1);
 
        boost::trim(key);
        boost::trim(rhs);
 
        // Detect prepend: VAR=+value
        if (!rhs.empty() && rhs[0] == '+')
        {
            return {key, Operation::Prepend, rhs.substr(1)};
        }
 
        // Detect append: VAR+=value
        if (!key.empty() && key.back() == '+')
        {
            key.pop_back();
            return {key, Operation::Append, rhs};
        }
 
        // Replace (default)
        return {key, Operation::Replace, rhs};
    }
 
    std::string
    EnvExpander::expandVariables(const std::string& value)
    {
        std::string result = value;
 
        // Expand leading tilde segments to HOME (if present)
        expandTildeSegments(result);
 
        static const boost::regex reBraced(R"(\$\{([A-Za-z_][A-Za-z0-9_]*)\})");
        static const boost::regex reUnbraced(R"(\$([A-Za-z_][A-Za-z0-9_]*))");
 
        // Track undefined variables so warnings appear only once per expansion
        std::unordered_set<std::string> warned;
 
        auto expand_match = [&](const boost::smatch& m) -> std::string
        {
            std::string var = m[1].str();
            const char* v = std::getenv(var.c_str());
 
            if (!v)
            {
                if (!warned.count(var))
                {
                    std::cerr << "[EnvExpander] Warning: environment variable '" << var
                              << "' is not defined\n";
                    warned.insert(var);
                }
                return ""; // undefined → empty
            }
            return std::string(v);
        };
 
        result = boost::regex_replace(result, reBraced, expand_match);
        result = boost::regex_replace(result, reUnbraced, expand_match);
 
        return result;
    }
 
    void
    EnvExpander::applyOperation(const std::string& name, Operation op, const std::string& val)
    {
        const char* existing = std::getenv(name.c_str());
        std::string oldVal = (existing != nullptr) ? existing : "";
 
        std::string newVal;
 
        switch (op)
        {
            case Operation::Replace:
                newVal = val;
                break;
 
            case Operation::Append:
                newVal = oldVal;
                if (!oldVal.empty())
                {
                    newVal += ":";
                }
                newVal += val;
                break;
 
            case Operation::Prepend:
                newVal = val;
                if (!oldVal.empty())
                {
                    newVal += ":";
                }
                newVal += oldVal;
                break;
        }
 
        env_[name] = newVal;
        setenv(name.c_str(), newVal.c_str(), 1);
    }
} // namespace armarx::core::system