Rename particle/culars to tags

lib/examples/signal.rs

@@ -2,7 +2,7 @@ use std::process::exit;
 
 use tokio::sync::mpsc;
 use watchexec::{
-	event::{Event, Particle},
+	event::{Event, Tag},
 	signal::{self, Signal},
 };
 
@@ -21,7 +21,7 @@ async fn main() -> color_eyre::eyre::Result<()> {
 		while let Some(e) = ev_r.recv().await {
 			tracing::info!("event: {:?}", e);
 
-			if e.particulars.contains(&Particle::Signal(Signal::Terminate)) {
+			if e.tags.contains(&Tag::Signal(Signal::Terminate)) {
 				exit(0);
 			}
 		}

lib/src/command/supervisor.rs

@@ -17,7 +17,7 @@ use tracing::{debug, error, trace, warn};
 
 use crate::{
 	error::RuntimeError,
-	event::{Event, Particle, Source},
+	event::{Event, Tag, Source},
 };
 
 use super::Process;
@@ -120,9 +120,9 @@ impl Supervisor {
 				}
 				Ok(status) => {
 					let event = Event {
-						particulars: vec![
-							Particle::Source(Source::Internal),
-							Particle::ProcessCompletion(status),
+						tags: vec![
+							Tag::Source(Source::Internal),
+							Tag::ProcessCompletion(status),
 						],
 						metadata: Default::default(),
 					};

lib/src/event.rs

@@ -20,15 +20,14 @@ use crate::signal::Signal;
 /// An event, as far as watchexec cares about.
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub struct Event {
-	pub particulars: Vec<Particle>,
+	pub tags: Vec<Tag>,
 	pub metadata: HashMap<String, Vec<String>>,
 }
 
-// TODO: this really needs a better name (along with "particulars")
 /// Something which can be used to filter or qualify an event.
 #[derive(Clone, Debug, Eq, PartialEq)]
 #[non_exhaustive]
-pub enum Particle {
+pub enum Tag {
 	Path(PathBuf),
 	FileEventKind(EventKind),
 	Source(Source),
@@ -50,26 +49,26 @@ pub enum Source {
 }
 
 impl Event {
-	/// Return all paths in the event's particulars.
+	/// Return all paths in the event's tags.
 	pub fn paths(&self) -> impl Iterator<Item = &Path> {
-		self.particulars.iter().filter_map(|p| match p {
-			Particle::Path(p) => Some(p.as_path()),
+		self.tags.iter().filter_map(|p| match p {
+			Tag::Path(p) => Some(p.as_path()),
 			_ => None,
 		})
 	}
 
-	/// Return all signals in the event's particulars.
+	/// Return all signals in the event's tags.
 	pub fn signals(&self) -> impl Iterator<Item = Signal> + '_ {
-		self.particulars.iter().filter_map(|p| match p {
-			Particle::Signal(s) => Some(*s),
+		self.tags.iter().filter_map(|p| match p {
+			Tag::Signal(s) => Some(*s),
 			_ => None,
 		})
 	}
 
-	/// Return all process completions in the event's particulars.
+	/// Return all process completions in the event's tags.
 	pub fn completions(&self) -> impl Iterator<Item = Option<ExitStatus>> + '_ {
-		self.particulars.iter().filter_map(|p| match p {
-			Particle::ProcessCompletion(s) => Some(*s),
+		self.tags.iter().filter_map(|p| match p {
+			Tag::ProcessCompletion(s) => Some(*s),
 			_ => None,
 		})
 	}
@@ -78,15 +77,15 @@ impl Event {
 impl fmt::Display for Event {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		write!(f, "Event")?;
-		for p in &self.particulars {
+		for p in &self.tags {
 			match p {
-				Particle::Path(p) => write!(f, " path={}", p.display())?,
-				Particle::FileEventKind(kind) => write!(f, " kind={:?}", kind)?,
-				Particle::Source(s) => write!(f, " source={:?}", s)?,
-				Particle::Process(p) => write!(f, " process={}", p)?,
-				Particle::Signal(s) => write!(f, " signal={:?}", s)?,
-				Particle::ProcessCompletion(None) => write!(f, " command-completed")?,
-				Particle::ProcessCompletion(Some(c)) => write!(f, " command-completed({})", c)?,
+				Tag::Path(p) => write!(f, " path={}", p.display())?,
+				Tag::FileEventKind(kind) => write!(f, " kind={:?}", kind)?,
+				Tag::Source(s) => write!(f, " source={:?}", s)?,
+				Tag::Process(p) => write!(f, " process={}", p)?,
+				Tag::Signal(s) => write!(f, " signal={:?}", s)?,
+				Tag::ProcessCompletion(None) => write!(f, " command-completed")?,
+				Tag::ProcessCompletion(Some(c)) => write!(f, " command-completed({})", c)?,
 			}
 		}
 

lib/src/fs.rs

@@ -14,7 +14,7 @@ use tracing::{debug, error, trace};
 
 use crate::{
 	error::{CriticalError, RuntimeError},
-	event::{Event, Particle, Source},
+	event::{Event, Tag, Source},
 };
 
 /// What kind of filesystem watcher to use.
@@ -227,16 +227,16 @@ fn process_event(
 ) -> Result<(), RuntimeError> {
 	let nev = nev.map_err(|err| RuntimeError::FsWatcherEvent { kind, err })?;
 
-	let mut particulars = Vec::with_capacity(4);
-	particulars.push(Particle::Source(Source::Filesystem));
-	particulars.push(Particle::FileEventKind(nev.kind));
+	let mut tags = Vec::with_capacity(4);
+	tags.push(Tag::Source(Source::Filesystem));
+	tags.push(Tag::FileEventKind(nev.kind));
 
 	for path in nev.paths {
-		particulars.push(Particle::Path(dunce::canonicalize(path)?));
+		tags.push(Tag::Path(dunce::canonicalize(path)?));
 	}
 
 	if let Some(pid) = nev.attrs.process_id() {
-		particulars.push(Particle::Process(pid));
+		tags.push(Tag::Process(pid));
 	}
 
 	let mut metadata = HashMap::new();
@@ -250,7 +250,7 @@ fn process_event(
 	}
 
 	let ev = Event {
-		particulars,
+		tags,
 		metadata,
 	};
 

lib/src/signal.rs

@@ -5,7 +5,7 @@ use tracing::{debug, trace};
 
 use crate::{
 	error::{CriticalError, RuntimeError},
-	event::{Event, Particle, Source},
+	event::{Event, Tag, Source},
 };
 
 /// A notification sent to the main (watchexec) process.
@@ -167,17 +167,17 @@ async fn send_event(
 	events: mpsc::Sender<Event>,
 	sig: Signal,
 ) -> Result<(), CriticalError> {
-	let particulars = vec![
-		Particle::Source(if sig == Signal::Interrupt {
+	let tags = vec![
+		Tag::Source(if sig == Signal::Interrupt {
 			Source::Keyboard
 		} else {
 			Source::Os
 		}),
-		Particle::Signal(sig),
+		Tag::Signal(sig),
 	];
 
 	let event = Event {
-		particulars,
+		tags,
 		metadata: Default::default(),
 	};