Merge pull request #1038 from CraftSpider/update-deps-minimal

pkgw · web-flow · commit ec275c68e4ad · 2023-05-16T08:43:07.000-04:00
Update non-watchexec deps
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -63,11 +63,11 @@ flate2 = { version = "^1.0.19", default-features = false, features = ["zlib"] }
 fs2 = "^0.4"
 lazy_static = "^1.4"
 libc = "^0.2"
-md-5 = "^0.9"
-open = "1.4.0"
-quick-xml = "^0.22"
+md-5 = "^0.10"
+open = "^4.0"
+quick-xml = "^0.28"
 serde = { version = "^1.0", features = ["derive"], optional = true }
-sha2 = "^0.9"
+sha2 = "^0.10"
 structopt = "0.3"
 tectonic_bridge_core = { path = "crates/bridge_core", version = "0.0.0-dev.0" }
 tectonic_bundles = { path = "crates/bundles", version = "0.0.0-dev.0", default-features = false }
@@ -84,10 +84,10 @@ tectonic_xdv = { path = "crates/xdv", version = "0.0.0-dev.0" }
 tectonic_xetex_layout = { path = "crates/xetex_layout", version = "0.0.0-dev.0" }
 tempfile = "^3.1"
 termcolor = "^1.1"
-toml = { version = "^0.5", optional = true }
+toml = { version = "^0.7", optional = true }
 url = "^2.0"
 watchexec = "^1.15.3"
-zip = { version = "^0.5", default-features = false, features = ["deflate"] }
+zip = { version = "^0.6", default-features = false, features = ["deflate"] }
 
 [features]
 default = ["geturl-reqwest", "serialization"]
diff --git a/crates/bridge_core/Cargo.toml b/crates/bridge_core/Cargo.toml
@@ -22,7 +22,7 @@ links = "tectonic_bridge_core"
 flate2 = { version = "^1.0", default-features = false, features = ["zlib"] }
 lazy_static = "^1.4"
 libc = "^0.2"
-md-5 = "^0.9"
+md-5 = "^0.10"
 tectonic_errors = { path = "../errors", version = "0.0.0-dev.0" }
 tectonic_io_base = { path = "../io_base", version = "0.0.0-dev.0" }
 tectonic_status_base = { path = "../status_base", version = "0.0.0-dev.0" }
diff --git a/crates/bundles/Cargo.toml b/crates/bundles/Cargo.toml
@@ -24,7 +24,7 @@ tectonic_errors = { path = "../errors", version = "0.0.0-dev.0" }
 tectonic_geturl = { path = "../geturl", version = "0.0.0-dev.0", default-features = false }
 tectonic_io_base = { path = "../io_base", version = "0.0.0-dev.0" }
 tectonic_status_base = { path = "../status_base", version = "0.0.0-dev.0" }
-zip = { version = "^0.5", default-features = false, features = ["deflate"] }
+zip = { version = "^0.6", default-features = false, features = ["deflate"] }
 
 [features]
 default = ["geturl-reqwest"]
diff --git a/crates/docmodel/Cargo.toml b/crates/docmodel/Cargo.toml
@@ -20,7 +20,7 @@ edition = "2018"
 [dependencies]
 serde = { version = "^1.0", features = ["derive"] }
 tectonic_errors = { path = "../errors", version = "0.0.0-dev.0" }
-toml = { version = "^0.5" }
+toml = { version = "^0.7" }
 
 [package.metadata.internal_dep_versions]
 tectonic_errors = "5c9ba661edf5ef669f24f9904f99cca369d999e7"
diff --git a/crates/io_base/Cargo.toml b/crates/io_base/Cargo.toml
@@ -19,7 +19,7 @@ edition = "2018"
 app_dirs2 = "^2.3"
 flate2 = { version = "^1.0.19", default-features = false, features = ["zlib"] }
 libc = "^0.2" # for EISDIR :-(
-sha2 = "^0.9" # for digest computations
+sha2 = "^0.10" # for digest computations
 thiserror = "1.0"
 tectonic_errors = { path = "../errors", version = "0.0.0-dev.0" }
 tectonic_status_base = { path = "../status_base", version = "0.0.0-dev.0" }
diff --git a/src/config.rs b/src/config.rs
@@ -80,9 +80,9 @@ impl PersistentConfig {
 
         let config = match File::open(&cfg_path) {
             Ok(mut f) => {
-                let mut buf = Vec::<u8>::new();
-                f.read_to_end(&mut buf)?;
-                toml::from_slice(&buf)?
+                let mut buf = String::new();
+                f.read_to_string(&mut buf)?;
+                toml::from_str(&buf)?
             }
             Err(e) => {
                 if e.kind() == IoErrorKind::NotFound {
diff --git a/src/driver.rs b/src/driver.rs
@@ -16,7 +16,7 @@
 //! which contains tectonic's main CLI program.
 
 use byte_unit::Byte;
-use quick_xml::{events::Event, Reader};
+use quick_xml::{events::Event, NsReader};
 use std::{
     collections::{HashMap, HashSet},
     fs::File,
@@ -2053,13 +2053,13 @@ impl ProcessingSession {
         }
 
         let curs = Cursor::new(&run_xml_entry.data[..]);
-        let mut reader = Reader::from_reader(curs);
+        let mut reader = NsReader::from_reader(curs);
         let mut buf = Vec::new();
         let mut state = State::Searching;
 
         loop {
             let event = ctry!(
-                reader.read_event(&mut buf);
+                reader.read_event_into(&mut buf);
                 "error parsing run.xml file"
             );
 
@@ -2069,15 +2069,15 @@ impl ProcessingSession {
 
             match (state, event) {
                 (State::Searching, Event::Start(ref e)) => {
-                    let name = reader.decode(e.local_name())?;
+                    let name = reader.decoder().decode(e.local_name().into_inner())?;
 
                     if name == "binary" {
                         state = State::InBinaryName;
                     }
                 }
 
                 (State::InBinaryName, Event::Text(ref e)) => {
-                    let text = e.unescape_and_decode(&reader)?;
+                    let text = e.unescape()?;
 
                     state = if &text == "biber" {
                         State::InBiberCmdline
@@ -2091,65 +2091,65 @@ impl ProcessingSession {
                 }
 
                 (State::InBiberCmdline, Event::Start(ref e)) => {
-                    let name = reader.decode(e.local_name())?;
+                    let name = reader.decoder().decode(e.local_name().into_inner())?;
 
                     // Note that the "infile" might be `foo` without the `.bcf`
                     // extension, so we can't use it for file-finding.
-                    state = match name {
+                    state = match &*name {
                         "infile" | "outfile" | "option" => State::InBiberArgument,
                         _ => State::InBiberRemainder,
                     }
                 }
 
                 (State::InBiberCmdline, Event::End(ref e)) => {
-                    let name = reader.decode(e.local_name())?;
+                    let name = reader.decoder().decode(e.local_name().into_inner())?;
 
                     if name == "cmdline" {
                         state = State::InBiberRemainder;
                     }
                 }
 
                 (State::InBiberArgument, Event::Text(ref e)) => {
-                    argv.push(e.unescape_and_decode(&reader)?);
+                    argv.push(e.unescape()?.to_string());
                     state = State::InBiberCmdline;
                 }
 
                 (State::InBiberRemainder, Event::Start(ref e)) => {
-                    let name = reader.decode(e.local_name())?;
+                    let name = reader.decoder().decode(e.local_name().into_inner())?;
 
-                    state = match name {
+                    state = match &*name {
                         "input" | "requires" => State::InBiberRequirementSection,
                         _ => State::InBiberRemainder,
                     }
                 }
 
                 (State::InBiberRemainder, Event::End(ref e)) => {
-                    let name = reader.decode(e.local_name())?;
+                    let name = reader.decoder().decode(e.local_name().into_inner())?;
 
                     if name == "external" {
                         break;
                     }
                 }
 
                 (State::InBiberRequirementSection, Event::Start(ref e)) => {
-                    let name = reader.decode(e.local_name())?;
+                    let name = reader.decoder().decode(e.local_name().into_inner())?;
 
-                    state = match name {
+                    state = match &*name {
                         "file" => State::InBiberFileRequirement,
                         _ => State::InBiberRemainder,
                     }
                 }
 
                 (State::InBiberRequirementSection, Event::End(ref e)) => {
-                    let name = reader.decode(e.local_name())?;
+                    let name = reader.decoder().decode(e.local_name().into_inner())?;
 
                     if name == "input" || name == "requires" {
                         state = State::InBiberRemainder;
                     }
                 }
 
                 (State::InBiberFileRequirement, Event::Text(ref e)) => {
-                    extra_requires.insert(e.unescape_and_decode(&reader)?);
+                    extra_requires.insert(e.unescape()?.to_string());
                     state = State::InBiberRequirementSection;
                 }
 

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@`
`16`	`16`	`//! which contains tectonic's main CLI program.`
`17`	`17`
`18`	`18`	`use byte_unit::Byte;`
`19`		`-use quick_xml::{events::Event, Reader};`
	`19`	`+use quick_xml::{events::Event, NsReader};`
`20`	`20`	`use std::{`
`21`	`21`	`collections::{HashMap, HashSet},`
`22`	`22`	`fs::File,`
`@@ -2053,13 +2053,13 @@ impl ProcessingSession {`
`2053`	`2053`	`}`
`2054`	`2054`
`2055`	`2055`	`let curs = Cursor::new(&run_xml_entry.data[..]);`
`2056`		`- let mut reader = Reader::from_reader(curs);`
	`2056`	`+ let mut reader = NsReader::from_reader(curs);`
`2057`	`2057`	`let mut buf = Vec::new();`
`2058`	`2058`	`let mut state = State::Searching;`
`2059`	`2059`
`2060`	`2060`	`loop {`
`2061`	`2061`	`let event = ctry!(`
`2062`		`- reader.read_event(&mut buf);`
	`2062`	`+ reader.read_event_into(&mut buf);`
`2063`	`2063`	`"error parsing run.xml file"`
`2064`	`2064`	`);`
`2065`	`2065`
`@@ -2069,15 +2069,15 @@ impl ProcessingSession {`
`2069`	`2069`
`2070`	`2070`	`match (state, event) {`
`2071`	`2071`	`(State::Searching, Event::Start(ref e)) => {`
`2072`		`- let name = reader.decode(e.local_name())?;`
	`2072`	`+ let name = reader.decoder().decode(e.local_name().into_inner())?;`
`2073`	`2073`
`2074`	`2074`	`if name == "binary" {`
`2075`	`2075`	`state = State::InBinaryName;`
`2076`	`2076`	`}`
`2077`	`2077`	`}`
`2078`	`2078`
`2079`	`2079`	`(State::InBinaryName, Event::Text(ref e)) => {`
`2080`		`- let text = e.unescape_and_decode(&reader)?;`
	`2080`	`+ let text = e.unescape()?;`
`2081`	`2081`
`2082`	`2082`	`state = if &text == "biber" {`
`2083`	`2083`	`State::InBiberCmdline`
`@@ -2091,65 +2091,65 @@ impl ProcessingSession {`
`2091`	`2091`	`}`
`2092`	`2092`
`2093`	`2093`	`(State::InBiberCmdline, Event::Start(ref e)) => {`
`2094`		`- let name = reader.decode(e.local_name())?;`
	`2094`	`+ let name = reader.decoder().decode(e.local_name().into_inner())?;`
`2095`	`2095`
`2096`	`2096`	// Note that the "infile" might be `foo` without the `.bcf`
`2097`	`2097`	`// extension, so we can't use it for file-finding.`
`2098`		`- state = match name {`
	`2098`	`+ state = match &*name {`
`2099`	`2099`	`"infile" \| "outfile" \| "option" => State::InBiberArgument,`
`2100`	`2100`	`_ => State::InBiberRemainder,`
`2101`	`2101`	`}`
`2102`	`2102`	`}`
`2103`	`2103`
`2104`	`2104`	`(State::InBiberCmdline, Event::End(ref e)) => {`
`2105`		`- let name = reader.decode(e.local_name())?;`
	`2105`	`+ let name = reader.decoder().decode(e.local_name().into_inner())?;`
`2106`	`2106`
`2107`	`2107`	`if name == "cmdline" {`
`2108`	`2108`	`state = State::InBiberRemainder;`
`2109`	`2109`	`}`
`2110`	`2110`	`}`
`2111`	`2111`
`2112`	`2112`	`(State::InBiberArgument, Event::Text(ref e)) => {`
`2113`		`- argv.push(e.unescape_and_decode(&reader)?);`
	`2113`	`+ argv.push(e.unescape()?.to_string());`
`2114`	`2114`	`state = State::InBiberCmdline;`
`2115`	`2115`	`}`
`2116`	`2116`
`2117`	`2117`	`(State::InBiberRemainder, Event::Start(ref e)) => {`
`2118`		`- let name = reader.decode(e.local_name())?;`
	`2118`	`+ let name = reader.decoder().decode(e.local_name().into_inner())?;`
`2119`	`2119`
`2120`		`- state = match name {`
	`2120`	`+ state = match &*name {`
`2121`	`2121`	`"input" \| "requires" => State::InBiberRequirementSection,`
`2122`	`2122`	`_ => State::InBiberRemainder,`
`2123`	`2123`	`}`
`2124`	`2124`	`}`
`2125`	`2125`
`2126`	`2126`	`(State::InBiberRemainder, Event::End(ref e)) => {`
`2127`		`- let name = reader.decode(e.local_name())?;`
	`2127`	`+ let name = reader.decoder().decode(e.local_name().into_inner())?;`
`2128`	`2128`
`2129`	`2129`	`if name == "external" {`
`2130`	`2130`	`break;`
`2131`	`2131`	`}`
`2132`	`2132`	`}`
`2133`	`2133`
`2134`	`2134`	`(State::InBiberRequirementSection, Event::Start(ref e)) => {`
`2135`		`- let name = reader.decode(e.local_name())?;`
	`2135`	`+ let name = reader.decoder().decode(e.local_name().into_inner())?;`
`2136`	`2136`
`2137`		`- state = match name {`
	`2137`	`+ state = match &*name {`
`2138`	`2138`	`"file" => State::InBiberFileRequirement,`
`2139`	`2139`	`_ => State::InBiberRemainder,`
`2140`	`2140`	`}`
`2141`	`2141`	`}`
`2142`	`2142`
`2143`	`2143`	`(State::InBiberRequirementSection, Event::End(ref e)) => {`
`2144`		`- let name = reader.decode(e.local_name())?;`
	`2144`	`+ let name = reader.decoder().decode(e.local_name().into_inner())?;`
`2145`	`2145`
`2146`	`2146`	`if name == "input" \|\| name == "requires" {`
`2147`	`2147`	`state = State::InBiberRemainder;`
`2148`	`2148`	`}`
`2149`	`2149`	`}`
`2150`	`2150`
`2151`	`2151`	`(State::InBiberFileRequirement, Event::Text(ref e)) => {`
`2152`		`- extra_requires.insert(e.unescape_and_decode(&reader)?);`
	`2152`	`+ extra_requires.insert(e.unescape()?.to_string());`
`2153`	`2153`	`state = State::InBiberRequirementSection;`
`2154`	`2154`	`}`
`2155`	`2155`