Feat/node insertion

Cargo.toml

@@ -13,6 +13,8 @@ rowan = "0.12.6"
 parse-display = "0.4.1"
 anyhow = "1.0"
 rust-nix-templater = { git = "https://github.com/yusdacra/rust-nix-templater.git", branch = "master" }
+either = "1.6.1"
+nixpkgs-fmt = "1.1.0"
 
 [package.metadata.nix]
 app = true

README.md

@@ -34,23 +34,12 @@ their package and set of dependencies.
 
 The idea is to have the user specify the type of dependencies,
 flake inputs and outputs, and type of the package with `skim`,
-then to output a flake. This flake is then validated with `rnix`.
+then to output a flake. This flake is then validated with `rnix`
+formatted with `nixpkgs-fmt`, then written to a file.
 
 If the user wants to modify an existing flake to add or remove
 dependencies, this will also be possible. The flake shall be
-parsed in with `rnix`, and the user will be able to modify it.
-
-As of now, basically none of the features exist. I've only
-got the proof of concept working: skim can be used for a cli
-and rnix can be used to modify the AST.
-
-Further down the line, I'd like to make this even more interactive.
-This will involve querying github, crates.io, pypy, nixpkgs and more for packages,
-then piping them into skim for selection based on language.
-
-The hope is to also provide automatic support for pre-existing
-nix expression generators such as node2nix, poetry2nix, cabal2nix,
-and naersk.
+parsed with `rnix`, and the user will be able to modify it.
 
 # Dependencies #
 
@@ -60,11 +49,11 @@ and the `skim` fuzzy finder for the cli.
 # Roadmap #
 
 - [x] Proof of concept
-- [ ] Flake Input management
-  - [ ] Add inputs
+- [x] Flake Input management
+  - [x] Add inputs
   - [ ] Remove inputs
   - [ ] Change inputs
-  - [ ] Query github
+  - [ ] Query github into skim (this is hard...may not be feasible..)
 - [ ] BuildInput management
   - [ ] Query nixpkgs
   - [ ] Modify buildInputs

src/main.rs

@@ -1,9 +1,15 @@
 mod parser;
 mod user;
 
+use crate::parser::input_utils::SyntaxStructure;
 use anyhow::anyhow;
+use nixpkgs_fmt::reformat_node;
 use parser::file::{filename_to_node, write_to_node};
-use parser::utils::remove_input;
+use parser::input_utils::{merge_attr_sets, Input};
+use parser::utils::{get_node_idx, remove_input, search_for_attr, NixNode};
+use rowan::GreenNode;
+use rowan::NodeOrToken;
+use rowan::SyntaxNode;
 use user::*;
 
 struct ActionStack {
@@ -21,6 +27,12 @@ impl ActionStack {
         self.inner.push(action)
     }
 
+    fn push_seq(&mut self, actions: impl IntoIterator<Item = UserAction>) {
+        actions
+            .into_iter()
+            .for_each(|action| self.inner.push(action))
+    }
+
     fn pop(&mut self) -> UserAction {
         self.inner.pop().unwrap_or(Self::START_ACTION)
     }
@@ -64,49 +76,109 @@ fn main() {
             UserPrompt::Create => action_stack.push(UserAction::CreateNew),
             UserPrompt::Modify => action_stack.push(UserAction::ModifyExisting),
             UserPrompt::DeleteInput => action_stack.push(UserAction::RemoveInput),
-            UserPrompt::AddInput => action_stack.push(UserAction::AddInput),
+            UserPrompt::AddInput => action_stack.push_seq(vec![
+                UserAction::IntroParsed,
+                UserAction::ConfirmWrite,
+                UserAction::ConfirmInputCorrect,
+                UserAction::QueryInputName,
+                UserAction::QueryInputUrl,
+                UserAction::IsInputFlake,
+            ]),
             UserPrompt::SelectLang(lang) => match lang {
                 Lang::Rust => action_stack.push(UserAction::Rust(user::rust::Action::Intro)),
                 lang => todo!("lang {}", lang),
             },
             UserPrompt::Rust(prompt) => {
                 prompt.process_prompt(&mut action_stack, &mut user_data);
             }
-            UserPrompt::Other(other) => {
-                match cur_action {
-                    UserAction::Rust(action) => {
-                        action
-                            .clone()
-                            .process_action(other, &mut action_stack, &mut user_data)
-                    }
-                    UserAction::ModifyExisting => {
-                        let filename = other.0.as_str();
-                        match filename_to_node(filename, &other) {
-                            Err(err_msg) => action_stack.push(UserAction::Error(err_msg)),
-                            Ok(root) => {
-                                user_data.filename = Some(filename.to_string());
-                                user_data.root = Some(root);
-                                action_stack.push(UserAction::IntroParsed);
-                            }
+            UserPrompt::Other(other) => match cur_action {
+                UserAction::Rust(action) => {
+                    action
+                        .clone()
+                        .process_action(other, &mut action_stack, &mut user_data)
+                }
+                UserAction::QueryInputUrl => {
+                    let mut i = user_data.new_input.unwrap_or_default();
+                    i.url = Some(SyntaxStructure::StringLiteral(other));
+                    user_data.new_input = Some(i);
+                    action_stack.pop();
+                }
+                UserAction::QueryInputName => {
+                    let mut i = user_data.new_input.unwrap_or_default();
+                    i.name = Some(SyntaxStructure::StringLiteral(other));
+                    user_data.new_input = Some(i);
+                    action_stack.pop();
+                }
+                UserAction::ModifyExisting => {
+                    let filename = other.0.as_str();
+                    match filename_to_node(filename, &other) {
+                        Err(err_msg) => action_stack.push(UserAction::Error(err_msg)),
+                        Ok(root) => {
+                            user_data.filename = Some(filename.to_string());
+                            user_data.root = Some(root);
+                            action_stack.push(UserAction::IntroParsed);
                         }
                     }
-                    UserAction::RemoveInput => {
-                        let inputs = user_data.inputs.as_ref().unwrap();
-                        let new_root = remove_input(
-                            user_data.root.as_ref().unwrap(),
-                            other.0.as_str(),
-                            Some(inputs),
-                        )
-                        .unwrap();
-                        user_data.new_root(new_root);
-                        write_to_node(&user_data);
-
-                        // TODO add in a "write to file" option at the end instead of writing after every modification
-                        action_stack.push(UserAction::IntroParsed);
+                }
+                UserAction::RemoveInput => {
+                    let inputs = user_data.inputs.as_ref().unwrap();
+                    let new_root = remove_input(
+                        user_data.root.as_ref().unwrap(),
+                        other.0.as_str(),
+                        Some(inputs),
+                    )
+                    .unwrap();
+                    user_data.new_root(new_root);
+                    action_stack.pop();
+                    action_stack.push(UserAction::IntroParsed);
+                }
+                _ => unimplemented!(),
+            },
+            UserPrompt::Bool(b) => match cur_action {
+                UserAction::IsInputFlake => {
+                    action_stack.pop();
+                    let mut i = user_data
+                        .new_input
+                        .as_ref()
+                        .and_then(|x: &Input| Some(x.clone()))
+                        .unwrap_or_default();
+                    i.is_flake = Some(SyntaxStructure::Bool(b));
+                    user_data.new_input = Some(i);
+                }
+                UserAction::ConfirmInputCorrect => {
+                    let root = user_data.root.as_ref().unwrap();
+                    let (inputs, _, _) = search_for_attr("inputs", 1, root, None)[0].clone();
+                    let new_input: GreenNode = user_data
+                        .new_input
+                        .as_ref()
+                        .and_then(|x| Some(x.clone()))
+                        .unwrap()
+                        .into();
+                    let augmented_input = merge_attr_sets(inputs.green().to_owned(), new_input);
+                    let idx = get_node_idx(&inputs).unwrap();
+                    let parent = inputs.parent().unwrap();
+                    let new_root = inputs
+                        .parent()
+                        .unwrap()
+                        .green()
+                        .to_owned()
+                        .replace_child(idx, NodeOrToken::Node(augmented_input));
+                    let mut new_root_wrapped: NixNode =
+                        SyntaxNode::new_root(parent.replace_with(new_root));
+                    while let Some(parent) = new_root_wrapped.parent() {
+                        new_root_wrapped = parent;
                     }
-                    _ => unimplemented!(),
+                    action_stack.pop();
+                    user_data.new_root(reformat_node(&new_root_wrapped))
                 }
-            }
+                UserAction::ConfirmWrite => {
+                    action_stack.pop();
+                    if b {
+                        write_to_node(&user_data)
+                    }
+                }
+                _ => unimplemented!("bool not implemented in this case {}", cur_action),
+            },
         }
     }
 }