Merge branch 'jpochyla:main' into user-view

Author: secondlnl

.github/workflows/build.yml

@@ -40,7 +40,7 @@ jobs:
             target: x86_64-unknown-linux-gnu
           - os: ubuntu-latest
             target: aarch64-unknown-linux-gnu
-          - os: macOS-latest
+          - os: macos-latest
           - os: windows-latest
 
     runs-on: ${{ matrix.os }}
@@ -130,9 +130,8 @@ jobs:
             --icon "Psst.app" 150 160 \
             --hide-extension "Psst.app" \
             --app-drop-link 450 160 \
-            --no-internet-enable \
             "Psst.dmg" \
-            "target/release/bundle/osx/Psst.app"
+            "../target/release/bundle/osx/Psst.app"
         working-directory: psst-gui
 
       - name: Upload macOS DMG

psst-core/build.rs

@@ -4,11 +4,11 @@ use time::OffsetDateTime;
 
 fn main() {
     let outdir = env::var("OUT_DIR").unwrap();
-    let outfile = format!("{}/build-time.txt", outdir);
+    let outfile = format!("{outdir}/build-time.txt");
 
     let mut fh = fs::File::create(outfile).unwrap();
     let now = OffsetDateTime::now_local().unwrap_or_else(|_| OffsetDateTime::now_utc());
-    write!(fh, r#""{}""#, now).ok();
+    write!(fh, r#""{now}""#).ok();
 
     let git_config = File::from_git_dir("../.git/".into()).expect("Git Config not found!");
     // Get Git's 'Origin' URL
@@ -37,7 +37,7 @@ fn main() {
     let trimmed_url = remote_url.trim_end_matches(".git");
     remote_url.clone_from(&String::from(trimmed_url));
 
-    let outfile = format!("{}/remote-url.txt", outdir);
+    let outfile = format!("{outdir}/remote-url.txt");
     let mut file = fs::File::create(outfile).unwrap();
-    write!(file, r#""{}""#, remote_url).ok();
+    write!(file, r#""{remote_url}""#).ok();
 }

psst-core/src/actor.rs

@@ -50,7 +50,7 @@ pub trait Actor: Sized {
             act = match self.handle(msg) {
                 Ok(act) => act,
                 Err(err) => {
-                    log::error!("error: {}", err);
+                    log::error!("error: {err}");
                     break;
                 }
             };

psst-core/src/audio/decode.rs

@@ -116,7 +116,7 @@ impl AudioDecoder {
                     return None; // End of this stream.
                 }
                 Err(err) => {
-                    log::error!("format error: {}", err);
+                    log::error!("format error: {err}");
                     return None; // We cannot recover from format errors, quit.
                 }
             };
@@ -137,16 +137,16 @@ impl AudioDecoder {
                 }
                 Err(SymphoniaError::IoError(err)) => {
                     // The packet failed to decode due to an IO error, skip the packet.
-                    log::error!("io decode error: {}", err);
+                    log::error!("io decode error: {err}");
                     continue;
                 }
                 Err(SymphoniaError::DecodeError(err)) => {
                     // The packet failed to decode due to invalid data, skip the packet.
-                    log::error!("decode error: {}", err);
+                    log::error!("decode error: {err}");
                     continue;
                 }
                 Err(err) => {
-                    log::error!("fatal decode error: {}", err);
+                    log::error!("fatal decode error: {err}");
                     return None;
                 }
             };

psst-core/src/audio/output/cpal.rs

@@ -24,7 +24,7 @@ impl CpalOutput {
             .ok_or(cpal::DefaultStreamConfigError::DeviceNotAvailable)?;
 
         if let Ok(name) = device.name() {
-            log::info!("using audio device: {:?}", name);
+            log::info!("using audio device: {name:?}");
         }
 
         // Get the default device config, so we know what sample format and sample rate
@@ -159,14 +159,14 @@ impl Stream {
             state: CallbackState::Paused,
         };
 
-        log::info!("opening output stream: {:?}", config);
+        log::info!("opening output stream: {config:?}");
         let stream = device.build_output_stream(
             &config,
             move |output, _| {
                 callback.write_samples(output);
             },
             |err| {
-                log::error!("audio output error: {}", err);
+                log::error!("audio output error: {err}");
             },
             None,
         )?;
@@ -187,14 +187,14 @@ impl Actor for Stream {
             StreamMsg::Pause => {
                 log::debug!("pausing audio output stream");
                 if let Err(err) = self.stream.pause() {
-                    log::error!("failed to stop stream: {}", err);
+                    log::error!("failed to stop stream: {err}");
                 }
                 Ok(Act::Continue)
             }
             StreamMsg::Resume => {
                 log::debug!("resuming audio output stream");
                 if let Err(err) = self.stream.play() {
-                    log::error!("failed to start stream: {}", err);
+                    log::error!("failed to start stream: {err}");
                 }
                 Ok(Act::Continue)
             }

psst-core/src/cache.rs

@@ -30,7 +30,7 @@ fn create_cache_dirs(base: &Path) -> io::Result<()> {
 
 impl Cache {
     pub fn new(base: PathBuf) -> Result<CacheHandle, Error> {
-        log::info!("using cache: {:?}", base);
+        log::info!("using cache: {base:?}");
 
         // Create the cache structure.
         create_cache_dirs(&base)?;
@@ -65,7 +65,7 @@ impl Cache {
     }
 
     pub fn save_track(&self, item_id: ItemId, track: &Track) -> Result<(), Error> {
-        log::debug!("saving track to cache: {:?}", item_id);
+        log::debug!("saving track to cache: {item_id:?}");
         fs::write(self.track_path(item_id), serialize_protobuf(track)?)?;
         Ok(())
     }
@@ -83,7 +83,7 @@ impl Cache {
     }
 
     pub fn save_episode(&self, item_id: ItemId, episode: &Episode) -> Result<(), Error> {
-        log::debug!("saving episode to cache: {:?}", item_id);
+        log::debug!("saving episode to cache: {item_id:?}");
         fs::write(self.episode_path(item_id), serialize_protobuf(episode)?)?;
         Ok(())
     }
@@ -106,7 +106,7 @@ impl Cache {
         file_id: FileId,
         key: &AudioKey,
     ) -> Result<(), Error> {
-        log::debug!("saving audio key to cache: {:?}:{:?}", item_id, file_id);
+        log::debug!("saving audio key to cache: {item_id:?}:{file_id:?}");
         fs::write(self.audio_key_path(item_id, file_id), key.0)?;
         Ok(())
     }
@@ -126,7 +126,7 @@ impl Cache {
     }
 
     pub fn save_audio_file(&self, file_id: FileId, from_path: PathBuf) -> Result<(), Error> {
-        log::debug!("saving audio file to cache: {:?}", file_id);
+        log::debug!("saving audio file to cache: {file_id:?}");
         fs::copy(from_path, self.audio_file_path(file_id))?;
         Ok(())
     }

psst-core/src/cdn.rs

@@ -121,7 +121,7 @@ impl From<ureq::Error> for Error {
 /// Constructs a Range header value for given offset and length.
 fn range_header(offfset: u64, length: u64) -> String {
     let last_byte = offfset + length - 1; // Offset of the last byte of the range is inclusive.
-    format!("bytes={}-{}", offfset, last_byte)
+    format!("bytes={offfset}-{last_byte}")
 }
 
 /// Parses a total content length from a Content-Range response header.

psst-core/src/connection/mod.rs

@@ -106,7 +106,7 @@ impl Transport {
                 ap_list
             }
             Err(err) => {
-                log::error!("error while resolving APs, using fallback: {:?}", err);
+                log::error!("error while resolving APs, using fallback: {err:?}");
                 vec![AP_FALLBACK.into()]
             }
         }
@@ -119,7 +119,7 @@ impl Transport {
         }
 
         let agent: ureq::Agent = default_ureq_agent_builder(proxy_url).build().into();
-        log::info!("requesting AP list from {}", AP_RESOLVE_ENDPOINT);
+        log::info!("requesting AP list from {AP_RESOLVE_ENDPOINT}");
         let data: APResolveData = agent
             .get(AP_RESOLVE_ENDPOINT)
             .call()?
@@ -145,23 +145,23 @@ impl Transport {
                 match Self::stream_through_proxy(ap, url) {
                     Ok(s) => s,
                     Err(e) => {
-                        log::warn!("failed to connect to AP {} through proxy: {:?}", ap, e);
+                        log::warn!("failed to connect to AP {ap} through proxy: {e:?}");
                         continue;
                     }
                 }
             } else {
                 match Self::stream_without_proxy(ap) {
                     Ok(s) => s,
                     Err(e) => {
-                        log::warn!("failed to connect to AP {} without proxy: {:?}", ap, e);
+                        log::warn!("failed to connect to AP {ap} without proxy: {e:?}");
                         continue;
                     }
                 }
             };
             if let Err(err) = stream.set_write_timeout(Some(NET_IO_TIMEOUT)) {
-                log::warn!("failed to set TCP write timeout: {:?}", err);
+                log::warn!("failed to set TCP write timeout: {err:?}");
             }
-            log::info!("successfully connected to AP: {}", ap);
+            log::info!("successfully connected to AP: {ap}");
             return Self::exchange_keys(stream);
         }
         log::error!("failed to connect to any access point");

psst-core/src/error.rs

@@ -45,13 +45,13 @@ impl fmt::Display for Error {
                 15 => write!(f, "Authentication failed: extra verification required"),
                 16 => write!(f, "Authentication failed: invalid app key"),
                 17 => write!(f, "Authentication failed: application banned"),
-                _ => write!(f, "Authentication failed with error code {}", code),
+                _ => write!(f, "Authentication failed with error code {code}"),
             },
             Self::ConnectionFailed => write!(f, "Failed to connect to any access point"),
             Self::ResamplingError(code) => {
-                write!(f, "Resampling failed with error code {}", code)
+                write!(f, "Resampling failed with error code {code}")
             }
-            Self::ConfigError(msg) => write!(f, "Configuration error: {}", msg),
+            Self::ConfigError(msg) => write!(f, "Configuration error: {msg}"),
             Self::JsonError(err)
             | Self::AudioFetchingError(err)
             | Self::AudioDecodingError(err)
@@ -60,9 +60,9 @@ impl fmt::Display for Error {
             | Self::AudioProbeError(err) => err.fmt(f),
             Self::IoError(err) => err.fmt(f),
             Self::SendError => write!(f, "Failed to send into a channel"),
-            Self::RecvTimeoutError(err) => write!(f, "Channel receive timeout: {}", err),
+            Self::RecvTimeoutError(err) => write!(f, "Channel receive timeout: {err}"),
             Self::JoinError => write!(f, "Failed to join thread"),
-            Self::OAuthError(msg) => write!(f, "OAuth error: {}", msg),
+            Self::OAuthError(msg) => write!(f, "OAuth error: {msg}"),
         }
     }
 }

psst-core/src/item_id.rs

@@ -111,8 +111,8 @@ impl ItemId {
     pub fn to_uri(&self) -> Option<String> {
         let b64 = self.to_base62();
         match self.id_type {
-            ItemIdType::Track => Some(format!("spotify:track:{}", b64)),
-            ItemIdType::Podcast => Some(format!("spotify:podcast:{}", b64)),
+            ItemIdType::Track => Some(format!("spotify:track:{b64}")),
+            ItemIdType::Podcast => Some(format!("spotify:podcast:{b64}")),
             // TODO: support adding local files to playlists
             ItemIdType::LocalFile => None,
             ItemIdType::Unknown => None,
@@ -176,7 +176,7 @@ impl FileId {
     pub fn to_base16(&self) -> String {
         self.0
             .iter()
-            .map(|b| format!("{:02x}", b))
+            .map(|b| format!("{b:02x}"))
             .collect::<Vec<String>>()
             .concat()
     }