@browsersync/bslive 0.0.5 → 0.0.9

package/crates/bsnext_fs/src/watcher.rs

@@ -0,0 +1,348 @@
+use crate::inner_fs_event_handler::InnerChangeEvent;
+use notify::event::{
+    AccessKind, AccessMode, CreateKind, DataChange, MetadataKind, ModifyKind, RemoveKind,
+    RenameMode,
+};
+use notify::EventKind;
+use std::collections::HashSet;
+use std::ffi::OsStr;
+use std::path::{Component, Path};
+use std::sync::Arc;
+use tokio::sync::broadcast;
+
+pub fn create_watcher(
+    sender: Arc<broadcast::Sender<InnerChangeEvent>>,
+    cwd: &Path,
+) -> notify::Result<notify::FsEventWatcher> {
+    let cwd_c = cwd.to_owned();
+    notify::recommended_watcher(move |res: Result<notify::Event, _>| {
+        let span = tracing::span!(tracing::Level::TRACE, "raw");
+        let _guard = span.enter();
+        match res {
+            Ok(event) => {
+                if event.paths.iter().any(|p| {
+                    is_ignored_path_type(&p.as_path())
+                        || is_auto_excluded(&cwd_c.as_path(), &p.as_path())
+                }) {
+                    tracing::trace!(?event.paths, "ignored!!!");
+                    return;
+                }
+
+                let msg = InnerChangeEvent {
+                    absolute_path: event.paths.first().unwrap().into(),
+                };
+                match event.kind {
+                    EventKind::Any => {}
+                    EventKind::Access(ac) => match ac {
+                        AccessKind::Any => tracing::trace!("EventKind::Access AccessKind::Any"),
+                        AccessKind::Read => {
+                            tracing::trace!("EventKind::Access AccessKind::Read")
+                        }
+                        AccessKind::Open(o) => match o {
+                            AccessMode::Any => {
+                                tracing::trace!(
+                                    "EventKind::Access AccessKind::Open AccessMode::Any"
+                                )
+                            }
+                            AccessMode::Execute => {
+                                tracing::trace!(
+                                    "EventKind::Access AccessKind::Open AccessMode::Execute"
+                                )
+                            }
+                            AccessMode::Read => {
+                                tracing::trace!(
+                                    "EventKind::Access AccessKind::Open AccessMode::Read"
+                                )
+                            }
+                            AccessMode::Write => {
+                                tracing::trace!(
+                                    "EventKind::Access AccessKind::Open AccessMode::Write"
+                                )
+                            }
+                            AccessMode::Other => {
+                                tracing::trace!(
+                                    "EventKind::Access AccessKind::Open AccessMode::Other"
+                                )
+                            }
+                        },
+                        AccessKind::Close(c) => match c {
+                            AccessMode::Any => {
+                                tracing::trace!(
+                                    "EventKind::Access AccessKind::Close AccessMode::Any"
+                                )
+                            }
+                            AccessMode::Execute => {
+                                tracing::trace!(
+                                    "EventKind::Access AccessKind::Close AccessMode::Execute"
+                                )
+                            }
+                            AccessMode::Read => {
+                                tracing::trace!(
+                                    "EventKind::Access AccessKind::Close AccessMode::Read"
+                                )
+                            }
+                            AccessMode::Write => {
+                                tracing::trace!(
+                                    "EventKind::Access AccessKind::Close AccessMode::Write"
+                                )
+                            }
+                            AccessMode::Other => {
+                                tracing::trace!(
+                                    "EventKind::Access AccessKind::Close AccessMode::Other"
+                                )
+                            }
+                        },
+                        AccessKind::Other => {
+                            tracing::trace!("EventKind::Access AccessKind::Other")
+                        }
+                    },
+                    EventKind::Create(c) => match c {
+                        CreateKind::Any => tracing::trace!("EventKind::Create CreateKind::Any"),
+                        CreateKind::File => {
+                            tracing::trace!("EventKind::Create CreateKind::File")
+                        }
+                        CreateKind::Folder => {
+                            tracing::trace!("EventKind::Create CreateKind::Folder")
+                        }
+                        CreateKind::Other => {
+                            tracing::trace!("EventKind::Create CreateKind::Other")
+                        }
+                    },
+                    EventKind::Modify(modify) => match modify {
+                        ModifyKind::Any => tracing::trace!("EventKind::Modify ModifyKind::Any"),
+                        ModifyKind::Data(data) => match data {
+                            DataChange::Any => {
+                                tracing::trace!(
+                                    "EventKind::Modify ModifyKind::Data DataChange::Any"
+                                );
+                            }
+                            DataChange::Size => {
+                                tracing::trace!(
+                                    "EventKind::Modify ModifyKind::Data DataChange::Size"
+                                );
+                            }
+                            DataChange::Content => {
+                                tracing::trace!(
+                                    "EventKind::Modify ModifyKind::Data DataChange::Content"
+                                );
+                                match sender.send(msg) {
+                                    Ok(_) => {}
+                                    Err(e) => tracing::error!(?e),
+                                };
+                            }
+                            DataChange::Other => {
+                                tracing::trace!(
+                                    "EventKind::Modify ModifyKind::Data DataChange::Other"
+                                );
+                            }
+                        },
+                        ModifyKind::Metadata(meta) => {
+                            match meta {
+                                MetadataKind::Any => {
+                                    tracing::trace!(
+                                        "EventKind::Modify ModifyKind::Metadata MetadataKind::Any"
+                                    );
+                                    match sender.send(msg) {
+                                        Ok(_) => {}
+                                        Err(e) => tracing::error!(?e),
+                                    };
+                                }
+                                MetadataKind::AccessTime => {
+                                    tracing::trace!("EventKind::Modify ModifyKind::Metadata MetadataKind::AccessTime")
+                                }
+                                MetadataKind::WriteTime => {
+                                    tracing::trace!("EventKind::Modify ModifyKind::Metadata MetadataKind::WriteTime")
+                                }
+                                MetadataKind::Permissions => {
+                                    tracing::trace!("EventKind::Modify ModifyKind::Metadata MetadataKind::Permissions")
+                                }
+                                MetadataKind::Ownership => {
+                                    tracing::trace!("EventKind::Modify ModifyKind::Metadata MetadataKind::Ownership")
+                                }
+                                MetadataKind::Extended => {
+                                    tracing::trace!("EventKind::Modify ModifyKind::Metadata MetadataKind::Extended")
+                                }
+                                MetadataKind::Other => {
+                                    tracing::trace!("EventKind::Modify ModifyKind::Metadata MetadataKind::Other")
+                                }
+                            }
+                        }
+                        ModifyKind::Name(mode) => match mode {
+                            RenameMode::Any => {
+                                tracing::trace!(
+                                    "EventKind::Modify ModifyKind::Name RenameMode::Any"
+                                )
+                            }
+                            RenameMode::To => {
+                                tracing::trace!("EventKind::Modify ModifyKind::Name RenameMode::To")
+                            }
+                            RenameMode::From => {
+                                tracing::trace!(
+                                    "EventKind::Modify ModifyKind::Name RenameMode::From"
+                                )
+                            }
+                            RenameMode::Both => {
+                                tracing::trace!(
+                                    "EventKind::Modify ModifyKind::Name RenameMode::Both"
+                                )
+                            }
+                            RenameMode::Other => {
+                                tracing::trace!(
+                                    "EventKind::Modify ModifyKind::Name RenameMode::Other"
+                                )
+                            }
+                        },
+                        ModifyKind::Other => {
+                            tracing::trace!("EventKind::Modify ModifyKind::Other")
+                        }
+                    },
+                    EventKind::Remove(remove) => match remove {
+                        RemoveKind::Any => tracing::trace!("EventKind::Remove RemoveKind::Any"),
+                        RemoveKind::File => {
+                            tracing::trace!("EventKind::Remove RemoveKind::File")
+                        }
+                        RemoveKind::Folder => {
+                            tracing::trace!("EventKind::Remove RemoveKind::Folder")
+                        }
+                        RemoveKind::Other => {
+                            tracing::trace!("EventKind::Remove RemoveKind::Other")
+                        }
+                    },
+                    EventKind::Other => tracing::trace!("EventKind::Other"),
+                }
+            }
+            Err(e) => {
+                tracing::error!("fswadtcher {:?}", e);
+            }
+        }
+    })
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    #[test]
+    fn test() {
+        let cwd = Path::new("/Users/shaneosbourne/WebstormProjects/browsersync.github.io");
+        let change = Path::new("/Users/shaneosbourne/WebstormProjects/browsersync.github.io/node_modules/ajv/dist/vocabularies/applicator/if.d.ts");
+        let excluded = is_auto_excluded(&cwd, &change);
+        assert_eq!(excluded, true);
+    }
+}
+
+fn is_ignored_path_type<P: AsRef<Path>>(subject: &P) -> bool {
+    subject
+        .as_ref()
+        .as_os_str()
+        .as_encoded_bytes()
+        .ends_with(b"~")
+}
+
+fn is_auto_excluded<P: AsRef<Path>>(cwd: &P, subject: &P) -> bool {
+    // todo: allow more config here...
+    let excluded: HashSet<&OsStr> = [
+        "node_modules",
+        ".git",
+        ".husky",
+        ".vscode",
+        ".idea",
+        ".sass-cache",
+    ]
+    .into_iter()
+    .map(OsStr::new)
+    .collect();
+    let rel = subject.as_ref().strip_prefix(cwd.as_ref());
+    return rel
+        .map(|p| match p.components().next() {
+            None => false,
+            Some(Component::Normal(str)) => excluded.contains(str),
+            Some(Component::Prefix(_)) => unreachable!("here? Prefix"),
+            Some(Component::RootDir) => unreachable!("here? RootDir"),
+            Some(Component::CurDir) => unreachable!("here? CurDir"),
+            Some(Component::ParentDir) => unreachable!("here? ParentDir"),
+        })
+        .unwrap_or(false);
+}
+
+#[test]
+fn matches_single_glob() {
+    use glob_match::glob_match;
+    let p1 = "public/css/style.css";
+    let g = "public/css/*.css";
+    let actual = glob_match(g, p1);
+    assert_eq!(actual, true);
+}
+#[test]
+fn matches_relative_glob_2() {
+    use glob_match::glob_match;
+    let relative_path = [
+        (
+            "/qwe/qwe/qwe/qw/ebuild/app-debug/debugger/debugger.css",
+            true,
+        ),
+        ("/qwe/qwe/qwe/qw/ebuild/app-debug/oops.txt", true),
+    ];
+    let glob = "**/*.{css,txt}";
+    for (path, expected) in relative_path {
+        let actual = glob_match(glob, path);
+        assert_eq!(actual, expected);
+    }
+}
+
+#[test]
+fn matches_absolute_glob() {
+    use glob_match::glob_match;
+
+    let test_cases = vec![
+        (
+            "/absolute/path/public/css/style.css",
+            "/absolute/path/public/css/*.css",
+            true,
+        ),
+        (
+            "/absolute/path/public/js/script.js",
+            "/absolute/path/public/css/*.css",
+            false,
+        ),
+        (
+            "/absolute/path/public/css/nested/style.css",
+            "/absolute/path/public/css/**/*.css",
+            true,
+        ),
+        (
+            "/absolute/path/public/js/nested/script.js",
+            "/absolute/path/public/css/**/*.css",
+            false,
+        ),
+        (
+            "/users/documents/reports/january/cash_flow.xls",
+            "/users/documents/reports/**/*.xls",
+            true,
+        ),
+        (
+            "/users/documents/reports/february/income.txt",
+            "/users/documents/reports/**/*.xls",
+            false,
+        ),
+        (
+            "/users/documents/reports/yearly/cash_flow.xls",
+            "/users/documents/reports/**/*.xls",
+            true,
+        ),
+        (
+            "/users/images/vacation/summer/pic.jpg",
+            "/users/images/vacation/**/*.jpg",
+            true,
+        ),
+        (
+            "/users/images/vacation/winter/snow.png",
+            "/users/images/vacation/**/*.jpg",
+            false,
+        ),
+    ];
+
+    for (path, glob, expected) in test_cases {
+        let actual = glob_match(glob, path);
+        assert_eq!(actual, expected);
+    }
+}

package/crates/bsnext_input/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "bsnext_input"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+markdown = { version = "1.0.0-alpha.16" }
+
+random_word = { workspace = true }
+mime_guess = { workspace = true }
+serde = { workspace = true }
+clap = { workspace = true }
+anyhow = { workspace = true }
+serde_yaml = { workspace = true }
+serde_json = { workspace = true }
+toml = { workspace = true }
+tracing = { workspace = true }
+thiserror = { workspace = true }
+typeshare = { workspace = true }
+nom = "7.1.3"

package/crates/bsnext_input/src/input_test/mod.rs

@@ -0,0 +1,151 @@
+use crate::route::{
+    CorsOpts, DebounceDuration, DelayKind, DelayOpts, FilterKind, Route, Spec, SpecOpts, WatchOpts,
+    Watcher,
+};
+use crate::Input;
+
+#[test]
+fn test_deserialize() {
+    let input = include_str!("../../../../examples/kitchen-sink/input.yml");
+    let _: Input = serde_yaml::from_str(input).unwrap();
+}
+
+#[test]
+fn test_deserialize_2() {
+    #[derive(serde::Deserialize, serde::Serialize, Debug)]
+    struct Config {
+        pub items: Vec<Route>,
+    }
+
+    let input = r#"
+    items:
+      - path: /hello.js
+        raw: "hello"
+        cors: true
+        delay:
+            ms: 2000
+      - path: /hello.js
+        json: ["2", "3"]
+      - path: /node_modules
+        dir: ./node_modules
+      - path: /node_modules
+        dir: ./node_modules
+      - path: /api
+        proxy: example.com
+
+        "#;
+    let c: Config = serde_yaml::from_str(input).unwrap();
+    let first = c.items.get(0).unwrap().to_owned();
+    let opts = first.cors_opts.unwrap();
+    assert_eq!(opts, CorsOpts::Cors(true));
+
+    let delay_opts = first.delay_opts.unwrap();
+    assert_eq!(delay_opts, DelayOpts::Delay(DelayKind::Ms(2000)));
+}
+
+#[test]
+fn test_deserialize_cors_false() {
+    #[derive(serde::Deserialize, serde::Serialize, Debug)]
+    struct Config {
+        pub items: Vec<Route>,
+    }
+
+    let input = r#"
+    items:
+      - path: /hello.js
+        raw: "hello"
+        cors: false
+        "#;
+    let c: Config = serde_yaml::from_str(input).unwrap();
+    let first = c.items.get(0).unwrap().to_owned();
+    let opts = first.cors_opts.unwrap();
+    assert_eq!(opts, CorsOpts::Cors(false));
+}
+
+#[test]
+fn test_deserialize_3() {
+    let input = r#"
+    path: /hello.js
+    dir: "hello"
+    cors: true
+        "#;
+    let _c: Route = serde_yaml::from_str(input).unwrap();
+}
+
+#[test]
+fn test_deserialize_watch() {
+    let input = r#"
+    path: /hello.js
+    dir: "hello"
+    watch: true
+        "#;
+    let c: Route = serde_yaml::from_str(input).unwrap();
+    assert_eq!(c.watch_opts, WatchOpts::Bool(true));
+    let input = r#"
+    path: /hello.js
+    dir: "hello"
+    watch: false
+        "#;
+    let c: Route = serde_yaml::from_str(input).unwrap();
+    assert_eq!(c.watch_opts, WatchOpts::Bool(false));
+    let input = r#"
+    path: /hello.js
+    dir: "hello"
+    watch: "public/**/*.css"
+        "#;
+    let c: Route = serde_yaml::from_str(input).unwrap();
+    assert_eq!(
+        c.watch_opts,
+        WatchOpts::InlineGlob("public/**/*.css".into())
+    );
+    let input = r#"
+    path: /hello.js
+    dir: "hello"
+    watch:
+      debounce:
+        ms: 2000
+        "#;
+    let c: Route = serde_yaml::from_str(input).unwrap();
+    assert_eq!(
+        c.watch_opts,
+        WatchOpts::Spec(Spec {
+            opts: Some(SpecOpts {
+                debounce: Some(DebounceDuration::Ms(2000)),
+                filter: None,
+            })
+        })
+    );
+}
+
+#[test]
+fn test_deserialize_server_watch_list() {
+    let input = r#"
+servers:
+- bind_address: 0.0.0.0:4000
+  watchers:
+    - dir: ./
+    - dir: ./other
+      debounce_ms: 2000
+      filter:
+        ext: "**/*.css"
+"#;
+    let c: Input = serde_yaml::from_str(input).unwrap();
+    dbg!(&c);
+    assert_eq!(
+        c.servers.get(0).unwrap().watchers,
+        vec![
+            Watcher {
+                dir: "./".to_string(),
+                debounce_ms: None,
+                filter: None,
+            },
+            Watcher {
+                dir: "./other".to_string(),
+                debounce_ms: Some(2000),
+                filter: Some(FilterKind::Extension {
+                    ext: "**/*.css".to_string()
+                }),
+            }
+        ]
+    )
+}

package/crates/bsnext_input/src/lib.rs

@@ -0,0 +1,153 @@
+use crate::target::TargetKind;
+
+use std::fmt::{Display, Formatter};
+use std::fs;
+use std::fs::read_to_string;
+use std::net::AddrParseError;
+use std::path::{Path, PathBuf};
+
+#[cfg(test)]
+pub mod input_test;
+pub mod md;
+pub mod paths;
+pub mod route;
+pub mod route_manifest;
+pub mod server_config;
+pub mod target;
+#[cfg(test)]
+pub mod watch_opt_test;
+pub mod yml;
+
+#[derive(Debug, Default, serde::Deserialize, serde::Serialize)]
+pub struct Input {
+    pub servers: Vec<server_config::ServerConfig>,
+}
+
+impl Input {
+    pub fn from_input_path<P: AsRef<Path>>(path: P) -> Result<Self, anyhow::Error> {
+        match path.as_ref().extension().and_then(|x| x.to_str()) {
+            None => Err(anyhow::anyhow!(
+                "paths without extensions are not supported"
+            )),
+            Some("yml") | Some("yaml") => Input::from_yaml_path(path),
+            Some("md") | Some("markdown") => Input::from_md_path(path),
+            _ => Err(anyhow::anyhow!("unsupported extension")),
+        }
+    }
+    fn from_yaml_path<P: AsRef<Path>>(path: P) -> Result<Self, anyhow::Error> {
+        let str = read_to_string(path)?;
+        let output = serde_yaml::from_str::<Self>(str.as_str())?;
+        // todo: don't allow duplicates.
+        Ok(output)
+    }
+    fn from_md_path<P: AsRef<Path>>(path: P) -> Result<Self, anyhow::Error> {
+        let str = read_to_string(path)?;
+        let input = md::md_to_input(&str)?;
+        // todo: don't allow duplicates.
+        Ok(input)
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum InputError {
+    #[error("no suitable inputs could be found")]
+    MissingInputs,
+    #[error("could not read input, error: {0}")]
+    InvalidInput(String),
+    #[error("Could not find the input file: {0}")]
+    NotFound(PathBuf),
+    #[error("InputWriteError prevented startup {0}")]
+    InputWriteError(#[from] InputWriteError),
+    #[error("Input path error prevented startup {0}")]
+    PathError(#[from] PathError),
+    #[error("Input port error prevented startup {0}")]
+    PortError(#[from] PortError),
+    #[error("Input directory error prevented startup {0}")]
+    DirError(#[from] DirError),
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum WatchError {
+    #[error("don't add `.` before the extension.")]
+    InvalidExtensionFilter,
+    #[error("empty")]
+    EmptyExtensionFilter,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum InputWriteError {
+    #[error("couldn't write input to {path}")]
+    FailedWrite { path: PathBuf },
+}
+
+#[derive(Debug, thiserror::Error, serde::Serialize, serde::Deserialize)]
+pub enum PathError {
+    #[error("path(s) not found \n{paths}")]
+    MissingPaths { paths: PathDefs },
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error(transparent)]
+pub enum PortError {
+    #[error("could not use that port: {port} {err}")]
+    InvalidPort { port: u16, err: AddrParseError },
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error(transparent)]
+pub enum DirError {
+    #[error("could not create that dir: {path}")]
+    CannotCreate { path: PathBuf },
+    #[error("could not change the process CWD to: {path}")]
+    CannotMove { path: PathBuf },
+}
+
+#[derive(Debug, thiserror::Error, serde::Serialize, serde::Deserialize)]
+pub struct PathDefs(Vec<PathDefinition>);
+
+#[derive(Debug, thiserror::Error, serde::Serialize, serde::Deserialize)]
+struct PathDefinition {
+    pub input: String,
+    pub cwd: PathBuf,
+    pub absolute: PathBuf,
+}
+
+impl Display for PathDefs {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        for pd in self.0.iter() {
+            writeln!(f, "  cwd:   {}", pd.cwd.display())?;
+            writeln!(f, "  input: {}", pd.input)?;
+        }
+        Ok(())
+    }
+}
+impl Display for PathDefinition {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("PathDefinition").finish()
+    }
+}
+
+pub fn rand_word() -> String {
+    random_word::gen(random_word::Lang::En).to_string()
+}
+
+pub fn fs_write_input(
+    cwd: &Path,
+    input: &Input,
+    target_kind: TargetKind,
+) -> Result<PathBuf, InputWriteError> {
+    let string = match target_kind {
+        TargetKind::Yaml => serde_yaml::to_string(&input).expect("create yaml?"),
+        TargetKind::Toml => toml::to_string_pretty(&input).expect("create toml?"),
+        TargetKind::Md => md::input_to_str(input),
+    };
+    let name = match target_kind {
+        TargetKind::Yaml => "input.yml",
+        TargetKind::Toml => "input.toml",
+        TargetKind::Md => "input.md",
+    };
+    let next_path = cwd.join(name);
+    fs::write(&next_path, string)
+        .map(|()| next_path.clone())
+        .map_err(|_e| InputWriteError::FailedWrite { path: next_path })
+}