[function-grep] fixed tests, fixed grammar

also simplified passing list of langauges

Author: mendelsshop

function-grep/README.md

@@ -17,11 +17,11 @@ To see help run `function-grep --help`.
 # Examples
 ## When you know the language 
 ```rust
-use function_grep::{supported_languages::Rust, ParsedFile};
+use function_grep::{supported_languages::{Rust, SupportedLanguage}, ParsedFile};
 use tree_sitter::Point;
 use tree_sitter::Range;
 
-let results = ParsedFile::search_file("foo", "fn foo() {}\n fn bar()\n", &Rust).unwrap();
+let results = ParsedFile::search_file( "fn foo() {}\n fn bar()\n", &Rust.to_language("foo")).unwrap();
 println!("{:?}", results.results());
 assert_eq!(results.results(), &[Range { start_byte: 0, end_byte: 11, start_point: Point { row: 0, column: 0 }, end_point: Point { row: 0, column: 11 } }]);
 assert_eq!(results.to_string(), "1: fn foo() {}".to_string())
@@ -30,14 +30,26 @@ assert_eq!(results.to_string(), "1: fn foo() {}".to_string())
 ## When you don't know the language 
 
 ```rust
-use function_grep::{supported_languages, ParsedFile};
+use function_grep::{supported_languages::*, ParsedFile};
 use tree_sitter::Point;
 use tree_sitter::Range;
-
-let results = ParsedFile::search_file_with_name("foo", "fn foo() {}\n fn bar()\n", "test.rs",  supported_languages::predefined_languages()).unwrap();
+let results = ParsedFile::search_file_with_name(
+    "fn foo() {}\n fn bar()\n",
+    "test.rs",
+    &predefined_languages().instantiate_map("foo").unwrap(),
+)
+.unwrap();
 println!("{:?}", results.results());
-assert_eq!(results.results(), &[Range { start_byte: 0, end_byte: 11, start_point: Point { row: 0, column: 0 }, end_point: Point { row: 0, column: 11 } }]);
-assert_eq!(results.to_string(), "1: fn foo() {}".to_string())
+
+assert_eq!(
+    results.results(),
+    &[Range {
+        start_byte: 0,
+        end_byte: 11,
+        start_point: Point { row: 0, column: 0 },
+        end_point: Point { row: 0, column: 11 }
+    }]
+);
 ```
 
 ## More Examples
@@ -54,7 +66,7 @@ use tree_sitter::Language;
 
 
 #[cfg(feature = "rust")]
-construct_language!(Rust(tree_sitter_rust::language()).[rs]?=name->
+construct_language!(Rust(tree_sitter_rust::LANGUAGE).[rs]?=name->
 
             "((function_item
   name: (identifier) @method-name)
@@ -73,7 +85,7 @@ construct_language!(Rust(tree_sitter_rust::language()).[rs]?=name->
   value: (closure_expression)) @method-definition
 (#eq? @method-name {name}))"
 );
-let results = ParsedFile::search_file("foo", "fn foo() {}\n fn bar()\n", &Rust).unwrap();
+let results = ParsedFile::search_file( "fn foo() {}\n fn bar()\n", &Rust.to_language("foo")).unwrap();
 println!("{:?}", results.results());
 assert_eq!(results.results(), &[Range { start_byte: 0, end_byte: 11, start_point: Point { row: 0, column: 0 }, end_point: Point { row: 0, column: 11 } }]);
 assert_eq!(results.to_string(), "1: fn foo() {}".to_string())

function-grep/examples/main.rs

@@ -3,7 +3,7 @@
 #![deny(missing_debug_implementations, clippy::missing_panics_doc)]
 #![warn(clippy::pedantic, clippy::nursery, clippy::cargo)]
 #![deny(clippy::use_self, rust_2018_idioms)]
-use function_grep::supported_languages::InstatiateMap;
+use function_grep::supported_languages::InstantiateMap;
 use function_grep::{supported_languages::predefined_languages, ParsedFile};
 
 use clap::Parser;
@@ -37,14 +37,13 @@ pub fn main() -> Result<(), Error> {
     // read the file in
     let mut code = String::new();
     let languages = predefined_languages()
-        .instatiate_map(&args.name)
+        .instantiate_map(&args.name)
         .map_err(Error::QueryError)?;
-    let languages = &*languages.as_slice().iter().collect::<Box<[_]>>();
     file.read_to_string(&mut code)
         .map_err(Error::CouldNotReadFile)?;
     let file_name = &args.file.to_string_lossy();
     // search the file for function with the given name
-    let found = ParsedFile::search_file_with_name(&code, file_name, languages)
+    let found = ParsedFile::search_file_with_name(&code, file_name, &languages)
         .map_err(Error::LibraryError)?;
     // and print the results
     println!("{found}");

function-grep/src/lib.rs

@@ -7,7 +7,7 @@
 use core::fmt;
 
 use filter::InstantiatedFilter;
-use supported_languages::InstatiatedLanguage;
+use supported_languages::InstantiatedLanguage;
 use tree_sitter::{LanguageError, QueryError, Range, Tree};
 #[allow(missing_debug_implementations)]
 #[derive(Hash, PartialEq, Eq, Debug, Clone)]
@@ -68,12 +68,12 @@ pub enum Error {
 /// If there is no language for this file extension in the provided language list.
 pub fn get_file_type_from_file_ext<'a>(
     ext: &str,
-    langs: &'a [&'a InstatiatedLanguage<'a>],
-) -> Result<&'a InstatiatedLanguage<'a>, Error> {
+    langs: &'a [InstantiatedLanguage<'a>],
+) -> Result<&'a InstantiatedLanguage<'a>, Error> {
     langs
         .iter()
         .find(|lang| lang.file_exts().contains(&ext))
-        .copied()
+        //.copied()
         .ok_or_else(|| Error::FileTypeUnkown(ext.to_string()))
 }
 
@@ -86,8 +86,8 @@ pub fn get_file_type_from_file_ext<'a>(
 /// If there is no file extension for this file name, or there is no language for this file in the provided language list.
 pub fn get_file_type_from_file<'a>(
     file_name: &str,
-    langs: &'a [&'a InstatiatedLanguage<'a>],
-) -> Result<&'a InstatiatedLanguage<'a>, Error> {
+    langs: &'a [ InstantiatedLanguage<'a>],
+) -> Result<&'a InstantiatedLanguage<'a>, Error> {
     file_name
         .rsplit_once('.')
         .ok_or_else(|| Error::FileTypeUnkown(file_name.to_string()))
@@ -106,7 +106,7 @@ pub struct ParsedFile {
     file_name: Option<Box<str>>,
     function_name: Box<str>,
     // TODO: maybe each supported language could define filters
-    // if so we would store InstatiatedLanguage here
+    // if so we would store InstantiatedLanguage here
     language_type: Box<str>,
     tree: Tree,
     results: Box<[Range]>,
@@ -197,7 +197,7 @@ impl ParsedFile {
     /// If something with tree sitter goes wrong.
     /// If the code cannot be parsed properly.
     /// If no results are found for this function name.
-    pub fn search_file(code: &str, language: &InstatiatedLanguage<'_>) -> Result<Self, Error> {
+    pub fn search_file(code: &str, language: &InstantiatedLanguage<'_>) -> Result<Self, Error> {
         let code_bytes = code.as_bytes();
         let mut parser = tree_sitter::Parser::new();
         let ts_lang = language.language();
@@ -234,7 +234,7 @@ impl ParsedFile {
     pub fn search_file_with_name(
         code: &str,
         file_name: &str,
-        langs: &[&InstatiatedLanguage<'_>],
+        langs: &[InstantiatedLanguage<'_>],
     ) -> Result<Self, Error> {
         get_file_type_from_file(file_name, langs)
             .and_then(|language| Self::search_file(code, language))

function-grep/src/supported_languages.rs

@@ -7,7 +7,7 @@ use tree_sitter::{Language as TsLanguage, Node, Query, QueryError, Range};
 // TODO: we could probably use tree sitter tags?
 
 #[allow(missing_debug_implementations)]
-pub struct InstatiatedLanguage<'a> {
+pub struct InstantiatedLanguage<'a> {
     search_name: &'a str,
     language: LanguageInformation,
     run_query: QueryFunction,
@@ -79,15 +79,15 @@ pub struct Identifier;
 pub struct TreeSitter;
 // TODO: hide in docs?
 trait InstantiateHelper<Type> {
-    fn instiate(&self, search: Box<str>) -> QueryFunction;
+    fn instantiate(&self, search: Box<str>) -> QueryFunction;
 }
 
 // TODO: hide in docs?
 pub trait Assoc {
     type Type;
 }
 impl<T: IdentifierQuery> InstantiateHelper<Identifier> for T {
-    fn instiate(
+    fn instantiate(
         &self,
         search: Box<str>,
     ) -> Box<dyn for<'x, 'y> Fn(Node<'x>, &'y [u8]) -> Box<[Range]> + Send + Sync> {
@@ -112,7 +112,7 @@ impl<T: IdentifierQuery> InstantiateHelper<Identifier> for T {
     }
 }
 impl<T: TreeSitterQuery> InstantiateHelper<TreeSitter> for T {
-    fn instiate(
+    fn instantiate(
         &self,
         search: Box<str>,
     ) -> Box<dyn for<'x, 'y> Fn(Node<'x>, &'y [u8]) -> Box<[Range]> + Send + Sync> {
@@ -131,35 +131,42 @@ impl<T: TreeSitterQuery> InstantiateHelper<TreeSitter> for T {
 }
 
 impl<T: Assoc + InstantiateHelper<T::Type> + HasLanguageInformation> SupportedLanguage for T {
-    fn instiate(
+    fn instantiate(
         &self,
         search: Box<str>,
     ) -> Box<dyn for<'x, 'y> Fn(Node<'x>, &'y [u8]) -> Box<[Range]> + Send + Sync> {
-        self.instiate(search)
+        self.instantiate(search)
     }
 }
 type QueryFunction = Box<dyn for<'x, 'y> Fn(Node<'x>, &'y [u8]) -> Box<[Range]> + Send + Sync>;
 
 pub trait SupportedLanguage: HasLanguageInformation {
-    fn instiate(&self, search: Box<str>) -> QueryFunction;
+    fn instantiate(&self, search: Box<str>) -> QueryFunction;
+    fn to_language<'a>(&self, search: &'a str) -> InstantiatedLanguage<'a> {
+        InstantiatedLanguage::new(
+            search,
+            self.language_info(),
+            self.instantiate(search.into()),
+        )
+    }
 }
 
-pub trait InstatiateMap<'a> {
-    fn instatiate_map(self, name: &'a str) -> Result<Vec<InstatiatedLanguage<'a>>, QueryError>;
+pub trait InstantiateMap<'a> {
+    fn instantiate_map(self, name: &'a str) -> Result<Vec<InstantiatedLanguage<'a>>, QueryError>;
 }
-impl<'a, T, U> InstatiateMap<'a> for T
+impl<'a, T, U> InstantiateMap<'a> for T
 where
     T: IntoIterator<Item = U>,
     U: Deref<Target = &'a dyn SupportedLanguage>,
 {
-    fn instatiate_map(self, name: &'a str) -> Result<Vec<InstatiatedLanguage<'a>>, QueryError> {
+    fn instantiate_map(self, name: &'a str) -> Result<Vec<InstantiatedLanguage<'a>>, QueryError> {
         Ok(self
             .into_iter()
-            .map(|l| InstatiatedLanguage::new(name, l.language_info(), l.instiate(name.into())))
+            .map(|l| InstantiatedLanguage::new(name, l.language_info(), l.instantiate(name.into())))
             .collect())
     }
 }
-impl<'a> InstatiatedLanguage<'a> {
+impl<'a> InstantiatedLanguage<'a> {
     pub(crate) fn new(
         search_name: &'a str,
         language: LanguageInformation,
@@ -208,7 +215,7 @@ impl<'a> InstatiatedLanguage<'a> {
 /// use function_grep::construct_language;
 /// use function_grep::supported_languages::SupportedLanguage;
 /// use tree_sitter::Language;
-/// construct_language!(C(tree_sitter_c::language()).[c h]?=
+/// construct_language!(C(tree_sitter_c::LANGUAGE).[c h]?=
 ///    name ->  "((function_definition
 ///  declarator:
 ///  (function_declarator declarator: (identifier) @method-name))
@@ -224,7 +231,7 @@ macro_rules! construct_language {
     ($name:ident($tslang:expr).[$($ext:ident)+]?=$query_name:literal=>$query:literal ) => {
         #[derive(Debug, Clone, Copy)]
         pub struct $name;
-        impl HasLanguageInformation for $name {
+        impl $crate::supported_languages::HasLanguageInformation for $name {
 
             fn language_name(&self) -> &'static str {
                 stringify!($name)
@@ -234,14 +241,14 @@ macro_rules! construct_language {
                 &[$(stringify!($ext)),+]
             }
 
-            fn language(&self) -> TsLanguage {
+            fn language(&self) -> tree_sitter::Language {
                 $tslang.into()
             }
         }
-        impl Assoc for $name {
-            type Type = Identifier;
+        impl $crate::supported_languages::Assoc for $name {
+            type Type = $crate::supported_languages::Identifier;
         }
-        impl IdentifierQuery for $name {
+        impl $crate::supported_languages::IdentifierQuery for $name {
             fn query_name(&self) -> impl ToString {
                 $query_name
             }
@@ -255,7 +262,7 @@ macro_rules! construct_language {
         #[derive(Debug, Clone, Copy)]
         pub struct $name;
 
-        impl HasLanguageInformation for $name {
+        impl $crate::supported_languages::HasLanguageInformation for $name {
 
             fn language_name(&self) -> &'static str {
                 stringify!($name)
@@ -265,14 +272,14 @@ macro_rules! construct_language {
                 &[$(stringify!($ext)),+]
             }
 
-            fn language(&self) -> TsLanguage {
+            fn language(&self) -> tree_sitter::Language {
                 $tslang.into()
             }
         }
-        impl Assoc for $name {
-            type Type = TreeSitter;
+        impl $crate::supported_languages::Assoc for $name {
+            type Type = $crate::supported_languages::TreeSitter;
         }
-        impl TreeSitterQuery for $name {
+        impl $crate::supported_languages::TreeSitterQuery for $name {
             fn query_string_function(&self, $query_name: &str) -> String {
                 format!($query)
             }

git-function-history-lib/src/lib.rs

@@ -38,7 +38,7 @@ macro_rules! get_item_from_oid_option {
 }
 use chrono::{DateTime, Utc};
 use function_grep::{
-    supported_languages::{InstatiateMap, InstatiatedLanguage, SupportedLanguage},
+    supported_languages::{InstantiateMap, InstantiatedLanguage, SupportedLanguage},
     ParsedFile,
 };
 use git_function_history_proc_macro::enumstuff;
@@ -229,8 +229,8 @@ pub fn get_function_history(
         let metadata = (message, commit, author, email, time);
         Some((tree, metadata))
     });
-    let langs = langs.instatiate_map(name).unwrap();
-    let langs = &*langs.as_slice().iter().collect::<Box<[_]>>();
+    let langs = langs.instantiate_map(name).unwrap();
+    let langs = langs.as_slice();
     if let Filter::Date(date) = filter {
         let date = DateTime::parse_from_rfc2822(date)?.with_timezone(&Utc);
         let commit = commits.min_by_key(|commit| (commit.1 .4.sub(date).num_seconds().abs()));
@@ -320,7 +320,7 @@ fn sender(
     id: ObjectId,
     repo: gix::Repository,
     file_exts: &[&str],
-    langs: &[&InstatiatedLanguage<'_>],
+    langs: &[InstantiatedLanguage<'_>],
     file: &FileFilterType,
 ) -> Result<Vec<ParsedFile>, String> {
     let object = repo.find_object(id).map_err(|_| "failed to find object")?;
@@ -335,7 +335,7 @@ fn traverse_tree(
     repo: &gix::Repository,
     path: String,
     file_exts: &[&str],
-    langs: &[&InstatiatedLanguage<'_>],
+    langs: &[InstantiatedLanguage<'_>],
     filetype: &FileFilterType,
 ) -> Result<Vec<ParsedFile>, String> {
     let files_exts_iter = file_exts.iter();
@@ -534,7 +534,7 @@ pub struct CommitInfo {
 // function that takes a vec of files paths and there contents and a function name and uses find_function_in_file_with_commit to find the function in each file and returns a vec of the functions
 fn find_function_in_files_with_commit(
     files: Vec<(String, String)>,
-    langs: &[&InstatiatedLanguage<'_>],
+    langs: &[InstantiatedLanguage<'_>],
 ) -> Vec<ParsedFile> {
     // commenting out this parallelization seems to net a gain in performance with tree sitter
     //#[cfg(feature = "parallel")]