Merge branch 'jpochyla:main' into main

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
@@ -301,33 +300,28 @@ jobs:
         with:
           path: artifacts
 
-      - name: Prepare Linux Release Assets
-        run: |
-          if [ -f "artifacts/psst-x86_64-unknown-linux-gnu/psst" ]; then
-            mv "artifacts/psst-x86_64-unknown-linux-gnu/psst" "artifacts/psst-linux-x86_64" && \
-            rmdir "artifacts/psst-x86_64-unknown-linux-gnu"
-          fi
-          if [ -f "artifacts/psst-aarch64-unknown-linux-gnu/psst" ]; then
-            mv "artifacts/psst-aarch64-unknown-linux-gnu/psst" "artifacts/psst-linux-aarch64" && \
-            rmdir "artifacts/psst-aarch64-unknown-linux-gnu"
-          fi
-
       - name: Prepare Release Body Data
         id: release_data
         run: |
           echo "CURRENT_DATE_STR=$(date)" >> $GITHUB_ENV
 
-      - name: Prepare All Release Assets
+      - name: Prepare Release Assets
         id: prep_assets
         run: |
-          V="${{ env.RELEASE_VERSION }}"
-          mv artifacts/Psst.dmg/Psst.dmg "artifacts/Psst-${V}.dmg"
-          mv artifacts/Psst.exe/psst-gui.exe "artifacts/Psst-${V}.exe"
-          mv artifacts/psst-linux-x86_64 "artifacts/psst-linux-x86_64-${V}"
-          mv artifacts/psst-linux-aarch64 "artifacts/psst-linux-aarch64-${V}"
-          mv artifacts/psst-deb-amd64/psst-amd64.deb "artifacts/psst-amd64-${V}.deb"
-          mv artifacts/psst-deb-arm64/psst-arm64.deb "artifacts/psst-arm64-${V}.deb"
-          ls -R artifacts
+          set -e
+          mkdir -p artifacts_final
+
+          find artifacts -type f -name 'Psst.dmg' -exec mv {} artifacts_final/Psst.dmg \;
+          find artifacts -type f -name 'psst-gui.exe' -exec mv {} artifacts_final/Psst.exe \;
+          find artifacts -type f -name 'psst-amd64.deb' -exec mv {} artifacts_final/psst-amd64.deb \;
+          find artifacts -type f -name 'psst-arm64.deb' -exec mv {} artifacts_final/psst-arm64.deb \;
+
+          find artifacts -type f -name 'psst' -path '*/psst-x86_64-unknown-linux-gnu/*' -exec mv {} artifacts_final/psst-linux-x86_64 \;
+          find artifacts -type f -name 'psst' -path '*/psst-aarch64-unknown-linux-gnu/*' -exec mv {} artifacts_final/psst-linux-aarch64 \;
+
+          rm -rf artifacts
+          mv artifacts_final artifacts
+          ls -l artifacts/
 
       - name: Create Main Release
         uses: softprops/action-gh-release@v2

.homebrew/generate_formula.sh

@@ -5,57 +5,24 @@ set -eo pipefail
 REPO_OWNER="jpochyla"
 REPO_NAME="psst"
 
-# Get the latest release
-RELEASE_INFO_JSON=$(curl -sL "https://api.github.com/repos/${REPO_OWNER}/${REPO_NAME}/releases/latest")
-: "${RELEASE_INFO_JSON:?Error: Could not fetch latest release info.}"
-
-# Find the latest Psst.dmg, get its version, URL, and SHA256
-DATA=$(echo "$RELEASE_INFO_JSON" | jq -r '
-  if .assets then
-    .assets[]
-    | select(.name | test("Psst-.*\\.dmg$"))
-    | .name + " " + .browser_download_url + " " + .digest
-  else
-    empty
-  end
-' | sort -V | tail -n 1)
-
-# Check if we got data
-: "${DATA:?Error: Could not find a matching Psst.dmg asset.}"
-
-# Extract variables from the data
-DMG_NAME=$(echo "$DATA" | awk '{print $1}')
-DMG_URL=$(echo "$DATA" | awk '{print $2}')
-SHA256=$(echo "$DATA" | awk '{print $3}' | sed 's/sha256://')
-
-VERSION=$(echo "$DMG_NAME" | sed -n 's/^Psst-\(.*\)\.dmg$/\1/p')
-: "${VERSION:?Error: Could not extract version from DMG name.}"
-
 cat <<EOF
 cask "psst" do
-  version "${VERSION}"
-  sha256 "${SHA256}"
+  version :latest
+  sha256 :no_check
 
-  url "${DMG_URL}",
-      verified: "github.com/${REPO_OWNER}/${REPO_NAME}/"
+  url "https://github.com/${REPO_OWNER}/${REPO_NAME}/releases/latest/download/Psst.dmg"
   name "Psst"
   desc "Fast and native Spotify client"
   homepage "https://github.com/${REPO_OWNER}/${REPO_NAME}/"
 
-  livecheck do
-    url "https://github.com/${REPO_OWNER}/${REPO_NAME}/releases/latest"
-    strategy :github_latest
-    regex(%r{href=.*?/Psst-([^/]+?)\.dmg}i)
-  end
+  depends_on macos: ">= :big_sur"
 
   app "Psst.app"
 
-  depends_on macos: ">= :big_sur"
-
   zap trash: [
     "~/Library/Application Support/Psst",
-    "~/Library/Caches/Psst",
     "~/Library/Caches/com.jpochyla.psst",
+    "~/Library/Caches/Psst",
     "~/Library/HTTPStorages/com.jpochyla.psst",
     "~/Library/Preferences/com.jpochyla.psst.plist",
     "~/Library/Saved Application State/com.jpochyla.psst.savedState",

README.md

@@ -23,7 +23,7 @@ You can download the latest release for Windows, Linux, and macOS from the [GitH
 | Debian Package (amd64) | [Download](https://github.com/jpochyla/psst/releases/latest/download/psst-amd64.deb)     |
 | Debian Package (arm64) | [Download](https://github.com/jpochyla/psst/releases/latest/download/psst-arm64.deb)     |
 | macOS                  | [Download](https://github.com/jpochyla/psst/releases/latest/download/Psst.dmg)           |
-| Windows                | [Download](https://github.com/jpochyla/psst/releases/latest/download/psst-gui.exe)       |
+| Windows                | [Download](https://github.com/jpochyla/psst/releases/latest/download/Psst.exe)           |
 
 Unofficial builds of Psst are also available through the [AUR](https://aur.archlinux.org/packages/psst-git) and [Homebrew](https://formulae.brew.sh/cask/psst).
 
@@ -39,13 +39,13 @@ Our user-interface library, Druid, has two possible backends on Linux: GTK and p
 The default Linux backend is GTK.
 Before building on Linux, make sure the required dependencies are installed.
 
-#### Debian/Ubuntu:
+### Debian/Ubuntu
 
 ```shell
 sudo apt-get install libssl-dev libgtk-3-dev libcairo2-dev libasound2-dev
 ```
 
-#### RHEL/Fedora:
+### RHEL/Fedora
 
 ```shell
 sudo dnf install openssl-devel gtk3-devel cairo-devel alsa-lib-devel
@@ -86,21 +86,21 @@ ulimit -d $(( 2 * `ulimit -d` ))
 
 ---
 
-#### Build from Source:
+#### Build from Source
 
 ```shell
 cargo build
 # Append `--release` for a release build.
 ```
 
-#### Run from Source:
+#### Run from Source
 
 ```shell
 cargo run --bin psst-gui
 # Append `--release` for a release build.
 ```
 
-#### Build Installation Bundle (i.e., macOS .app):
+#### Build Installation Bundle (i.e., macOS .app)
 
 ```shell
 cargo install cargo-bundle

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");