@browsersync/bslive 0.0.14 → 0.0.16

package/crates/bsnext_input/src/paths.rs

@@ -1,64 +0,0 @@
-use crate::route::{DirRoute, Route, RouteKind};
-use crate::server_config::{Identity, ServerConfig};
-use crate::{Input, PathDefinition, PathDefs, PathError};
-use std::path::{Path, PathBuf};
-
-pub fn from_paths<T: AsRef<str>>(
-    cwd: &Path,
-    paths: &[T],
-    identity: Identity,
-) -> Result<Input, PathError> {
-    let path_defs = paths
-        .iter()
-        .map(|p| {
-            let pb = PathBuf::from(p.as_ref());
-            if pb.is_absolute() {
-                return PathDefinition {
-                    input: p.as_ref().to_string(),
-                    cwd: cwd.to_path_buf(),
-                    absolute: pb,
-                };
-            } else {
-                return PathDefinition {
-                    input: p.as_ref().to_string(),
-                    cwd: cwd.to_path_buf(),
-                    absolute: cwd.join(pb),
-                };
-            }
-        })
-        .map(|path_def| {
-            let exists = path_def.absolute.exists();
-            (path_def, exists)
-        })
-        .collect::<Vec<(PathDefinition, bool)>>();
-
-    let invalid = path_defs
-        .into_iter()
-        .filter_map(|(pb, exists)| if exists { None } else { Some(pb) })
-        .collect::<Vec<_>>();
-
-    if !invalid.is_empty() {
-        return Err(PathError::MissingPaths {
-            paths: PathDefs(invalid),
-        });
-    }
-
-    let server = ServerConfig {
-        identity,
-        routes: paths
-            .iter()
-            .map(|p| -> Route {
-                let str = p.as_ref();
-                Route {
-                    path: "/".to_string(),
-                    kind: RouteKind::Dir(DirRoute { dir: str.into() }),
-                    ..Default::default()
-                }
-            })
-            .collect(),
-        ..Default::default()
-    };
-    Ok(Input {
-        servers: vec![server],
-    })
-}

package/crates/bsnext_input/src/route.rs

@@ -1,189 +0,0 @@
-use std::collections::BTreeMap;
-use std::fmt::{Display, Formatter};
-use std::hash::{Hash, Hasher};
-use std::ops::Deref;
-
-use typeshare::typeshare;
-
-#[derive(Debug, PartialEq, Hash, Clone, serde::Deserialize, serde::Serialize)]
-pub struct Route {
-    pub path: String,
-    #[serde(flatten)]
-    pub cors_opts: Option<CorsOpts>,
-    #[serde(flatten)]
-    pub delay_opts: Option<DelayOpts>,
-    #[serde(rename = "watch")]
-    #[serde(default)]
-    pub watch_opts: WatchOpts,
-    #[serde(flatten)]
-    pub kind: RouteKind,
-    pub headers: Option<BTreeMap<String, String>>,
-}
-
-impl Default for Route {
-    fn default() -> Self {
-        Self {
-            path: "/".to_string(),
-            kind: RouteKind::Html {
-                html: "default".into(),
-            },
-            delay_opts: None,
-            cors_opts: None,
-            watch_opts: Default::default(),
-            headers: None,
-        }
-    }
-}
-
-impl AsRef<Route> for Route {
-    fn as_ref(&self) -> &Route {
-        self
-    }
-}
-
-impl Route {
-    pub fn path(&self) -> &str {
-        self.path.as_str()
-    }
-}
-
-#[derive(Debug, Hash, PartialEq, Clone, serde::Deserialize, serde::Serialize)]
-#[serde(untagged)]
-pub enum RouteKind {
-    Html { html: String },
-    Json { json: JsonWrapper },
-    Raw { raw: String },
-    Sse { sse: String },
-    Proxy(ProxyRoute),
-    Dir(DirRoute),
-}
-
-#[derive(Debug, PartialEq, Clone, serde::Deserialize, serde::Serialize)]
-pub struct JsonWrapper(serde_json::Value);
-
-impl Display for JsonWrapper {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", serde_json::to_string(&self.0).expect("serde_json"))
-    }
-}
-
-impl Deref for JsonWrapper {
-    type Target = serde_json::Value;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl Hash for JsonWrapper {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        //todo: implement hashing for serde_value
-        if let Ok(as_str) = serde_json::to_string(&self.0) {
-            state.write(as_str.as_bytes());
-        } else {
-            todo!("handle error here?")
-        }
-    }
-}
-
-#[typeshare]
-impl RouteKind {
-    #[allow(dead_code)]
-    pub fn html(s: &str) -> Self {
-        Self::Html { html: s.into() }
-    }
-}
-
-#[derive(Debug, PartialEq, Hash, Clone, serde::Deserialize, serde::Serialize)]
-pub struct DirRoute {
-    pub dir: String,
-}
-
-#[derive(Debug, PartialEq, Hash, Clone, serde::Deserialize, serde::Serialize)]
-pub struct ProxyRoute {
-    pub proxy: String,
-}
-
-#[derive(Debug, PartialEq, Hash, Clone, serde::Deserialize, serde::Serialize)]
-pub enum CorsOpts {
-    #[serde(rename = "cors")]
-    Cors(bool),
-}
-
-#[derive(Debug, PartialEq, Hash, Clone, serde::Deserialize, serde::Serialize)]
-pub enum DelayOpts {
-    #[serde(rename = "delay")]
-    Delay(DelayKind),
-}
-
-#[derive(
-    Debug, Ord, PartialOrd, PartialEq, Eq, Hash, Clone, serde::Deserialize, serde::Serialize,
-)]
-pub enum DelayKind {
-    #[serde(rename = "ms")]
-    Ms(u64),
-}
-
-#[derive(
-    Debug, Ord, PartialOrd, PartialEq, Eq, Hash, Clone, serde::Deserialize, serde::Serialize,
-)]
-pub enum DebounceDuration {
-    #[serde(rename = "ms")]
-    Ms(u64),
-}
-
-#[derive(
-    Debug, Ord, PartialOrd, PartialEq, Eq, Hash, Clone, serde::Deserialize, serde::Serialize,
-)]
-#[serde(untagged)]
-pub enum FilterKind {
-    StringGlob(String),
-    Extension { ext: String },
-    Glob { glob: String },
-    List(Vec<FilterKind>),
-}
-
-#[derive(
-    Debug, Ord, PartialOrd, PartialEq, Eq, Hash, Clone, serde::Deserialize, serde::Serialize,
-)]
-pub struct Spec {
-    #[serde(flatten)]
-    pub opts: Option<SpecOpts>,
-}
-
-#[derive(
-    Debug, Ord, PartialOrd, PartialEq, Eq, Hash, Clone, serde::Deserialize, serde::Serialize,
-)]
-pub struct SpecOpts {
-    pub debounce: Option<DebounceDuration>,
-    pub filter: Option<FilterKind>,
-}
-
-#[derive(Debug, PartialEq, Hash, Clone, serde::Deserialize, serde::Serialize)]
-#[serde(untagged)]
-pub enum WatchOpts {
-    Bool(bool),
-    InlineGlob(String),
-    Spec(Spec),
-}
-
-impl Default for WatchOpts {
-    fn default() -> Self {
-        Self::Bool(true)
-    }
-}
-
-impl WatchOpts {
-    pub fn is_enabled(&self) -> bool {
-        !matches!(self, WatchOpts::Bool(false))
-    }
-}
-
-#[derive(
-    Debug, PartialOrd, Ord, Eq, PartialEq, Hash, Clone, serde::Deserialize, serde::Serialize,
-)]
-pub struct Watcher {
-    pub dir: String,
-    pub debounce_ms: Option<u64>,
-    pub filter: Option<FilterKind>,
-}

package/crates/bsnext_input/src/route_manifest.rs

@@ -1,186 +0,0 @@
-use crate::route::{Route, RouteKind};
-use std::collections::{HashMap, HashSet};
-use std::hash::{DefaultHasher, Hash, Hasher};
-
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub struct RoutesManifest {
-    inner: HashMap<RouteIdentity, u64>,
-}
-
-impl RoutesManifest {
-    pub fn changeset_for(&self, other: &Self) -> RouteChangeSet {
-        let prev = self.inner.keys().collect::<HashSet<_>>();
-        let next = other.inner.keys().collect::<HashSet<_>>();
-        let changed_only = prev
-            .intersection(&next)
-            .filter_map(|id| {
-                let old = self.inner.get(*id);
-                let new = other.inner.get(*id);
-                match (old, new) {
-                    (Some(old), Some(new)) if old != new => Some((*id).to_owned()),
-                    _ => None,
-                }
-            })
-            .collect::<Vec<_>>();
-        RouteChangeSet {
-            added: next.difference(&prev).map(|x| (*x).to_owned()).collect(),
-            removed: prev.difference(&next).map(|x| (*x).to_owned()).collect(),
-            changed: changed_only,
-        }
-    }
-    pub fn new<A: AsRef<Route>>(routes: &[A]) -> Self {
-        Self {
-            inner: routes
-                .iter()
-                .map(|a| {
-                    let route = a.as_ref();
-                    let mut hasher = DefaultHasher::new();
-                    route.hash(&mut hasher);
-                    let r2_hash = hasher.finish();
-                    let id: RouteIdentity = a.as_ref().into();
-                    (id, r2_hash)
-                })
-                .collect::<HashMap<RouteIdentity, u64>>(),
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, Hash, Eq, Clone)]
-pub struct RouteIdentity {
-    pub path: String,
-    pub kind_str: String,
-}
-
-impl From<&Route> for RouteIdentity {
-    fn from(value: &Route) -> Self {
-        Self {
-            path: value.path.clone(),
-            kind_str: match value.kind {
-                RouteKind::Html { .. } => "RouteKind::Html",
-                RouteKind::Json { .. } => "RouteKind::Json",
-                RouteKind::Raw { .. } => "RouteKind::Raw",
-                RouteKind::Sse { .. } => "RouteKind::Sse",
-                RouteKind::Proxy(_) => "RouteKind::Proxy",
-                RouteKind::Dir(_) => "RouteKind::Dir",
-            }
-            .to_string(),
-        }
-    }
-}
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub struct RouteChangeSet {
-    pub added: Vec<RouteIdentity>,
-    pub removed: Vec<RouteIdentity>,
-    pub changed: Vec<RouteIdentity>,
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    use std::hash::DefaultHasher;
-    #[test]
-    fn test_route_hash() -> anyhow::Result<()> {
-        let r1 = Route {
-            path: "/".to_string(),
-            kind: RouteKind::Html {
-                html: String::from("hello world!"),
-            },
-            ..Default::default()
-        };
-        let r2 = r#"
-path: /
-html: hello world!
-        "#;
-        let r2: Route = serde_yaml::from_str(&r2).expect("test");
-
-        let mut hasher = DefaultHasher::new();
-        r1.hash(&mut hasher);
-        let r1_hash = hasher.finish();
-
-        let mut hasher = DefaultHasher::new();
-        r2.hash(&mut hasher);
-        let r2_hash = hasher.finish();
-
-        assert_eq!(r1_hash, r2_hash);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_route_hash_2() -> anyhow::Result<()> {
-        let r1 = r#"
-path: /
-html: hello world!
-        "#;
-        let r2 = r#"
-path: /api
-html: hello world!
-        "#;
-        let r2_edited = r#"
-path: /api
-html: hello world
-        "#;
-
-        let r1: Route = serde_yaml::from_str(&r1).expect("test");
-        let r2: Route = serde_yaml::from_str(&r2).expect("test");
-        let r2_edited: Route = serde_yaml::from_str(&r2_edited).expect("test");
-
-        let routes_orig = RoutesManifest::new(&[&r1, &r2]);
-        let routes_next = RoutesManifest::new(&[&r1]);
-        let routes_next_dup = RoutesManifest::new(&[&r1, &r2]);
-        let routes_next_3 = RoutesManifest::new(&[&r1, &r2_edited]);
-
-        let changeset_1 = routes_orig.changeset_for(&routes_next);
-        let changeset_2 = routes_orig.changeset_for(&routes_next_dup);
-        let changeset_3 = routes_orig.changeset_for(&routes_next_3);
-
-        assert_eq!(
-            changeset_1,
-            RouteChangeSet {
-                added: vec![],
-                removed: vec![RouteIdentity {
-                    path: "/api".to_string(),
-                    kind_str: "RouteKind::Html".to_string()
-                }],
-                changed: vec![],
-            }
-        );
-
-        assert_eq!(
-            changeset_1,
-            RouteChangeSet {
-                added: vec![],
-                removed: vec![RouteIdentity {
-                    path: "/api".to_string(),
-                    kind_str: "RouteKind::Html".to_string()
-                }],
-                changed: vec![],
-            }
-        );
-
-        // dbg!(changeset_1);
-        assert_eq!(
-            changeset_2,
-            RouteChangeSet {
-                added: vec![],
-                removed: vec![],
-                changed: vec![],
-            }
-        );
-
-        assert_eq!(
-            changeset_3,
-            RouteChangeSet {
-                added: vec![],
-                removed: vec![],
-                changed: vec![RouteIdentity {
-                    path: "/api".to_string(),
-                    kind_str: "RouteKind::Html".to_string()
-                }],
-            }
-        );
-
-        Ok(())
-    }
-}

package/crates/bsnext_input/src/server_config.rs

@@ -1,88 +0,0 @@
-use crate::route::{Route, Watcher};
-use crate::{rand_word, PortError};
-use std::hash::{DefaultHasher, Hash, Hasher};
-use std::net::SocketAddr;
-use std::str::FromStr;
-
-#[derive(Debug, Default, Clone, serde::Deserialize, serde::Serialize)]
-pub struct ServerConfig {
-    #[serde(flatten)]
-    pub identity: Identity,
-    #[serde(default)]
-    pub routes: Vec<Route>,
-    #[serde(default)]
-    pub watchers: Vec<Watcher>,
-}
-
-#[derive(
-    Debug, Ord, PartialOrd, PartialEq, Hash, Eq, Clone, serde::Deserialize, serde::Serialize,
-)]
-#[serde(untagged)]
-pub enum Identity {
-    Both { name: String, bind_address: String },
-    Address { bind_address: String },
-    Named { name: String },
-}
-
-impl Default for Identity {
-    fn default() -> Self {
-        Self::named()
-    }
-}
-
-impl Identity {
-    pub fn named() -> Self {
-        Self::Named { name: rand_word() }
-    }
-    pub fn address<A: AsRef<str>>(a: A) -> Self {
-        Self::Address {
-            bind_address: a.as_ref().to_string(),
-        }
-    }
-    /// if a port was provided, try to use it by validating it first
-    /// otherwise default to a named identity
-    pub fn from_port_or_named(port: Option<u16>) -> Result<Self, PortError> {
-        let result = port.map(|port| {
-            SocketAddr::from_str(&format!("0.0.0.0:{port}"))
-                .map_err(|err| PortError::InvalidPort { port, err })
-        });
-        match result {
-            None => Ok(Identity::named()),
-            Some(Ok(addr)) => Ok(Identity::address(addr.to_string())),
-            Some(Err(err)) => Err(err),
-        }
-    }
-
-    pub fn as_id(&self) -> u64 {
-        let mut hasher = DefaultHasher::new();
-        self.hash(&mut hasher);
-        hasher.finish()
-    }
-}
-
-#[test]
-fn server_config_as_enum() {
-    #[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
-    struct C {
-        servers: Vec<ServerConfig>,
-    }
-    let input = r#"
-servers:
-    - bind_address: 127.0.0.1:3000
-    - name: server_1
-    - name: server_2
-      bind_address: 127.0.0.1:3001
-      routes:
-        - path: /
-          dir: .
-    "#;
-    let c: C = serde_yaml::from_str(input).unwrap();
-
-    // let baseline = ServerConfigInput::Named { name: "server_1".into() };
-    let baseline = Identity::Address {
-        bind_address: "127.0.0.1x:3000".into(),
-    };
-    for x in &c.servers {
-        assert_eq!(x.identity == baseline, false);
-    }
-}

package/crates/bsnext_input/src/target.rs

@@ -1,7 +0,0 @@
-#[derive(Debug, Clone, Default, clap::ValueEnum)]
-pub enum TargetKind {
-    #[default]
-    Yaml,
-    Toml,
-    Md,
-}

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

@@ -1,68 +0,0 @@
-use crate::route::{DebounceDuration, FilterKind, Spec, SpecOpts, WatchOpts};
-
-#[test]
-fn test_watch_opts_debounce() {
-    let input = r#"
-    debounce:
-      ms: 200
-    filter: "**/*.css"
-    "#;
-    let expected = WatchOpts::Spec(Spec {
-        opts: Some(SpecOpts {
-            debounce: Some(DebounceDuration::Ms(200)),
-            filter: Some(FilterKind::StringGlob("**/*.css".into())),
-        }),
-    });
-    let actual: WatchOpts = serde_yaml::from_str(input).unwrap();
-    assert_eq!(actual, expected);
-}
-
-#[test]
-fn test_watch_opts_inline_filter() {
-    let input = r#"
-    filter: "**/*.css"
-    "#;
-    let expected = WatchOpts::Spec(Spec {
-        opts: Some(SpecOpts {
-            debounce: None,
-            filter: Some(FilterKind::StringGlob("**/*.css".into())),
-        }),
-    });
-    let actual: WatchOpts = serde_yaml::from_str(input).unwrap();
-    assert_eq!(actual, expected);
-}
-
-#[test]
-fn test_watch_opts_explicit_filter_ext() {
-    let input = r#"
-    filter:
-      ext: "css"
-    "#;
-    let expected = WatchOpts::Spec(Spec {
-        opts: Some(SpecOpts {
-            debounce: None,
-            filter: Some(FilterKind::Extension {
-                ext: "css".to_string(),
-            }),
-        }),
-    });
-    let actual: WatchOpts = serde_yaml::from_str(input).unwrap();
-    assert_eq!(actual, expected);
-}
-#[test]
-fn test_watch_opts_explicit_filter_glob() {
-    let input = r#"
-    filter:
-      glob: "**/*.css"
-    "#;
-    let expected = WatchOpts::Spec(Spec {
-        opts: Some(SpecOpts {
-            debounce: None,
-            filter: Some(FilterKind::Glob {
-                glob: "**/*.css".into(),
-            }),
-        }),
-    });
-    let actual: WatchOpts = serde_yaml::from_str(input).unwrap();
-    assert_eq!(actual, expected);
-}

package/crates/bsnext_input/src/yml.rs

@@ -1 +0,0 @@
-

package/crates/bsnext_output/Cargo.toml

@@ -1,16 +0,0 @@
-[package]
-name = "bsnext_output"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-bsnext_core = { path = "../bsnext_core" }
-
-ansi_term = { version = "0.12.1" }
-
-anyhow = { workspace = true }
-clap = { workspace = true }
-serde = { workspace = true }
-serde_json = { workspace = true }

package/crates/bsnext_output/src/json.rs

@@ -1,11 +0,0 @@
-use crate::OutputWriter;
-use bsnext_core::dto::ExternalEvents;
-use std::io::Write;
-
-pub struct JsonPrint;
-
-impl OutputWriter for JsonPrint {
-    fn handle_event<W: Write>(&self, sink: &mut W, evt: &ExternalEvents) -> anyhow::Result<()> {
-        write!(sink, "{}", serde_json::to_string(&evt)?).map_err(|e| anyhow::anyhow!(e.to_string()))
-    }
-}

package/crates/bsnext_output/src/lib.rs

@@ -1,25 +0,0 @@
-use crate::json::JsonPrint;
-use crate::pretty::PrettyPrint;
-use bsnext_core::dto::ExternalEvents;
-use std::io::Write;
-
-pub mod json;
-pub mod pretty;
-
-pub trait OutputWriter {
-    fn handle_event<W: Write>(&self, sink: &mut W, evt: &ExternalEvents) -> anyhow::Result<()>;
-}
-
-pub enum Writers {
-    Pretty,
-    Json,
-}
-
-impl OutputWriter for Writers {
-    fn handle_event<W: Write>(&self, sink: &mut W, evt: &ExternalEvents) -> anyhow::Result<()> {
-        match self {
-            Writers::Pretty => PrettyPrint.handle_event(sink, evt),
-            Writers::Json => JsonPrint.handle_event(sink, evt),
-        }
-    }
-}