very basic query language

1 files changed, 85 insertions, 323 deletions

diff --git a/src/main.rs b/src/main.rs
index 5e86c89..a09f4ef 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,356 +1,118 @@
-use std::{path::{Path, PathBuf}, fs, str::FromStr, sync::{Arc, Mutex}};
-use anyhow::{Result, Context, anyhow};
-use itertools::Itertools;
-use rnix::{SyntaxKind, ast::{AttrpathValue, AttrSet, HasEntry, Entry::*}, SyntaxNode};
+use std::{path::PathBuf, fs, process::exit};
 use rowan::{ast::AstNode, TextSize};
-use serde::Deserialize;
-use threadpool::ThreadPool;
+use clap::{arg, command, value_parser};
 
-struct StatusReportData {
-    files: usize,
-    items: usize,
-    total_files: usize,
-    total_items: usize,
-    changed_items: usize,
-    last_file: String,
-    last_item: String,
-}
-
-impl StatusReportData {
-    fn print(&self, clear: bool) {
-        if clear {
-            print!("\x1b[1F\x1b[2K\x1b[1F\x1b[2K");
-        }
-        println!("{}/{} files ({})", self.files, self.total_files, self.last_file);
-        println!("{}/{} ({}) items ({})", self.items, self.total_items,
-                 self.changed_items, self.last_item);
-    }
-}
-
-struct StatusReport(Mutex<StatusReportData>);
-
-impl StatusReport {
-    fn new(total_files: usize, total_items: usize) -> Self {
-        Self(Mutex::new(StatusReportData {
-            files: 0,
-            items: 0,
-            total_files,
-            total_items,
-            changed_items: 0,
-            last_file: "".to_string(),
-            last_item: "".to_string(),
-        }))
-    }
-
-    fn enter_file(&self, f: &str) {
-        let mut m = self.0.lock().unwrap();
-        m.files += 1;
-        m.last_file = f.to_string();
-        m.print(m.files > 1 || m.items >= 1);
-    }
-
-    fn enter_item(&self, i: String) {
-        let mut m = self.0.lock().unwrap();
-        m.items += 1;
-        m.last_item = i;
-        m.print(m.files >= 1 || m.items > 1);
-    }
-
-    fn update_item(&self, i: String) {
-        let mut m = self.0.lock().unwrap();
-        m.last_item = i;
-        m.print(true);
-    }
-
-    fn changed_item(&self) {
-        let mut m = self.0.lock().unwrap();
-        m.changed_items += 1;
-        m.print(true);
-    }
-
-    fn skip_items(&self, i: usize) {
-        let mut m = self.0.lock().unwrap();
-        m.items += i;
-        m.print(m.files >= 1 || m.items >= 1);
-    }
-}
-
-struct StatusPart<'a>(&'a StatusReport, usize);
-
-impl<'a> StatusPart<'a> {
-    fn enter_item(&mut self, i: String) {
-        self.0.enter_item(i);
-        self.1 -= 1;
-    }
-
-    fn update_item(&mut self, i: String) {
-        self.0.update_item(i);
-    }
-
-    fn changed_item(&mut self) {
-        self.0.changed_item();
-    }
-}
-
-impl<'a> Drop for StatusPart<'a> {
-    fn drop(&mut self) {
-        self.0.skip_items(self.1);
-    }
-}
-
-
-
-fn textsize_at_line(s: &str, line: usize) -> TextSize {
-    s
-        .split('\n')
-        .map(|l|
-            TextSize::of(l) + TextSize::new(1)
-        )
-        .take(line-1)
-        .sum()
-}
-
-
-fn dig_to_kind(kind: SyntaxKind, node: &SyntaxNode) -> Option<SyntaxNode> {
-    if node.kind() == kind {
-        return Some(node.clone());
-    }
-
-    node.descendants()
-        .filter(|node| node.kind() == kind)
-        .next()
-}
-
-fn add_to_meta_block(rough_pos: SyntaxNode, content: &str, main_program: &str, file: &Path, line: usize) -> Result<(String, usize)> {
-    let meta_node = dig_to_kind(SyntaxKind::NODE_ATTR_SET, &rough_pos).unwrap();
-    let meta_set = AttrSet::cast(meta_node.clone()).unwrap();
+#[allow(dead_code)]
+mod queries;
+#[allow(dead_code)]
+mod status_reporter;
+mod batchmode;
+#[allow(dead_code)]
+mod util;
 
-    let description_entry = meta_set.entries()
-         .filter(|entry| {
-             match &entry {
-                 Inherit(it) => it.attrs().any(|c| c.to_string() == "description"),
-                 AttrpathValue(it) => it.attrpath().unwrap().to_string() == "description",
-             }
-         })
-         .exactly_one().ok()
-         .with_context(|| format!("meta node has no description attribute in {:?} at {}", file, line))?;
-    let description = description_entry.syntax();
 
-    let pos = description.text_range();
-    let indent = content[..pos.start().into()].chars().rev().position(|c| c == '\n').unwrap();
+fn parse_nexp(path: &PathBuf) -> anyhow::Result<(String, rnix::Root)> {
+    let content = fs::read_to_string(path)?;
 
-    let patch = String::new()
-        + "\n"
-        + &" ".repeat(indent)
-        + "mainProgram = \"" + main_program + "\";";
-
-    Ok((patch, pos.end().into()))
-}
-
-fn edit_one(file: &Path, line: usize, main_program: &str, p: &StatusReport) -> Result<String> {
-    let mut content = fs::read_to_string(file)?;
-    let searchpos = textsize_at_line(&content, line);
-
-    p.update_item(format!("doing {:?}", file));
     let parse = rnix::Root::parse(&content);
     if !parse.errors().is_empty() {
         anyhow::bail!("error: {:?}", parse.errors());
     }
-    let tree = parse.tree();
-
-    let pos_node = tree.syntax().descendants()
-        .filter(|node| {
-            if node.kind() == SyntaxKind::NODE_ATTRPATH_VALUE {
-                let value = AttrpathValue::cast(node.clone()).unwrap();
-                node.text_range().contains(searchpos) && value.attrpath().unwrap().to_string() == "meta"
-            } else { false }
-        })
-        .exactly_one().ok();
-
-    // do we have a meta attrset already?
-    let (patch, insert_offset) = match pos_node {
-        None => {
-            let version_node = tree
-                .syntax()
-                .descendants()
-                .filter(|node| {
-                    if node.kind() == SyntaxKind::NODE_ATTRPATH_VALUE {
-                        let value = AttrpathValue::cast(node.clone()).unwrap();
-                        let name =  value.attrpath().unwrap().to_string();
-                        node.text_range().contains(searchpos + TextSize::new(5))
-                            && (name == "version" || name == "pname" || name == "name")
-                    } else { false }
-                })
-                .exactly_one().ok()
-                .with_context(|| format!("neither meta nor version node found for {:?} at {}", file, line))?;
+    Ok((content, parse.tree()))
+}
 
-            let attrset = version_node.parent().unwrap();
-            if attrset.kind() != SyntaxKind::NODE_ATTR_SET {
-                anyhow::bail!("name not in an attrset in {:?} at {}", file, line)
-            }
+fn main() {
 
-            // does a meta block already exist?
-            let maybe_meta_block = attrset
-                .descendants()
-                .filter(|node| {
-                    if node.kind() == SyntaxKind::NODE_ATTRPATH_VALUE {
-                        let value = AttrpathValue::cast(node.clone()).unwrap();
-                        let name =  value.attrpath().unwrap().to_string();
-                        name == "meta"
-                    } else { false }
-                })
-                .exactly_one();
+    let matches = command!()
+        .arg(arg!(--batchmode "run in batch mode")
+             .required(false)
+        )
+        .arg(arg!([query] "query to run")
+             .required(true))
+        .arg(arg!([file] "file to operate on")
+            .required(true)
+             .value_parser(value_parser!(PathBuf))
+        )
+        .arg(arg!(--edit <operation> "what to do")
+        .required(false))
+        .get_matches();
+
+    let query_string = matches.get_one::<String>("query").unwrap();
+    let files = matches.get_one::<PathBuf>("file").unwrap();
+
+    let parse = queries::parse(query_string);
+    if parse.errors.len() != 0 {
+        eprintln!(
+            "syntax {}: \n  {}",
+            if parse.errors.len() == 1 { "error" } else { "errors" },
+            parse.errors.join("  \n")
+        );
+        exit(1);
+    }
+
+    let (content, nexp) = match parse_nexp(files) {
+        Err(e) => {
+            eprintln!("could not parse file: {e}");
+            exit(2);
+        },
+        Ok(exp) => exp
+    };
 
-            if let Ok(meta) = maybe_meta_block {
-                add_to_meta_block(meta.clone(), &content, main_program, file, line)?
-            } else {
-                let before_attrset_end = Into::<usize>::into(attrset.text_range().end())
-                    - 1
-                    - content[..attrset.text_range().end().into()]
-                    .chars().rev().position(|c| c == '\n').unwrap();
+    // println!("{nexp:#?}");
 
-                let indent = content[..version_node.text_range().start().into()]
-                    .chars().rev().position(|c| c == '\n').unwrap();
+    let results = parse.apply(&content, nexp.syntax().clone()).unwrap();
 
-                // some language specific build systems don't use meta as its own attrset
-                // there's no good way to recognise these, but this seems to work fine
-                let weird_nonstandard_meta = attrset
-                    .descendants()
-                    .any(|node| {
-                        if node.kind() == SyntaxKind::NODE_ATTRPATH_VALUE {
-                            let value = AttrpathValue::cast(node.clone()).unwrap();
-                            let name =  value.attrpath().unwrap().to_string();
-                            name == "description" || name == "homepage" || name == "license"
-                        } else { false }
-                    });
-                let patch = String::new()
-                    + "\n"
-                    + &" ".repeat(indent)
-                    + if weird_nonstandard_meta { "mainProgram = \"" } else { "meta.mainProgram = \"" }
-                    + main_program + "\";";
 
-                (patch, before_attrset_end)
+    if let Some(op) = matches.get_one::<String>("edit") {
+        match &op[..] {
+            "remove" => {
+                let new = remove_nodes(content, &results);
+                println!("{new}");
             }
-        },
-        Some(pos) => {
-            add_to_meta_block(pos.clone(), &content, main_program, file, line)?
+            _ => ()
         }
-    };
-
-
-    content = String::new()
-        + &content[..insert_offset]
-        + &patch
-        + &content[insert_offset..];
-
-    p.changed_item();
-    Ok(content)
-}
+    } else {
+        for result in &results {
+            println!("{result}");
+        }
+    }
 
 
-#[derive(Deserialize, Clone)]
-struct TrivialProgram {
-    pos: Option<String>,
-    name: String
 }
 
-fn main() {
-
-    let raw_inputs = fs::read_to_string("trivials.json").unwrap();
-    let inputs: Vec<TrivialProgram> = serde_json::de::from_str::<Vec<_>>(&raw_inputs).unwrap();
-        // .into_iter().take(200).collect();
+fn remove_nodes(content: String, results: &Vec<rnix::SyntaxNode>) -> String {
 
+    assert!(results.len() == 1);
 
-    // TODO: group edits in the same file
-    let pool = ThreadPool::new(16);
+    let span = &results[0];
 
-    let mut tasks: Vec<(TrivialProgram, PathBuf, usize)> = inputs.into_iter()
-        .filter_map(|i| {
-            if i.pos.is_none() {
-                println!("no position for name {}", i.name);
-                None
+    let (before, after) = match (span.prev_sibling_or_token(), span.next_sibling_or_token()) {
+        (Some(prev), Some(next))
+            if prev.kind() == rnix::SyntaxKind::TOKEN_WHITESPACE
+              && next.kind() == rnix::SyntaxKind::TOKEN_WHITESPACE
+        => {
+            if prev.to_string().lines().count() < next.to_string().lines().count() {
+                (prev.text_range().len(), TextSize::new(0))
             } else {
-                let pos = i.pos.as_ref().unwrap();
-                let (filename, line) = {
-                    let l = pos.split(':').collect::<Vec<_>>();
-                    assert!(l.len() == 2);
-
-                    (PathBuf::from_str(l[0]).unwrap(), l[1].parse().unwrap())
-                };
-                Some((i, filename, line))
-            }
-        })
-        .collect();
-
-    tasks.sort_by_key(|(_ ,filename, _)| filename.clone());
-
-    let grouped_tasks: Vec<(TrivialProgram, PathBuf, Vec<(usize, String)>)> =
-        tasks.into_iter()
-             .map(|(i, f, l)| (i.clone(), f, vec![(l, i.name)]))
-             .coalesce(|(i1, f1, l1), (i2, f2, l2)| {
-                 if f1 == f2 {
-                     if l1 == l2 && i1.name == i2.name {
-                         Ok((i1, f1, l1))
-                     } else {
-                         Ok((i1, f1, l1.into_iter().chain(l2.into_iter()).collect()))
-                     }
-                 } else {
-                     Err(((i1,f1,l1),(i2,f2,l2)))
-                 }
-             }).collect();
-
-    let results = Arc::new(Mutex::new(vec![]));
-    let printer = Arc::new(StatusReport::new(grouped_tasks.len(), grouped_tasks.len()));
-
-    for (i, filename, sites) in grouped_tasks {
-        pool.execute({
-            let results = Arc::clone(&results);
-            let printer = Arc::clone(&printer);
-
-            move || {
-                let pos = i.pos.unwrap();
-                printer.enter_file(&pos);
-                if sites.len() == 1 {
-                    let result = edit_one(&filename, sites[0].0, &sites[0].1, &printer)
-                        .map(|ok| (filename, ok));
-                    results.lock().unwrap().push(result);
-                } else {
-                    results.lock().unwrap().push(Err(anyhow!("skipped {:?} as it has multiple edits", filename)));
-                }
+                (TextSize::new(0), next.text_range().len())
             }
-        });
-    }
-
-    pool.join();
-
-    println!("\n\nSummary:");
-    let mut c_errors = 0;
-    let mut c_total = 0;
-    for r in results.lock().unwrap().iter() {
-        match r {
-            Err(e) => {
-                println!(" {}", e);
-                c_errors += 1;
-            },
-            _ => ()
         }
-        c_total += 1;
-    }
+        _ => (TextSize::default(),TextSize::default())
+    };
+
+    String::new()
+        + &content[..Into::<usize>::into(span.text_range().start() - before) - previous_indentation(span).unwrap_or(0)]
+        + &content[(span.text_range().end() + after).into()..]
+}
 
-    println!("\n  ({c_total} sites total, {c_errors} errors, generated {} edits)", c_total - c_errors);
 
-    let edits: Vec<_> = Arc::into_inner(results).unwrap().into_inner().unwrap()
-        .into_iter()
-        .filter_map(|r| r.ok())
-        .collect();
 
-    // check we didn't miss any duplicate edits
-    let duplicates = edits.iter().duplicates_by(|(filename, _)| filename).count();
-    println!("{duplicates} edits were not the only one in their file");
+fn previous_indentation(node: &rnix::SyntaxNode) -> Option<usize> {
+    let whitespace_token = node.prev_sibling_or_token()?;
 
-    println!("applying changes ...");
-    for (filename, content) in edits {
-        fs::write(&filename, content.as_bytes()).unwrap();
-        // println!("{}", content);
+    if whitespace_token.kind() == rnix::SyntaxKind::TOKEN_WHITESPACE {
+        Some(whitespace_token.to_string().lines().last().unwrap().len())
+    } else {
+        None
     }
 }