chore: release

chore: release v0.10.4

.github/workflows/ci.yml

@@ -1,46 +1,22 @@
-name: ci
+name: Rust
 
 on:
   push:
-    branches: [senpai]
+    branches: [ "senpai" ]
   pull_request:
-    branches: [senpai]
+    branches: [ "senpai" ]
 
 env:
-  RUST_BACKTRACE: 1
+  CARGO_TERM_COLOR: always
-  RUST_LOG: trace
 
 jobs:
-  test:
+  build:
-    name: test
+
-    strategy:
+    runs-on: ubuntu-latest
-      matrix:
-        os: [ubuntu-latest]
-    runs-on: ${{ matrix.os }}
 
     steps:
-      - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
-
+    - name: Build
-      - name: Install Rust
+      run: cargo build --verbose
-        uses: actions-rs/toolchain@v1
+    - name: Run tests
-        with:
+      run: cargo test --verbose
-          toolchain: stable
-          profile: minimal
-          override: true
-
-      - name: Set up cache
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cargo/bin/
-            ~/.cargo/registry/index/
-            ~/.cargo/registry/cache/
-            ~/.cargo/git/db/
-            target/
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-
-      - name: Build projectable
-        run: cargo build --verbose
-
-      - name: Run tests
-        run: cargo test --verbose

.github/workflows/release-plz.yml

@@ -0,0 +1,27 @@
+name: Release Plz
+
+permissions:
+  pull-requests: write
+  contents: write
+
+on:
+  push:
+    branches:
+      - senpai
+
+jobs:
+  release-plz:
+    name: Release-plz
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Run release-plz
+        uses: MarcoIeni/release-plz-action@v0.5
+        env:
+          GITHUB_TOKEN: ${{ secrets.RELEASE_PLZ_TOKEN }}
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}

.github/workflows/release.yml

@@ -1,119 +1,281 @@
-name: release
+# Copyright 2022-2024, axodotdev
+# SPDX-License-Identifier: MIT or Apache-2.0
+#
+# CI that:
+#
+# * checks for a Git Tag that looks like a release
+# * builds artifacts with cargo-dist (archives, installers, hashes)
+# * uploads those artifacts to temporary workflow zip
+# * on success, uploads the artifacts to a GitHub Release
+#
+# Note that the GitHub Release will be created with a generated
+# title/body based on your changelogs.
 
+name: Release
+permissions:
+  "contents": "write"
+
+# This task will run whenever you push a git tag that looks like a version
+# like "1.0.0", "v0.1.0-prerelease.1", "my-app/0.1.0", "releases/v1.0.0", etc.
+# Various formats will be parsed into a VERSION and an optional PACKAGE_NAME, where
+# PACKAGE_NAME must be the name of a Cargo package in your workspace, and VERSION
+# must be a Cargo-style SemVer Version (must have at least major.minor.patch).
+#
+# If PACKAGE_NAME is specified, then the announcement will be for that
+# package (erroring out if it doesn't have the given version or isn't cargo-dist-able).
+#
+# If PACKAGE_NAME isn't specified, then the announcement will be for all
+# (cargo-dist-able) packages in the workspace with that version (this mode is
+# intended for workspaces with only one dist-able package, or with all dist-able
+# packages versioned/released in lockstep).
+#
+# If you push multiple tags at once, separate instances of this workflow will
+# spin up, creating an independent announcement for each one. However, GitHub
+# will hard limit this to 3 tags per commit, as it will assume more tags is a
+# mistake.
+#
+# If there's a prerelease-style suffix to the version, then the release(s)
+# will be marked as a prerelease.
 on:
+  pull_request:
   push:
     tags:
-      - "[0-9]+.[0-9]+.[0-9]+"
+      - '**[0-9]+.[0-9]+.[0-9]+*'
-
-permissions: write-all
 
 jobs:
-  # Creates a release and outputs the url
+  # Run 'cargo dist plan' (or host) to determine what tasks we need to do
-  create-release:
+  plan:
-    name: create-release
+    runs-on: "ubuntu-20.04"
-    runs-on: ubuntu-latest
     outputs:
-      upload_url: ${{ env.RELEASE_UPLOAD_URL }}
+      val: ${{ steps.plan.outputs.manifest }}
-      version: ${{ env.VERSION }}
+      tag: ${{ !github.event.pull_request && github.ref_name || '' }}
+      tag-flag: ${{ !github.event.pull_request && format('--tag={0}', github.ref_name) || '' }}
+      publishing: ${{ !github.event.pull_request }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
-      - name: Get the release version from the tag
+      - uses: actions/checkout@v4
-        shell: bash
-        if: env.VERSION == ''
-        run: |
-          echo "VERSION=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
-          echo "version is: ${{ env.VERSION }}"
-      - name: Create GitHub release
-        uses: actions/github-script@v6
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          github-token: "${{ secrets.GITHUB_TOKEN }}"
+          submodules: recursive
-          script: |
+      - name: Install cargo-dist
-            try {
+        # we specify bash to get pipefail; it guards against the `curl` command
-              const response = await github.rest.repos.createRelease({
+        # failing. otherwise `sh` won't catch that `curl` returned non-0
-                draft: false,
+        shell: bash
-                generate_release_notes: true,
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.20.0/cargo-dist-installer.sh | sh"
-                name: process.env.VERSION,
+      - name: Cache cargo-dist
-                owner: context.repo.owner,
+        uses: actions/upload-artifact@v4
-                prerelease: false,
+        with:
-                repo: context.repo.repo,
+          name: cargo-dist-cache
-                tag_name: process.env.VERSION,
+          path: ~/.cargo/bin/cargo-dist
-              });
+      # sure would be cool if github gave us proper conditionals...
-
+      # so here's a doubly-nested ternary-via-truthiness to try to provide the best possible
-              core.exportVariable('RELEASE_ID', response.data.id);
+      # functionality based on whether this is a pull_request, and whether it's from a fork.
-              core.exportVariable('RELEASE_UPLOAD_URL', response.data.upload_url);
+      # (PRs run on the *source* but secrets are usually on the *target* -- that's *good*
-            } catch (error) {
+      # but also really annoying to build CI around when it needs secrets to work right.)
-              core.setFailed(error.message);
+      - id: plan
-            }
+        run: |
-
+          cargo dist ${{ (!github.event.pull_request && format('host --steps=create --tag={0}', github.ref_name)) || 'plan' }} --output-format=json > plan-dist-manifest.json
-  build-and-upload:
+          echo "cargo dist ran successfully"
-    name: Build and upload
+          cat plan-dist-manifest.json
-    needs: create-release
+          echo "manifest=$(jq -c "." plan-dist-manifest.json)" >> "$GITHUB_OUTPUT"
-    runs-on: ${{ matrix.os }}
+      - name: "Upload dist-manifest.json"
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifacts-plan-dist-manifest
+          path: plan-dist-manifest.json
 
+  # Build and packages all the platform-specific things
+  build-local-artifacts:
+    name: build-local-artifacts (${{ join(matrix.targets, ', ') }})
+    # Let the initial task tell us to not run (currently very blunt)
+    needs:
+      - plan
+    if: ${{ fromJson(needs.plan.outputs.val).ci.github.artifacts_matrix.include != null && (needs.plan.outputs.publishing == 'true' || fromJson(needs.plan.outputs.val).ci.github.pr_run_mode == 'upload') }}
     strategy:
-      matrix:
+      fail-fast: false
-        build: [linux-gnu, linux-aarch64-gnu]
+      # Target platforms/runners are computed by cargo-dist in create-release.
-        include:
+      # Each member of the matrix has the following arguments:
-          - build: linux-gnu
+      #
-            os: ubuntu-latest
+      # - runner: the github runner
-            target: x86_64-unknown-linux-gnu
+      # - dist-args: cli flags to pass to cargo dist
-            use-cross: true
+      # - install-dist: expression to run to install cargo-dist on the runner
-
+      #
-          - build: linux-aarch64-gnu
+      # Typically there will be:
-            os: ubuntu-latest
+      # - 1 "global" task that builds universal installers
-            target: aarch64-unknown-linux-gnu
+      # - N "local" tasks that build each platform's binaries and platform-specific installers
-            use-cross: true
+      matrix: ${{ fromJson(needs.plan.outputs.val).ci.github.artifacts_matrix }}
-
+    runs-on: ${{ matrix.runner }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      BUILD_MANIFEST_NAME: target/distrib/${{ join(matrix.targets, '-') }}-dist-manifest.json
     steps:
-      - name: Checkout
+      - name: enable windows longpaths
-        uses: actions/checkout@v3
+        run: |
-
+          git config --global core.longpaths true
-      - name: Install Rust
+      - uses: actions/checkout@v4
-        uses: actions-rs/toolchain@v1
         with:
-          toolchain: stable
+          submodules: recursive
-          profile: minimal
+      - name: Install cargo-dist
-          override: true
+        run: ${{ matrix.install_dist }}
-          target: ${{ matrix.target }}
+      # Get the dist-manifest
-
+      - name: Fetch local artifacts
-      - name: Build
+        uses: actions/download-artifact@v4
-        uses: actions-rs/cargo@v1
         with:
-          use-cross: ${{ matrix.use-cross }}
+          pattern: artifacts-*
-          command: build
+          path: target/distrib/
-          args: --verbose --release --target ${{ matrix.target }}
+          merge-multiple: true
-
+      - name: Install dependencies
-      - name: Strip release binary (linux and macos)
+        run: |
-        if: matrix.build == 'linux-gnu' || matrix.build == 'linux-musl' || matrix.build == 'macos' || matrix.build == 'linux-aarch64-gnu'
+          ${{ matrix.packages_install }}
-        run: strip "target/${{ matrix.target }}/release/lyra"
+      - name: Build artifacts
-
+        run: |
-      - name: Build archive
+          # Actually do builds and make zips and whatnot
+          cargo dist build ${{ needs.plan.outputs.tag-flag }} --print=linkage --output-format=json ${{ matrix.dist_args }} > dist-manifest.json
+          echo "cargo dist ran successfully"
+      - id: cargo-dist
+        name: Post-build
+        # We force bash here just because github makes it really hard to get values up
+        # to "real" actions without writing to env-vars, and writing to env-vars has
+        # inconsistent syntax between shell and powershell.
         shell: bash
         run: |
-          dirname="lyra-${{ needs.create-release.outputs.version }}-${{ matrix.target }}"
+          # Parse out what we just built and upload it to scratch storage
-          mkdir "$dirname"
+          echo "paths<<EOF" >> "$GITHUB_OUTPUT"
-          if [ "${{ matrix.os }}" = "windows-latest" ]; then
+          jq --raw-output ".upload_files[]" dist-manifest.json >> "$GITHUB_OUTPUT"
-            mv "target/${{ matrix.target }}/release/lyra.exe" "$dirname"
+          echo "EOF" >> "$GITHUB_OUTPUT"
-          else
-            mv "target/${{ matrix.target }}/release/lyra" "$dirname"
-          fi
-          mv LICENSE.md "$dirname"
 
-          if [ "${{ matrix.os }}" = "windows-latest" ]; then
+          cp dist-manifest.json "$BUILD_MANIFEST_NAME"
-            7z a "$dirname.zip" "$dirname"
+      - name: "Upload artifacts"
-            echo "ASSET=$dirname.zip" >> $GITHUB_ENV
+        uses: actions/upload-artifact@v4
-          else
-            tar -czf "$dirname.tar.gz" "$dirname"
-            echo "ASSET=$dirname.tar.gz" >> $GITHUB_ENV
-          fi
-
-      - name: Upload archive
-        uses: actions/upload-release-asset@v1.0.1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          upload_url: ${{ needs.create-release.outputs.upload_url }}
+          name: artifacts-build-local-${{ join(matrix.targets, '_') }}
-          asset_path: ${{ env.ASSET }}
+          path: |
-          asset_name: ${{ env.ASSET }}
+            ${{ steps.cargo-dist.outputs.paths }}
-          asset_content_type: application/octet-stream
+            ${{ env.BUILD_MANIFEST_NAME }}
+
+  # Build and package all the platform-agnostic(ish) things
+  build-global-artifacts:
+    needs:
+      - plan
+      - build-local-artifacts
+    runs-on: "ubuntu-20.04"
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install cached cargo-dist
+        uses: actions/download-artifact@v4
+        with:
+          name: cargo-dist-cache
+          path: ~/.cargo/bin/
+      - run: chmod +x ~/.cargo/bin/cargo-dist
+      # Get all the local artifacts for the global tasks to use (for e.g. checksums)
+      - name: Fetch local artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: target/distrib/
+          merge-multiple: true
+      - id: cargo-dist
+        shell: bash
+        run: |
+          cargo dist build ${{ needs.plan.outputs.tag-flag }} --output-format=json "--artifacts=global" > dist-manifest.json
+          echo "cargo dist ran successfully"
+
+          # Parse out what we just built and upload it to scratch storage
+          echo "paths<<EOF" >> "$GITHUB_OUTPUT"
+          jq --raw-output ".upload_files[]" dist-manifest.json >> "$GITHUB_OUTPUT"
+          echo "EOF" >> "$GITHUB_OUTPUT"
+
+          cp dist-manifest.json "$BUILD_MANIFEST_NAME"
+      - name: "Upload artifacts"
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifacts-build-global
+          path: |
+            ${{ steps.cargo-dist.outputs.paths }}
+            ${{ env.BUILD_MANIFEST_NAME }}
+  # Determines if we should publish/announce
+  host:
+    needs:
+      - plan
+      - build-local-artifacts
+      - build-global-artifacts
+    # Only run if we're "publishing", and only if local and global didn't fail (skipped is fine)
+    if: ${{ always() && needs.plan.outputs.publishing == 'true' && (needs.build-global-artifacts.result == 'skipped' || needs.build-global-artifacts.result == 'success') && (needs.build-local-artifacts.result == 'skipped' || needs.build-local-artifacts.result == 'success') }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    runs-on: "ubuntu-20.04"
+    outputs:
+      val: ${{ steps.host.outputs.manifest }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install cached cargo-dist
+        uses: actions/download-artifact@v4
+        with:
+          name: cargo-dist-cache
+          path: ~/.cargo/bin/
+      - run: chmod +x ~/.cargo/bin/cargo-dist
+      # Fetch artifacts from scratch-storage
+      - name: Fetch artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: target/distrib/
+          merge-multiple: true
+      - id: host
+        shell: bash
+        run: |
+          cargo dist host ${{ needs.plan.outputs.tag-flag }} --steps=upload --steps=release --output-format=json > dist-manifest.json
+          echo "artifacts uploaded and released successfully"
+          cat dist-manifest.json
+          echo "manifest=$(jq -c "." dist-manifest.json)" >> "$GITHUB_OUTPUT"
+      - name: "Upload dist-manifest.json"
+        uses: actions/upload-artifact@v4
+        with:
+          # Overwrite the previous copy
+          name: artifacts-dist-manifest
+          path: dist-manifest.json
+      # Create a GitHub Release while uploading all files to it
+      - name: "Download GitHub Artifacts"
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: artifacts
+          merge-multiple: true
+      - name: Cleanup
+        run: |
+          # Remove the granular manifests
+          rm -f artifacts/*-dist-manifest.json
+      - name: Create GitHub Release
+        env:
+          PRERELEASE_FLAG: "${{ fromJson(steps.host.outputs.manifest).announcement_is_prerelease && '--prerelease' || '' }}"
+          ANNOUNCEMENT_TITLE: "${{ fromJson(steps.host.outputs.manifest).announcement_title }}"
+          ANNOUNCEMENT_BODY: "${{ fromJson(steps.host.outputs.manifest).announcement_github_body }}"
+          RELEASE_COMMIT: "${{ github.sha }}"
+        run: |
+          # Write and read notes from a file to avoid quoting breaking things
+          echo "$ANNOUNCEMENT_BODY" > $RUNNER_TEMP/notes.txt
+
+          gh release create "${{ needs.plan.outputs.tag }}" --target "$RELEASE_COMMIT" $PRERELEASE_FLAG --title "$ANNOUNCEMENT_TITLE" --notes-file "$RUNNER_TEMP/notes.txt" artifacts/*
+
+  announce:
+    needs:
+      - plan
+      - host
+    # use "always() && ..." to allow us to wait for all publish jobs while
+    # still allowing individual publish jobs to skip themselves (for prereleases).
+    # "host" however must run to completion, no skipping allowed!
+    if: ${{ always() && needs.host.result == 'success' }}
+    runs-on: "ubuntu-20.04"
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive

CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.10.7](https://github.com/eRgo35/lyra/compare/v0.10.6...v0.10.7) - 2024-08-16
+
+### Other
+- update Cargo.lock dependencies
+
+## [0.10.4](https://github.com/eRgo35/lyra/compare/v0.10.3...v0.10.4) - 2024-08-13
+
+### Fixed
+- added wip info for some commands
+
+### Other
+- cargo-dist action setup
+- repo added to Cargo.toml
+- using cargo-dist for package building
+
+## [0.10.3](https://github.com/eRgo35/lyra/compare/v0.10.2...v0.10.3) - 2024-08-13
+
+### Other
+- release-plz
+# Changelog

Cargo.lock

@@ -1311,7 +1311,7 @@ dependencies = [
 
 [[package]]
 name = "lyra"
-version = "0.10.2"
+version = "0.10.7"
 dependencies = [
  "dotenv",
  "json",
@@ -2788,9 +2788,8 @@ dependencies = [
 
 [[package]]
 name = "songbird"
-version = "0.4.3"
+version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
+source = "git+https://github.com/eRgo35/songbird#64a9b6ba5e591a1324390aa896b661633f4baa24"
-checksum = "338dd182f9f084f583c4c0db38588e28a34778ecec288208cf0b61c378ac90d1"
 dependencies = [
  "async-trait",
  "audiopus",

Cargo.toml

@@ -1,10 +1,11 @@
 [package]
 name = "lyra"
-version = "0.10.2"
+version = "0.10.7"
 authors = ["Michał Czyż <mike@c2yz.com>"]
 edition = "2021"
 description = "A featureful Discord bot written in Rust."
 documentation = "https://github.com/eRgo35/lyra"
+repository = "https://github.com/eRgo35/lyra"
 readme = "README.md"
 homepage = "https://lyra.c2yz.com"
 license-file = "LICENSE.md"
@@ -22,9 +23,9 @@ regex = "1.10.6"
 reqwest = { version = "0.11.27", features = ["json"] }
 serde = { version = "1.0.204", features = ["derive"] }
 serde_json = "1.0.122"
-songbird = { version = "0.4.3", default-features = true, features = [
+songbird = { version = "~0.4.3", default-features = true, features = [
     "builtin-queue",
-] }
+], git = "https://github.com/eRgo35/songbird" }
 serenity = { default-features = true, features = [
     "cache",
     "framework",
@@ -51,3 +52,23 @@ once_cell = "1.19.0"
 [patch.crates-io.serenity-voice-model]
 git = "https://github.com/serenity-rs/serenity"
 branch = "current"
+
+# The profile that 'cargo dist' will build with
+[profile.dist]
+inherits = "release"
+lto = "thin"
+
+# Config for 'cargo dist'
+[workspace.metadata.dist]
+# The preferred cargo-dist version to use in CI (Cargo.toml SemVer syntax)
+cargo-dist-version = "0.20.0"
+# CI backends to support
+ci = "github"
+# The installers to generate for each app
+installers = ["shell"]
+# Target platforms to build apps for (Rust target-triple syntax)
+targets = ["x86_64-unknown-linux-gnu"]
+# Path that installers should place binaries in
+install-path = "CARGO_HOME"
+# Whether to install an updater program
+install-updater = false

src/commands/music/play.rs

@@ -132,6 +132,7 @@ async fn parse_data(data: String) -> VecDeque<String> {
                 .unwrap();
 
                 let list = Command::new("yt-dlp")
+                    .args(["--username", "oauth2", "--password", "''"])
                     .args(["-j", "--flat-playlist", track])
                     .output()
                     .expect("Failed to execute process")

src/commands/tools/ip.rs

@@ -5,8 +5,10 @@ use crate::{commands::embeds::embed, Context, Error};
 /// Shows IP information
 #[poise::command(prefix_command, slash_command, category = "Tools")]
 pub async fn ip(ctx: Context<'_>) -> Result<(), Error> {
-    ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
+    ctx.send(
-        .await?;
+        CreateReply::default().embed(embed(ctx, "IP Info", "Work in progress", "").await.unwrap()),
+    )
+    .await?;
 
     Ok(())
 }

src/commands/tools/metar.rs

@@ -5,8 +5,10 @@ use crate::{commands::embeds::embed, Context, Error};
 /// Prints metar for provided airport
 #[poise::command(prefix_command, slash_command, category = "Tools")]
 pub async fn metar(ctx: Context<'_>) -> Result<(), Error> {
-    ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
+    ctx.send(
-        .await?;
+        CreateReply::default().embed(embed(ctx, "Metar", "Work in progress", "").await.unwrap()),
+    )
+    .await?;
 
     Ok(())
 }

src/commands/tools/taf.rs

@@ -5,8 +5,10 @@ use crate::{commands::embeds::embed, Context, Error};
 /// Returns taf for provided airport
 #[poise::command(prefix_command, slash_command, category = "Tools")]
 pub async fn taf(ctx: Context<'_>) -> Result<(), Error> {
-    ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
+    ctx.send(
-        .await?;
+        CreateReply::default().embed(embed(ctx, "Taf", "Work in progress", "").await.unwrap()),
+    )
+    .await?;
 
     Ok(())
 }

src/commands/tools/weather.rs

@@ -10,8 +10,10 @@ pub async fn weather(
     #[rest]
     _location: String,
 ) -> Result<(), Error> {
-    ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
+    ctx.send(
-        .await?;
+        CreateReply::default().embed(embed(ctx, "Weather", "Work in progress", "").await.unwrap()),
+    )
+    .await?;
 
     Ok(())
 }