evaluator.cpp

/*
 * Copyright 2022 The casbin Authors. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include "casbin/model/evaluator.h"

#include <functional>
#include <regex>

#include "casbin/util/util.h"

namespace casbin {
bool ExprtkEvaluator::Eval(const std::string& expression_string) {
    expression.register_symbol_table(symbol_table);
    if (enable_get) {
        expression.register_symbol_table(glbl_variable_symbol_table);
    }

    if (this->expression_string_ != expression_string) {
        this->expression_string_ = expression_string;
        // replace (&& -> and), (|| -> or)
        auto replaced_string = std::regex_replace(expression_string, std::regex("&&"), "and");
        replaced_string = std::regex_replace(replaced_string, std::regex("\\|{2}"), "or");
        // replace string "" -> ''
        replaced_string = std::regex_replace(replaced_string, std::regex("\""), "\'");

        return parser.compile(replaced_string, expression);
    }

    return this->parser.error_count() == 0;
}

void ExprtkEvaluator::InitialObject(const std::string& identifier) {
    // symbol_table.add_stringvar("");
}

void ExprtkEvaluator::EnableGet(const std::string& identifier) {
    enable_get = true;
    if (identifier.empty()) {
        glbl_variable_symbol_table.add_stringvar("key_get_result", key_get_result);
    } else {
        glbl_variable_symbol_table.add_stringvar(identifier, key_get_result);
    }
}

void ExprtkEvaluator::PushObjectString(const std::string& target, const std::string& proprity, const std::string& var) {
    auto identifier = target + "." + proprity;

    this->AddIdentifier(identifier, var);
}

void ExprtkEvaluator::PushObjectJson(const std::string& target, const std::string& proprity, const nlohmann::json& var) {
    auto identifier = target + "." + proprity;

    // Recursively flatten JSON object into dot-notation identifiers
    std::function<void(const std::string&, const nlohmann::json&)> flatten;
    flatten = [&](const std::string& prefix, const nlohmann::json& j) {
        if (j.is_object()) {
            // Recursively process nested objects
            for (auto it = j.begin(); it != j.end(); ++it) {
                std::string key = it.key();
                flatten(prefix + "." + key, it.value());
            }
        } else if (j.is_string()) {
            // Add string value
            this->AddIdentifier(prefix, j.get<std::string>());
        } else if (j.is_number_integer()) {
            // Convert integer to string
            this->AddIdentifier(prefix, std::to_string(j.get<int>()));
        } else if (j.is_number_float()) {
            // Convert float to string
            this->AddIdentifier(prefix, std::to_string(j.get<double>()));
        } else if (j.is_boolean()) {
            // Convert boolean to string
            this->AddIdentifier(prefix, j.get<bool>() ? "true" : "false");
        } else if (j.is_null()) {
            // Handle null as empty string
            this->AddIdentifier(prefix, "");
        }
        // Note: JSON arrays are intentionally not handled by this implementation.
        // If an array is encountered, it is silently ignored and no identifier is added.
    };

    flatten(identifier, var);
}

void ExprtkEvaluator::LoadFunctions() {
    AddFunction("keyMatch", ExprtkFunctionFactory::GetExprtkFunction(ExprtkFunctionType::KeyMatch, 2));
    AddFunction("keyMatch2", ExprtkFunctionFactory::GetExprtkFunction(ExprtkFunctionType::KeyMatch2, 2));
    AddFunction("keyMatch3", ExprtkFunctionFactory::GetExprtkFunction(ExprtkFunctionType::KeyMatch3, 2));
    AddFunction("keyMatch4", ExprtkFunctionFactory::GetExprtkFunction(ExprtkFunctionType::KeyMatch4, 2));
    AddFunction("regexMatch", ExprtkFunctionFactory::GetExprtkFunction(ExprtkFunctionType::RegexMatch, 2));
    AddFunction("ipMatch", ExprtkFunctionFactory::GetExprtkFunction(ExprtkFunctionType::IpMatch, 2));
    AddFunction("keyGet", ExprtkFunctionFactory::GetExprtkFunction(ExprtkFunctionType::KeyGet, 2));
    AddFunction("keyGet2", ExprtkFunctionFactory::GetExprtkFunction(ExprtkFunctionType::KeyGet2, 3));
    AddFunction("keyGet3", ExprtkFunctionFactory::GetExprtkFunction(ExprtkFunctionType::KeyGet3, 3));
}

void ExprtkEvaluator::LoadGFunction(std::shared_ptr<RoleManager> rm, const std::string& name, int narg) {
    auto func = ExprtkFunctionFactory::GetExprtkFunction(ExprtkFunctionType::Gfunction, narg, rm);
    this->AddFunction(name, func);
}

void ExprtkEvaluator::ProcessFunctions(const std::string& expression) {
}

Type ExprtkEvaluator::CheckType() {
    if (parser.error_count() != 0) {
        throw parser.error();
    }
    if (expression.value() == float(0) || expression.value() == float(1)) {
        return Type::Bool;
    } else {
        return Type::Float;
    }
}

bool ExprtkEvaluator::GetBoolean() {
    return bool(this->expression);
}

float ExprtkEvaluator::GetFloat() {
    return expression.value();
}

std::string ExprtkEvaluator::GetString() {
    const numerical_type result = expression.value();
    return key_get_result;
}

void ExprtkEvaluator::Clean(AssertionMap& section, bool after_enforce) {
    if (!after_enforce) {
        return;
    }

    this->symbol_table.clear();
    this->glbl_variable_symbol_table.clear();
    this->expression_string_ = "";
    this->Functions.clear();
    this->identifiers_.clear();
}

void ExprtkEvaluator::AddFunction(const std::string& func_name, std::shared_ptr<exprtk_func_t> func) {
    if (func != nullptr) {
        this->Functions.push_back(func);
        symbol_table.add_function(func_name, *func);
    }
}

void ExprtkEvaluator::PrintSymbol() {
    std::vector<std::string> var_list;
    symbol_table.get_stringvar_list(var_list);

    printf("Current symboltable: \n");
    for (auto& var : var_list) {
        printf(" %s: %s\n", var.c_str(), symbol_table.get_stringvar(var)->ref().c_str());
    }
    printf("Current error: %s\n", parser.error().c_str());
    // printf("Current exprsio string: %s\n", parser.current_token);
    printf("Current value: %d\n", bool(this->expression));
}

std::unordered_map<std::string, std::string> ExprtkEvaluator::requestValues() const {
    std::vector<std::string> var_list;
    symbol_table.get_stringvar_list(var_list);
    std::unordered_map<std::string, std::string> result;
    for (const auto& e : var_list) {
        if (e[0] == 'r') {
            auto token = e.substr(2, e.size() - 2);
            auto value = symbol_table.get_stringvar("r." + token)->ref().c_str();
            result.emplace(token, value);
        }
    }
    return result;
}

void ExprtkEvaluator::AddIdentifier(const std::string& identifier, const std::string& var) {
    if (!symbol_table.symbol_exists(identifier)) {
        identifiers_[identifier] = std::make_unique<std::string>("");
        this->symbol_table.add_stringvar(identifier, *identifiers_[identifier]);
    }
    symbol_table.get_stringvar(identifier)->ref() = var;
}

} // namespace casbin