Proposal: Adopt .fpp.json as the Standard Extension for Feel++ JSON Files

[prudhomm]

Background

Feel++ uses JSON files to define models, boundary conditions, materials, and post-processing configurations.
To improve consistency, tooling support, and schema validation, we propose adopting a standardized file extension.

Proposed Change

We suggest using .fpp.json as the standard extension for Feel++ JSON files.

Reasons for Choosing .fpp.json

1. Distinct Feel++ Identity

   • .json alone is too generic.
   • .fpp.json clearly indicates a Feel++-specific JSON file.

2. Schema Validation Support

   • Editors like VSCode allow automatic schema validation based on file extensions.
   • Easier to apply a JSON Schema for Feel++ in IDEs.

3. Better Tooling & Automation

   • CI/CD pipelines, JSON validators, and Feel++ tools can quickly identify and process Feel++ configurations.
   • Prevents accidental mixing with general-purpose JSON files.

Alternatives Considered

• .feel.json: Explicit but longer.
• .toolbox.json: Too specific to the Feel++ toolboxes.
• .feelpp.json: Explicit but redundant.

We find .fpp.json to be the best balance between clarity, brevity, and compatibility.

Questions for Discussion

1. Do you agree with .fpp.json as the standard extension?
2. Are there any other concerns or suggestions?
3. What would be the best way to transition existing files (e.g., automatic renaming, documentation updates)?

Looking forward to your feedback!

[prudhomm]

I would also favor using .fpp.json over alternatives like .fson or .fon for several reasons:

• Clarity and Familiarity: The compound extension clearly indicates a Feel++ JSON file while leveraging the well-known .json format. This transparency helps users quickly identify the file’s purpose.
• Tooling and Schema Validation: Editors and JSON validators are already set up to handle .json files. Using .fpp.json allows us to associate a specific JSON Schema without additional configuration, whereas custom extensions like .fson or .fon might require extra setup.
• Consistency: Maintaining a compound extension ensures that we stay consistent with our naming conventions. Although it requires a little extra handling in C++ (e.g., checking for the full suffix), a small helper function can easily address that.

While .fson or .fon might simplify certain filesystem operations, the benefits of clarity, schema validation support, and overall tooling integration make .fpp.json the preferred choice I think.

Here are two possible helper functions : one manipulating strings, the other using std::filesystem.

#include <iostream>
#include <string>
#include <filesystem>

bool hasCompoundExtension(const std::string & filename, const std::string & compound_ext)
{
    if (filename.size() < compound_ext.size())
    {
        return false;
    }

    return (filename.compare(filename.size() - compound_ext.size(), compound_ext.size(), compound_ext) == 0);
}

bool hasCompoundExtensionFS(const std::filesystem::path & filePath, const std::string & firstExt, const std::string & secondExt)
{
    // Check that the final extension matches the second extension (e.g., ".json")
    if (filePath.extension() != secondExt)
    {
        return false;
    }

    // Get the stem (the filename without the final extension)
    std::filesystem::path stem = filePath.stem();

    // Check if the stem has an extension matching the first extension (e.g., ".fpp")
    return (stem.extension() == firstExt);
}

int main()
{
    std::string file1 = "config.fpp.json";
    std::string file2 = "settings.json";
    std::string file3 = "data.fpp.json.bak";

    std::cout << file1 << " is " 
              << (hasCompoundExtension(file1, ".fpp.json") ? "" : "not ") 
              << "a file with compound extension .fpp.json\n";

    std::cout << file2 << " is " 
              << (hasCompoundExtension(file2, ".fpp.json") ? "" : "not ") 
              << "a file with compound extension .fpp.json\n";

    std::cout << file3 << " is " 
              << (hasCompoundExtension(file3, ".fpp.json") ? "" : "not ") 
              << "a file with compound extension .fpp.json\n";



    std::cout << file1 << " is " 
              << (hasCompoundExtensionFS(file1, ".fpp", ".json") ? "" : "not ") 
              << "a file with compound extension .fpp.json\n";

    std::cout << file2 << " is " 
              << (hasCompoundExtensionFS(file2, ".fpp", ".json") ? "" : "not ") 
              << "a file with compound extension .fpp.json\n";

    std::cout << file3 << " is " 
              << (hasCompoundExtensionFS(file3, ".fpp", ".json") ? "" : "not ") 
              << "a file with compound extension .fpp.json\n";
    return 0;
}

here is the output (I added a test_fppjson)

> ./feelpp_test_fppjson 
config.fpp.json is a file with compound extension .fpp.json
settings.json is not a file with compound extension .fpp.json
data.fpp.json.bak is not a file with compound extension .fpp.json
config.fpp.json is a file with compound extension .fpp.json
settings.json is not a file with compound extension .fpp.json
data.fpp.json.bak is not a file with compound extension .fpp.json

@vincentchabannes what do you think ?