Add support for R (#47)

Nice work! Thank you for the tests and scm comments.

Author: bnprks

Cargo.lock

@@ -39,6 +39,7 @@ tree-sitter-html = "<0.25.0"
 tree-sitter-javascript = "<0.25.0"
 tree-sitter-php = "<0.24.0"
 tree-sitter-python = "<0.25.0"
+tree-sitter-r = "1.1.0"
 tree-sitter-ruby = "0.23.1"
 tree-sitter-rust = "<0.25.0"
 tree-sitter-toml-ng = "<0.8.0"

Cargo.toml

@@ -15,6 +15,7 @@ tree-sitter-html.workspace = true
 tree-sitter-javascript.workspace = true
 tree-sitter-php.workspace = true
 tree-sitter-python.workspace = true
+tree-sitter-r.workspace = true
 tree-sitter-ruby.workspace = true
 tree-sitter-rust.workspace = true
 tree-sitter-toml-ng.workspace = true

crates/codebook/Cargo.toml

@@ -12,6 +12,7 @@ pub enum LanguageType {
     Javascript,
     Php,
     Python,
+    R,
     Ruby,
     Rust,
     TOML,
@@ -136,6 +137,13 @@ pub static LANGUAGE_SETTINGS: &[LanguageSetting] = &[
         query: include_str!("queries/php.scm"),
         extensions: &["php"],
     },
+    LanguageSetting {
+        type_: LanguageType::R,
+        ids: &["r"],
+        dictionary_ids: &["r"],
+        query: include_str!("queries/r.scm"),
+        extensions: &["r", "R"],
+    },
 ];
 
 #[derive(Debug)]
@@ -159,6 +167,7 @@ impl LanguageSetting {
             LanguageType::Javascript => Some(tree_sitter_javascript::LANGUAGE.into()),
             LanguageType::Php => Some(tree_sitter_php::LANGUAGE_PHP.into()),
             LanguageType::Python => Some(tree_sitter_python::LANGUAGE.into()),
+            LanguageType::R => Some(tree_sitter_r::LANGUAGE.into()),
             LanguageType::Ruby => Some(tree_sitter_ruby::LANGUAGE.into()),
             LanguageType::Rust => Some(tree_sitter_rust::LANGUAGE.into()),
             LanguageType::TOML => Some(tree_sitter_toml_ng::LANGUAGE.into()),

crates/codebook/src/queries.rs

@@ -0,0 +1,35 @@
+(comment) @comment
+(string) @string
+
+(parameter name: (identifier) @identifier)
+
+(binary_operator
+    lhs: (identifier) @identifier
+    operator: ["<-" "="])
+(binary_operator
+    operator: "->"
+    rhs: (identifier) @identifier)
+
+;---------------------------------------
+; Less clear-cut spell checking targets:
+;---------------------------------------
+
+; Functions with ... args sometimes use the argument names similarly to
+; new variable definitions which should be spell-checked.
+; e.g. dplyr::mutate(data_table, new_column_name=col_a + col_b) should check `new_column_name`
+(argument  name: (identifier) @identifier)
+
+; Assignments with `$` can similarly define new names
+; For chains, only check the last name since the earlier names are not being newly defined
+; e.g. `my_list$data_table$new_column_name <- 1 + 2` should check `new_column_name`
+(binary_operator
+  lhs: (extract_operator
+          operator: "$"
+          rhs: (identifier) @identifier)
+  operator: ["<-" "="])
+
+(binary_operator
+  operator: "->"
+  rhs: (extract_operator
+          operator: "$"
+          rhs: (identifier) @identifier))

crates/codebook/src/queries/r.scm

@@ -0,0 +1,88 @@
+use codebook::queries::LanguageType;
+mod utils;
+
+#[test]
+fn test_r_simple() {
+    utils::init_logging();
+    let processor = utils::get_processor();
+    let sample_text = r#"
+       calculatr <- function(numbr1, argumnt2=3) {
+           # This is an exampl function
+           numberr1 + argument2
+       }
+    "#;
+    let expected = vec!["argumnt", "calculatr", "exampl", "numbr"];
+    let binding = processor
+        .spell_check(sample_text, Some(LanguageType::R), None)
+        .to_vec();
+    let mut misspelled = binding
+        .iter()
+        .map(|r| r.word.as_str())
+        .collect::<Vec<&str>>();
+    misspelled.sort();
+    assert_eq!(misspelled, expected);
+}
+
+#[test]
+fn test_r_string() {
+    utils::init_logging();
+    let processor = utils::get_processor();
+    let sample_text = r#"
+        my_var <- "herlo, world"
+    "#;
+    let expected = vec!["herlo"];
+    let binding = processor
+        .spell_check(sample_text, Some(LanguageType::R), None)
+        .to_vec();
+    let mut misspelled = binding
+        .iter()
+        .map(|r| r.word.as_str())
+        .collect::<Vec<&str>>();
+    misspelled.sort();
+    assert_eq!(misspelled, expected);
+}
+
+#[test]
+fn test_r_kwarg() {
+    utils::init_logging();
+    let processor = utils::get_processor();
+    let sample_text = r#"
+        table2 <- dplyr::mutate(table1, mispell=nmae1 + name2, bad_spelin, olny_named_cols=3)
+    "#;
+    let expected = vec!["mispell", "olny"];
+    let binding = processor
+        .spell_check(sample_text, Some(LanguageType::R), None)
+        .to_vec();
+    let mut misspelled = binding
+        .iter()
+        .map(|r| r.word.as_str())
+        .collect::<Vec<&str>>();
+    misspelled.sort();
+    assert_eq!(misspelled, expected);
+}
+
+#[test]
+fn test_r_assign() {
+    utils::init_logging();
+    let processor = utils::get_processor();
+    let sample_text = r#"
+        list$miispell = list()
+        list$mispell$chiian <- 1
+        list$mispell$chainn[1:3] <- 2 # Should not get checked
+        list$ingore@atsigns = 3
+        4 -> right@atsigns$wroks
+        lerft -> rihgt # Only right-side gets checked
+        leeft <- 3
+        lefft = 2
+    "#;
+    let expected = vec!["chiian", "leeft", "lefft", "miispell", "rihgt", "wroks"];
+    let binding = processor
+        .spell_check(sample_text, Some(LanguageType::R), None)
+        .to_vec();
+    let mut misspelled = binding
+        .iter()
+        .map(|r| r.word.as_str())
+        .collect::<Vec<&str>>();
+    misspelled.sort();
+    assert_eq!(misspelled, expected);
+}