flakegen.cpp

#include <string>
#include <format>
#include <fstream>
#include <filesystem>
#include <ftxui/component/app.hpp>
#include <ftxui/component/component.hpp>
#include <ftxui/component/component_base.hpp>
#include <ftxui/dom/elements.hpp>

const std::unordered_map<std::string, std::string> lang_map = {
  {"c", "clang\ngnumake\nclang-tools\nbear\npkg-config\n"},
  {"cpp", "clang\ncmake\nclang-tools\nbear\npkg-config\n"},
  {"rust", "rustc\nrustfmt\nrust-analyzer\ncargo\nclippy\n"},
  {"zig", "zig\nzls\n"},
  {"js", "nodejs\n"}
};

std::string flake = "{{\n"
  "\tdescription = \"{} devshell\";\n"
  "\tinputs = {{\n"
  "\t\tnixpkgs.url = \"nixpkgs/nixos-{}\";\n"
  "{}"
  "\t}};\n"
  "\toutputs = {{ self, nixpkgs, {} }}:\n"
  "\tlet\n"
  "\t\tsystem = \"{}\";\n"
  "\t\tpkgs = import nixpkgs {{ inherit system; }};\n"
  "{}"
  "\tin\n"
  "\t{{\n"
  "\t\tdevShell.${{system}}.default = pkgs.mkShell {}{{\n"
  "{}"
  "\t\t\tbuildInputs= with pkgs; [\n{}\n\t\t\t];\n"
  "{}"
  "\t\t}};\n"
  "\t}};\n"
  "}}";

std::vector<std::string> split(
    std::string const& str,
    std::string const& delim,
    std::size_t times = INT_MAX
    );
std::string gen_inputs (std::string name, std::string url);
void usage (std::string program);

using namespace ftxui;
Component LabeledInput(std::string label_text, Component input_comp);

int main()
{
  namespace fs = std::filesystem;
  App screen = App::TerminalOutput();
  std::vector<std::string> tab_values{
      "Setup",
      "Inputs",
      "Packages",
      "Shell Hook",
      // "Variables and Overrides",
      "Finish"
  };
  int tab_selected = 0;
  auto tab_toggle = Toggle(&tab_values, &tab_selected);

  std::string devshell_name = "";
  std::string dir = ".";
  std::string system = "x86_64-linux";
  std::string vnixos = "unstable";
  std::string language = "";
  std::vector<std::string> nix_inputs;
  ftxui::Box vbox_size;
  std::vector<std::string> shellHook {};
  std::string pkgs = "", build_inputs = "", native_build_inputs = "";
  std::function<void ()> onClick_generate;
  std::vector<std::string> status_messages {};

  Component i_devshell = Input(&devshell_name, "");
  Component i_dir = Input(&dir, " ./ ");
  Component i_system = Input(&system, " x86_64-linux ");
  Component i_vnix = Input(&vnixos, " unstable ");
  Component i_lang = Input(&language, "");

  std::string current_nix_input = "";
  Component i_nix_input = Input(&current_nix_input, "Add a nix input (i.e. name=github:user/repo)...");
  Component i_nix_input_logic = CatchEvent(i_nix_input, [&](Event event) {
      if (event == Event::Return)
      {
        if (!current_nix_input.empty())
        {
          nix_inputs.push_back(current_nix_input);
          current_nix_input.clear();
        }
        return true;
      }
      return false;
  });

  std::string current_shellHook_input= "";
  Component i_shellhook = Input(&current_shellHook_input, "");
  Component i_shellhook_logic = CatchEvent(i_shellhook, [&](Event event) {
      if (event == Event::Return)
      {
        if (!current_shellHook_input.empty())
        {
          shellHook.emplace_back(current_shellHook_input);
          current_shellHook_input.clear();
        }
        return true;
      }
      return false;
  });

  Component i_pkgs = Input(&pkgs, "");
  Component i_buildinputs = Input(&build_inputs, "");
  Component i_nbuildinputs = Input(&native_build_inputs, "");

  onClick_generate = [&] ()
  {
    std::stringstream flake_inputs {};
    std::stringstream flake_outputs {};
    std::stringstream packages {};
    for (std::string& in: nix_inputs)
    {
      std::vector<std::string> splits = split(in, "=");
      if (splits.size() != 2)
      {
        status_messages.emplace_back("[ERROR] Invalid Nix Input!");
        tab_selected = 1;
        return;
      }
      flake_inputs << gen_inputs(splits.front(), splits.back());
      flake_outputs << splits.front() + ", ";
      packages << "\t\t\t\t" + splits.front() + ".packages.${system}." + splits.front() + "\n";
    }
    flake_outputs << "...";

    std::string _nbuildInputs = "";
    if (!native_build_inputs.empty())
    {
      _nbuildInputs = "\t\t\tnativeBuildInputs = with pkgs; [\n";
      std::vector<std::string> nbI = split(native_build_inputs, " ");
      for (std::string pkg : nbI)
      {
        _nbuildInputs += "\t\t\t\t" + pkg + "\n";
      }
      _nbuildInputs += "\t\t\t];\n";
    }

    std::string _buildInputs = "";
    if (!build_inputs.empty())
    {
      if (!language.empty() && lang_map.contains(language))
      {
        std::vector<std::string> lang_pkgs = split(lang_map.at(language), "\n");
        for (std::string pkg : lang_pkgs)
        {
          _buildInputs += "\t\t\t\t" + pkg + "\n";
        }
      }
      std::vector<std::string> bI = split(build_inputs, " ");
      for (std::string pkg: bI)
      {
        _buildInputs += "\t\t\t\t" + pkg + "\n";
      }
      std::vector<std::string> ipkgs = split(pkgs, " ");
      for (std::string pkg: ipkgs)
      {
        _buildInputs += "\t\t\t\t" + pkg + "\n";
      }
      _buildInputs += packages.str();
    }

    std::stringstream shell_hooks {};
    shell_hooks << "";
    if (!shellHook.empty())
    {
      shell_hooks << "\t\t\tshellHook = ''\n";
      for (std::string& sh: shellHook)
      {
        shell_hooks << "\t\t\t\t" + sh + "\n";
      }
      shell_hooks << "\t\t\t'';\n";
    }

    fs::path path {fs::current_path()};
    if (!dir.empty())
    {
      if (fs::exists(dir)) path /= dir;
      else
      {
        status_messages.emplace_back("[ERROR] Path doesn't exist! Please provide a valid path!");
        tab_selected = 0;
        return;
      }
    }

    std::string flake_inputs_str = flake_inputs.str();
    std::string flake_outputs_str = flake_outputs.str();
    std::string shell_hooks_str = shell_hooks.str();
    std::string variables = "", overrides = ""; //INFO: not yet impl'd

    try
    {
      std::ofstream nix_flake (path/"flake.nix");
      if (!nix_flake.is_open())
      {
        throw std::runtime_error("File is not open!");
      }
      nix_flake << std::vformat(
          flake,
          std::make_format_args(
            devshell_name, vnixos, flake_inputs_str, flake_outputs_str, system,
            variables, overrides, _nbuildInputs, _buildInputs, shell_hooks_str
            )
          );
      nix_flake.close();
      status_messages.emplace_back("[INFO] Path to generated flake: "+ path.string());
      screen.Exit();
    } catch (std::exception& e)
    {
      status_messages.emplace_back(std::format("[ERROR] {}", e.what()));
    }
  };

  Component setup_tab = Container::Vertical({
      LabeledInput("DevShell Name: ", i_devshell),
      LabeledInput("Output Directory: ",i_dir),
      LabeledInput("System: ",i_system),
      LabeledInput("Nixpkgs Version: ",i_vnix),
      LabeledInput("Language: ",i_lang),
  });
  Component nix_input_tab = Renderer(i_nix_input_logic, [&] {
      Elements list_elements;
      for (const auto& in : nix_inputs)
      {
        list_elements.push_back(text("  • " + in) | color(Color::Blue));
      }

      return vbox({
          text(" Nix Flake Inputs ") | bold | center,
          separator(),
          vbox(std::move(list_elements)) | size(HEIGHT, LESS_THAN, 10) | reflect(vbox_size),
          filler(),
          separator(),
          hbox({ text(" Add Input: "), i_nix_input_logic->Render() | flex }),
          });
      });

  Component packages_tab = Container::Vertical({
        LabeledInput("Native Build Inputs: ", i_nbuildinputs),
        LabeledInput("Build Inputs: ", i_buildinputs),
        LabeledInput("Packages: ", i_pkgs),
    });

  Component shellHook_tab = Renderer(i_shellhook_logic, [&] {
      Elements list_elements;
      for (const auto& hook : shellHook)
      {
        list_elements.push_back(text("  • " + hook) | color(Color::Blue));
      }

      return vbox({
          text(" Nix Flake Shell Hook") | bold | center,
          separator(),
          vbox(std::move(list_elements)) | size(HEIGHT, LESS_THAN, 10) | reflect(vbox_size),
          filler(),
          separator(),
          hbox({ i_shellhook_logic->Render() | flex }),
          });
      });

  Component btn_generate = Button(" Generate Flake ", onClick_generate, ButtonOption::Animated());
  Component finish_container = Container::Vertical({btn_generate});

  Component finish_tab = Renderer(finish_container, [&] {
      Elements list_messages;
      for (const std::string& message : status_messages)
      {
        Color msg_color = message.find("[ERROR]") != std::string::npos ? Color::Red : Color::Blue;
        list_messages.push_back(text("  • " + message) | color(msg_color));
      }

      return vbox({
          text(" Status Messages ") | bold | center,
          separator(),
          vbox(std::move(list_messages)) | size(HEIGHT, LESS_THAN, 10) | reflect(vbox_size),
          filler(),
          separator(),
          finish_container->Render()
          });
      });

  // Tabs
  Component tab_container = Container::Tab(
      {
          setup_tab,
          nix_input_tab,
          packages_tab,
          shellHook_tab,
          finish_tab
      },
      &tab_selected);

  Component container = Container::Vertical({
      tab_toggle,
      tab_container,
  });

  Component tab_renderer = Renderer(container, [&] {
    return vbox({
               tab_toggle->Render(),
               separator(),
               tab_container->Render(),
           }) |
           border;
  });

  screen.Loop(tab_renderer);
}

std::string gen_inputs (std::string name, std::string url)
{
  std::string final_str {};
  final_str.append("\t\t" + name + ".url = \"{}\";\n");
  if (url.contains(':'))
  {
    final_str = std::vformat(final_str, std::make_format_args(url));
  }else
  {
    std::string full_url = "github:" + url;
    final_str = std::vformat(final_str, std::make_format_args(full_url));
  }
  return final_str;
}

std::vector<std::string> split (
    std::string const& str,
    std::string const& delim,
    std::size_t times
    )
{
  std::vector<std::string> vtok;
  std::size_t start {0};
  auto end = str.find(delim);

  while ((times-- > 0) && (end != std::string::npos))
  {
    vtok.emplace_back(str.substr(start, end - start));
    start = end + delim.length();
    end = str.find(delim, start);
  }
  vtok.emplace_back(str.substr(start));

  return vtok;
}

Component LabeledInput(std::string label_text, Component input_comp)
{
    return Renderer(input_comp, [label_text, input_comp] {
        return hbox({
            text(label_text) | size(WIDTH, EQUAL, 20) | vcenter,
            input_comp->Render()
        });
    });
}