Refactor parcel config (#9766)

crates/parcel_config/src/config_error.rs

@@ -6,12 +6,6 @@ use thiserror::Error;
 pub enum ConfigError {
  #[error("{0}")]
  InvalidConfig(String),
- #[error("No {phase} found for {path} with pipeline {pipeline:?}")]
- MissingPlugin {
- path: PathBuf,
- phase: String,
- pipeline: Option<String>,
- },
  #[error("Unable to locate .parcelrc from {0}")]
  MissingParcelRc(PathBuf),
  #[error("Failed to parse {path}")]

crates/parcel_config/src/lib.rs

@@ -1,11 +1,10 @@
 pub mod config_error;
+pub mod map;
 pub mod parcel_config;
-#[cfg(test)]
-mod parcel_config_fixtures;
+pub mod parcel_config_fixtures;
 pub mod parcel_rc;
 pub mod parcel_rc_config_loader;
 mod partial_parcel_config;
-pub mod pipeline;
 
 pub use parcel_config::ParcelConfig;
 pub use parcel_config::PluginNode;

crates/parcel_config/src/map.rs

@@ -0,0 +1,11 @@
+mod matcher;
+use matcher::*;
+
+mod named_pipelines_map;
+pub use named_pipelines_map::*;
+
+mod pipeline_map;
+pub use pipeline_map::*;
+
+mod pipelines_map;
+pub use pipelines_map::*;

crates/parcel_config/src/map/matcher.rs

@@ -0,0 +1,111 @@
+use std::path::Path;
+
+use glob_match::glob_match;
+
+pub fn named_pattern_matcher<'a>(path: &'a Path) -> impl Fn(&str, &str) -> bool + 'a {
+ let basename = path.file_name().unwrap().to_str().unwrap();
+ let path = path.as_os_str().to_str().unwrap();
+
+ |pattern, pipeline| {
+ let (named_pipeline, pattern) = pattern.split_once(':').unwrap_or(("", pattern));
+ pipeline == named_pipeline && (glob_match(pattern, basename) || glob_match(pattern, path))
+ }
+}
+
+pub fn pattern_matcher<'a>(path: &'a Path) -> impl Fn(&str) -> bool + 'a {
+ let is_match = named_pattern_matcher(path);
+
+ move |pattern| is_match(pattern, "")
+}
+
+#[cfg(test)]
+mod tests {
+ use std::env;
+ use std::path::PathBuf;
+
+ use super::*;
+
+ fn paths(filename: &str) -> Vec<PathBuf> {
+ let cwd = env::current_dir().unwrap();
+ vec![
+ PathBuf::from(filename),
+ cwd.join(filename),
+ cwd.join("src").join(filename),
+ ]
+ }
+
+ mod named_pattern_matcher {
+ use super::*;
+
+ #[test]
+ fn returns_false_when_path_does_not_match_pattern_with_empty_pipeline() {
+ for path in paths("a.ts") {
+ let is_match = named_pattern_matcher(&path);
+
+ assert_eq!(is_match("*.t", ""), false);
+ assert_eq!(is_match("*.tsx", ""), false);
+ assert_eq!(is_match("types:*.{ts,tsx}", ""), false);
+ assert_eq!(is_match("url:*", ""), false);
+ }
+ }
+
+ #[test]
+ fn returns_false_when_path_does_not_match_pipeline() {
+ for path in paths("a.ts") {
+ let is_match = named_pattern_matcher(&path);
+
+ assert_eq!(is_match("types:*.{ts,tsx}", "type"), false);
+ assert_eq!(is_match("types:*.{ts,tsx}", "typesa"), false);
+ }
+ }
+
+ #[test]
+ fn returns_true_when_path_matches_pattern_with_empty_pipeline() {
+ for path in paths("a.ts") {
+ let is_match = named_pattern_matcher(&path);
+
+ assert_eq!(is_match("*.{ts,tsx}", ""), true);
+ assert_eq!(is_match("*.ts", ""), true);
+ assert_eq!(is_match("*", ""), true);
+ }
+ }
+
+ #[test]
+ fn returns_true_when_path_matches_pattern_and_pipeline() {
+ for path in paths("a.ts") {
+ let is_match = named_pattern_matcher(&path);
+
+ assert_eq!(is_match("types:*.{ts,tsx}", "types"), true);
+ assert_eq!(is_match("types:*.ts", "types"), true);
+ assert_eq!(is_match("types:*", "types"), true);
+ }
+ }
+ }
+
+ mod pattern_matcher {
+ use super::*;
+
+ #[test]
+ fn returns_false_when_path_does_not_match_pattern() {
+ for path in paths("a.ts") {
+ let is_match = pattern_matcher(&path);
+
+ assert_eq!(is_match("*.t"), false);
+ assert_eq!(is_match("*.tsx"), false);
+ assert_eq!(is_match("types:*.{ts,tsx}"), false);
+ assert_eq!(is_match("url:*"), false);
+ }
+ }
+
+ #[test]
+ fn returns_true_when_path_matches_pattern_with_empty_pipeline() {
+ for path in paths("a.ts") {
+ let is_match = pattern_matcher(&path);
+
+ assert_eq!(is_match("*.{ts,tsx}"), true);
+ assert_eq!(is_match("*.ts"), true);
+ assert_eq!(is_match("*"), true);
+ }
+ }
+ }
+}