183 wildcard include does not work in windows

.github/workflows/build-latest.yml

@@ -33,12 +33,18 @@ jobs:
         run: yarn run build
         working-directory: ./frontend
   test:
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+        rust: [stable]
     steps:
       - uses: actions/checkout@v1
-      - uses: actions-rs/toolchain@v1
+      - name: Install ${{ matrix.rust }}
+        uses: actions-rs/toolchain@v1
         with:
-          toolchain: stable
+          toolchain: ${{ matrix.rust }}
+          override: true
       - uses: actions/cache@v3
         with:
           path: |

core/src/ledger.rs

@@ -5,7 +5,7 @@ use std::sync::{Arc, RwLock};
 
 use bigdecimal::Zero;
 use glob::Pattern;
-use itertools::Itertools;
+use itertools::{Either, Itertools};
 use log::{error, info};
 use zhang_ast::{Directive, DirectiveType, Spanned, Transaction};
 
@@ -21,7 +21,7 @@ use crate::ZhangResult;
 pub struct Ledger {
     pub entry: (PathBuf, String),
 
-    pub visited_files: Vec<Pattern>,
+    pub visited_files: Vec<Either<Pattern, PathBuf>>,
 
     pub options: InMemoryOptions,
 
@@ -49,7 +49,7 @@ impl Ledger {
     }
 
     fn process(
-        directives: Vec<Spanned<Directive>>, entry: (PathBuf, String), visited_files: Vec<Pattern>, transformer: Arc<dyn Transformer>,
+        directives: Vec<Spanned<Directive>>, entry: (PathBuf, String), visited_files: Vec<Either<Pattern, PathBuf>>, transformer: Arc<dyn Transformer>,
     ) -> ZhangResult<Ledger> {
         let (meta_directives, dated_directive): (Vec<Spanned<Directive>>, Vec<Spanned<Directive>>) =
             directives.into_iter().partition(|it| it.datetime().is_none());
@@ -188,6 +188,7 @@ mod test {
     use std::sync::Arc;
 
     use glob::Pattern;
+    use itertools::Either;
     use tempfile::tempdir;
     use zhang_ast::{Directive, SpanInfo, Spanned};
 
@@ -222,7 +223,7 @@ mod test {
         Ledger::process(
             test_parse_zhang(content),
             (temp_dir.clone(), "example.zhang".to_string()),
-            vec![Pattern::new(temp_dir.join("example.zhang").as_path().to_str().unwrap()).unwrap()],
+            vec![Either::Left(Pattern::new(temp_dir.join("example.zhang").as_path().to_str().unwrap()).unwrap())],
             Arc::new(TestTransformer {}),
         )
         .unwrap()

core/src/lib.rs

@@ -24,6 +24,7 @@ mod test {
     use std::sync::Arc;
 
     use glob::Pattern;
+    use itertools::Either;
     use serde_json_path::JsonPath;
     use tempfile::tempdir;
     use zhang_ast::{Directive, Spanned};
@@ -42,7 +43,7 @@ mod test {
             let result: Vec<Spanned<Directive>> = parse_zhang(&string, file).expect("cannot read file");
             Ok(TransformResult {
                 directives: result,
-                visited_files: vec![Pattern::new("example.zhang").unwrap()],
+                visited_files: vec![Either::Left(Pattern::new("example.zhang").unwrap())],
             })
         }
     }

core/src/transform.rs

@@ -1,17 +1,19 @@
-use std::collections::{HashSet, VecDeque};
+use std::collections::VecDeque;
 use std::path::PathBuf;
+use std::str::FromStr;
 
 use glob::{glob, Pattern};
-use itertools::Itertools;
+use itertools::Either;
 use log::debug;
 use zhang_ast::{Directive, Spanned};
 
 use crate::error::IoErrorIntoZhangError;
+use crate::utils::to_glob_or_path;
 use crate::{utils, ZhangResult};
 
 pub struct TransformResult {
     pub directives: Vec<Spanned<Directive>>,
-    pub visited_files: Vec<Pattern>,
+    pub visited_files: Vec<Either<Pattern, PathBuf>>,
 }
 
 pub trait Transformer
@@ -43,46 +45,67 @@
         let entry = entry.canonicalize().with_path(&entry)?;
         let main_endpoint = entry.join(endpoint);
         let main_endpoint = main_endpoint.canonicalize().with_path(&main_endpoint)?;
-        let mut load_queue: VecDeque<Pattern> = VecDeque::new();
-        load_queue.push_back(Pattern::new(main_endpoint.as_path().to_str().unwrap()).unwrap());
+        let mut load_queue: VecDeque<Either<Pattern, PathBuf>> = VecDeque::new();
+        let a = to_glob_or_path(main_endpoint);
+        load_queue.push_back(a);
 
-        let mut visited: HashSet<Pattern> = HashSet::new();
+        let mut visited: Vec<Either<Pattern, PathBuf>> = Vec::new();
         let mut directives = vec![];
         while let Some(load_entity) = load_queue.pop_front() {
-            debug!("visited path pattern: {}", load_entity);
-            for entry in glob(load_entity.as_str()).unwrap() {
-                match entry {
-                    Ok(path) => {
-                        debug!("visited entry file: {:?}", path.display());
-                        if utils::has_path_visited(&visited, &path) {
-                            continue;
-                        }
-                        let file_content = self.get_file_content(path.clone())?;
-                        let entity_directives = self.parse(&file_content, path.clone())?;
+            //            debug!("visited path pattern: {}", load_entity);
+
+            match &load_entity {
+                Either::Left(pattern) => {
+                    for entry in glob(pattern.as_str()).unwrap() {
+                        match entry {
+                            Ok(path) => {
+                                debug!("visited entry file: {:?}", path.display());
+                                if utils::has_path_visited(&visited, &path) {
+                                    continue;
+                                }
+                                let file_content = self.get_file_content(path.clone())?;
+                                let entity_directives = self.parse(&file_content, path.clone())?;
 
-                        entity_directives.iter().filter_map(|directive| self.go_next(directive)).for_each(|buf| {
-                            let fullpath = if buf.starts_with('/') {
-                                buf
-                            } else {
-                                path.parent()
-                                    .map(|it| it.join(buf))
-                                    .map(|it| it.as_path().to_str().unwrap().to_owned())
-                                    .unwrap()
-                            };
-                            load_queue.push_back(Pattern::new(&fullpath).unwrap());
-                        });
-                        directives.extend(entity_directives)
+                                entity_directives.iter().filter_map(|directive| self.go_next(directive)).for_each(|buf| {
+                                    let fullpath = if buf.starts_with('/') {
+                                        to_glob_or_path(PathBuf::from_str(&buf).unwrap())
+                                    } else {
+                                        path.parent().map(|it| it.join(buf)).map(to_glob_or_path).unwrap()
+                                    };
+                                    load_queue.push_back(fullpath);
+                                });
+                                directives.extend(entity_directives);
+                            }
+                            // if the path matched but was unreadable,
+                            // thereby preventing its contents from matching
+                            Err(e) => println!("{:?}", e),
+                        }
                     }
-                    // if the path matched but was unreadable,
-                    // thereby preventing its contents from matching
-                    Err(e) => println!("{:?}", e),
+                }
+                Either::Right(pathbuf) => {
+                    debug!("visited entry file: {:?}", pathbuf.display());
+                    if utils::has_path_visited(&visited, pathbuf) {
+                        continue;
+                    }
+                    let file_content = self.get_file_content(pathbuf.clone())?;
+                    let entity_directives = self.parse(&file_content, pathbuf.clone())?;
+
+                    entity_directives.iter().filter_map(|directive| self.go_next(directive)).for_each(|buf| {
+                        let fullpath = if buf.starts_with('/') {
+                            to_glob_or_path(PathBuf::from_str(&buf).unwrap())
+                        } else {
+                            pathbuf.parent().map(|it| it.join(buf)).map(to_glob_or_path).unwrap()
+                        };
+                        load_queue.push_back(fullpath);
+                    });
+                    directives.extend(entity_directives);
                 }
             }
-            visited.insert(load_entity);
+            visited.push(load_entity);
         }
         Ok(TransformResult {
             directives: self.transform(directives)?,
-            visited_files: visited.into_iter().collect_vec(),
+            visited_files: visited,
         })
     }
 }

core/src/utils/mod.rs

@@ -1,6 +1,7 @@
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 use glob::Pattern;
+use itertools::Either;
 
 pub mod bigdecimal_ext;
 pub mod calculable;
@@ -11,6 +12,20 @@
 pub mod price_grip;
 pub mod string_;
 
-pub fn has_path_visited<'a>(visited: impl IntoIterator<Item = &'a Pattern>, path: &Path) -> bool {
-    visited.into_iter().any(|pattern| pattern.matches_path(path))
+pub fn has_path_visited<'a>(visited: impl IntoIterator<Item = &'a Either<Pattern, PathBuf>>, path: &Path) -> bool {
+    visited.into_iter().any(|pattern| match pattern {
+        Either::Left(pattern) => pattern.matches_path(path),
+        Either::Right(pathbuf) => pathbuf.eq(path),
+    })
+}
+
+const GLOB_CHAR: char = '*';
+pub(crate) fn to_glob_or_path(path: PathBuf) -> Either<Pattern, PathBuf> {
+    let path_str = path.as_path().to_str().unwrap();
+
+    if path_str.contains(GLOB_CHAR) {
+        Either::Left(Pattern::new(path.as_path().to_str().unwrap()).unwrap())
+    } else {
+        Either::Right(path)
+    }
 }

server/src/routes/file.rs

@@ -2,6 +2,7 @@
 
 use actix_web::web::{Data, Json, Path};
 use actix_web::{get, put};
+use itertools::Either;
 use log::error;
 use tokio::sync::RwLock;
 use zhang_core::ledger::Ledger;
@@ -16,14 +17,21 @@
     let entry_path = &ledger.entry.0;
 
     let mut ret = vec![];
-    for patten in &ledger.visited_files {
-        for entry in glob::glob(patten.as_str()).unwrap() {
-            match entry {
-                Ok(path) => {
-                    let p = path.strip_prefix(entry_path).unwrap().to_str().map(|it| it.to_string());
-                    ret.push(p);
+    for visited in &ledger.visited_files {
+        match visited {
+            Either::Left(pattern) => {
+                for entry in glob::glob(pattern.as_str()).unwrap() {
+                    match entry {
+                        Ok(path) => {
+                            let p = path.strip_prefix(entry_path).unwrap().to_str().map(|it| it.to_string());
+                            ret.push(p);
+                        }
+                        Err(e) => error!("{:?}", e),
+                    }
                 }
-                Err(e) => error!("{:?}", e),
+            }
+            Either::Right(path) => {
+                ret.push(path.to_str().map(|it| it.to_string()));
             }
         }
     }