feat: allow specifying an input query-paths argument

cli/loader/src/lib.rs

@@ -496,7 +496,7 @@ impl Loader {
             }
             Ok(None) => None,
             Ok(Some((language, configuration))) => {
-                match configuration.highlight_config(language, apply_all_captures) {
+                match configuration.highlight_config(language, apply_all_captures, None) {
                     Err(e) => {
                         eprintln!(
                             "Failed to load property sheet for injection string '{}': {}",
@@ -708,16 +708,61 @@ impl<'a> LanguageConfiguration<'a> {
         &self,
         language: Language,
         apply_all_captures: bool,
+        paths: Option<&[String]>,
     ) -> Result<Option<&HighlightConfiguration>> {
+        let (highlights_filenames, injections_filenames, locals_filenames) = match paths {
+            Some(paths) => (
+                Some(
+                    paths
+                        .iter()
+                        .filter(|p| p.ends_with("highlights.scm"))
+                        .cloned()
+                        .collect(),
+                ),
+                Some(
+                    paths
+                        .iter()
+                        .filter(|p| p.ends_with("tags.scm"))
+                        .cloned()
+                        .collect(),
+                ),
+                Some(
+                    paths
+                        .iter()
+                        .filter(|p| p.ends_with("locals.scm"))
+                        .cloned()
+                        .collect(),
+                ),
+            ),
+            None => (None, None, None),
+        };
         return self
             .highlight_config
             .get_or_try_init(|| {
-                let (highlights_query, highlight_ranges) =
+                let (highlights_query, highlight_ranges) = self.read_queries(
-                    self.read_queries(&self.highlights_filenames, "highlights.scm")?;
+                    if highlights_filenames.is_some() {
-                let (injections_query, injection_ranges) =
+                        &highlights_filenames
-                    self.read_queries(&self.injections_filenames, "injections.scm")?;
+                    } else {
-                let (locals_query, locals_ranges) =
+                        &self.highlights_filenames
-                    self.read_queries(&self.locals_filenames, "locals.scm")?;
+                    },
+                    "highlights.scm",
+                )?;
+                let (injections_query, injection_ranges) = self.read_queries(
+                    if injections_filenames.is_some() {
+                        &injections_filenames
+                    } else {
+                        &self.injections_filenames
+                    },
+                    "injections.scm",
+                )?;
+                let (locals_query, locals_ranges) = self.read_queries(
+                    if locals_filenames.is_some() {
+                        &locals_filenames
+                    } else {
+                        &self.locals_filenames
+                    },
+                    "locals.scm",
+                )?;
 
                 if highlights_query.is_empty() {
                     Ok(None)

cli/src/main.rs

@@ -264,6 +264,14 @@ fn run() -> Result<()> {
                         .long("captures-path")
                         .takes_value(true),
                 )
+                .arg(
+                    Arg::with_name("query-paths")
+                        .help("Paths to files with queries")
+                        .long("query-paths")
+                        .takes_value(true)
+                        .multiple(true)
+                        .number_of_values(1),
+                )
                 .arg(&scope_arg)
                 .arg(&time_arg)
                 .arg(&quiet_arg)
@@ -592,6 +600,15 @@ fn run() -> Result<()> {
                 }
             }
 
+            let query_paths = matches.values_of("query-paths").map_or(None, |e| {
+                Some(
+                    e.collect::<Vec<_>>()
+                        .into_iter()
+                        .map(|s| s.to_string())
+                        .collect::<Vec<_>>(),
+                )
+            });
+
             for path in paths {
                 let path = Path::new(&path);
                 let (language, language_config) = match lang {
@@ -605,9 +622,11 @@ fn run() -> Result<()> {
                     },
                 };
 
-                if let Some(highlight_config) =
+                if let Some(highlight_config) = language_config.highlight_config(
-                    language_config.highlight_config(language, apply_all_captures)?
+                    language,
-                {
+                    apply_all_captures,
+                    query_paths.as_deref(),
+                )? {
                     if should_check {
                         let names = if let Some(path) = matches.value_of("captures-path") {
                             let path = Path::new(path);

cli/src/test_highlight.rs

@@ -76,7 +76,7 @@ fn test_highlights_indented(
                 .language_configuration_for_file_name(&test_file_path)?
                 .ok_or_else(|| anyhow!("No language found for path {:?}", test_file_path))?;
             let highlight_config = language_config
-                .highlight_config(language, apply_all_captures)?
+                .highlight_config(language, apply_all_captures, None)?
                 .ok_or_else(|| anyhow!("No highlighting config found for {:?}", test_file_path))?;
             match test_highlight(
                 &loader,