├── .envrc
├── .gitignore
├── src
    ├── ro_cell.rs
    ├── message.rs
    ├── config
    │   ├── mod.rs
    │   ├── options.rs
    │   ├── theme.rs
    │   └── keys.rs
    ├── cli.rs
    ├── search.rs
    ├── import.rs
    ├── player.rs
    ├── channel.rs
    ├── stream_formats.rs
    ├── protobuf.rs
    ├── commands.rs
    ├── help.rs
    ├── api
    │   ├── invidious.rs
    │   └── mod.rs
    ├── utils.rs
    ├── main.rs
    ├── ui
    │   └── utils.rs
    ├── input.rs
    ├── client.rs
    └── database.rs
├── flake.nix
├── Cargo.toml
├── .github
    └── workflows
    │   ├── ci.yml
    │   └── cd.yml
├── flake.lock
├── CHANGELOG.md
└── README.md


/.envrc:
--------------------------------------------------------------------------------
1 | use flake
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | /result
3 | /.direnv
4 | 


--------------------------------------------------------------------------------
/src/ro_cell.rs:
--------------------------------------------------------------------------------
 1 | use std::{cell::UnsafeCell, mem::MaybeUninit, ops::Deref};
 2 | 
 3 | pub struct RoCell<T> {
 4 |     content: UnsafeCell<MaybeUninit<T>>,
 5 |     initialized: UnsafeCell<bool>,
 6 | }
 7 | 
 8 | unsafe impl<T> Sync for RoCell<T> {}
 9 | 
10 | impl<T> RoCell<T> {
11 |     pub const fn new() -> Self {
12 |         Self {
13 |             content: UnsafeCell::new(MaybeUninit::uninit()),
14 |             initialized: UnsafeCell::new(false),
15 |         }
16 |     }
17 | 
18 |     pub fn init(&self, value: T) {
19 |         unsafe {
20 |             self.initialized.get().replace(true);
21 |             *self.content.get() = MaybeUninit::new(value);
22 |         }
23 |     }
24 | }
25 | 
26 | impl<T> Deref for RoCell<T> {
27 |     type Target = T;
28 | 
29 |     fn deref(&self) -> &Self::Target {
30 |         unsafe { (*self.content.get()).assume_init_ref() }
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/message.rs:
--------------------------------------------------------------------------------
 1 | use std::ops::Deref;
 2 | use tokio_util::sync::CancellationToken;
 3 | 
 4 | pub enum MessageType {
 5 |     Normal,
 6 |     Error,
 7 |     Warning,
 8 | }
 9 | 
10 | pub struct Message {
11 |     message: String,
12 |     pub message_type: MessageType,
13 |     token: CancellationToken,
14 | }
15 | 
16 | impl Message {
17 |     pub fn new() -> Self {
18 |         Message {
19 |             message: String::new(),
20 |             message_type: MessageType::Normal,
21 |             token: CancellationToken::new(),
22 |         }
23 |     }
24 | 
25 |     pub fn set_message(&mut self, message: &str) {
26 |         message.clone_into(&mut self.message);
27 |         self.message_type = MessageType::Normal;
28 |         self.token.cancel();
29 |         self.token = CancellationToken::new();
30 |     }
31 | 
32 |     pub fn set_error_message(&mut self, message: &str) {
33 |         self.set_message(message);
34 |         self.message_type = MessageType::Error;
35 |     }
36 | 
37 |     pub fn set_warning_message(&mut self, message: &str) {
38 |         self.set_message(message);
39 |         self.message_type = MessageType::Warning;
40 |     }
41 | 
42 |     pub fn clear_message(&mut self) {
43 |         self.message.clear();
44 |     }
45 | 
46 |     pub fn clone_token(&self) -> CancellationToken {
47 |         self.token.clone()
48 |     }
49 | }
50 | 
51 | impl Deref for Message {
52 |     type Target = String;
53 | 
54 |     fn deref(&self) -> &Self::Target {
55 |         &self.message
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/flake.nix:
--------------------------------------------------------------------------------
 1 | {
 2 |   inputs = {
 3 |     nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
 4 | 
 5 |     crane.url = "github:ipetkov/crane";
 6 | 
 7 |     flake-utils.url = "github:numtide/flake-utils";
 8 | 
 9 |     rust-overlay = {
10 |       url = "github:oxalica/rust-overlay";
11 |       inputs.nixpkgs.follows = "nixpkgs";
12 |     };
13 |   };
14 | 
15 |   outputs =
16 |     {
17 |       nixpkgs,
18 |       crane,
19 |       flake-utils,
20 |       rust-overlay,
21 |       ...
22 |     }:
23 |     flake-utils.lib.eachDefaultSystem (
24 |       system:
25 |       let
26 |         pkgs = import nixpkgs {
27 |           inherit system;
28 |           overlays = [ (import rust-overlay) ];
29 |         };
30 | 
31 |         rust-toolchain = pkgs.rust-bin.stable.latest.default.override {
32 |           extensions = [
33 |             "rust-src"
34 |             "rust-analyzer"
35 |           ];
36 |         };
37 | 
38 |         craneLib = (crane.mkLib pkgs).overrideToolchain rust-toolchain;
39 | 
40 |         ytsub = craneLib.buildPackage {
41 |           CARGO_PROFILE = "release-lto";
42 | 
43 |           src = craneLib.cleanCargoSource ./.;
44 | 
45 |           buildInputs = [
46 |             pkgs.sqlite.dev
47 |           ];
48 |         };
49 |       in
50 |       {
51 |         packages.default = ytsub;
52 | 
53 |         devShells.default = craneLib.devShell {
54 |           inputsFrom = [ ytsub ];
55 | 
56 |           packages = with pkgs; [
57 |             cargo-edit
58 |           ];
59 |         };
60 |       }
61 |     );
62 | }
63 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "ytsub"
 3 | version = "0.7.0"
 4 | edition = "2024"
 5 | description = "A subscriptions only TUI Youtube client"
 6 | authors = ["Berke Enercan <berkeenercan@tutanota.com>"]
 7 | repository = "https://github.com/sarowish/ytsub"
 8 | license = "GPL-3.0"
 9 | readme = "README.md"
10 | keywords = ["youtube", "cli", "tui", "terminal"]
11 | categories = ["command-line-utilities"]
12 | 
13 | [dependencies]
14 | anyhow = "1.0.100"
15 | clap = "4.5.50"
16 | crossterm = { version = "0.29.0", features = ["event-stream"] }
17 | dirs = "6.0.0"
18 | futures-util = "0.3.31"
19 | num_cpus = "1.17.0"
20 | rand = "0.9.2"
21 | rusqlite = "0.37.0"
22 | serde = { version = "1.0.228", features = ["derive"] }
23 | serde_json = "1.0.145"
24 | tokio = { version = "1.48.0", features = ["time", "macros", "rt-multi-thread", "process"] }
25 | tokio-util = "0.7.16"
26 | unicode-width = "0.2.0"
27 | unicode-segmentation = "1.12.0"
28 | toml = "0.9.8"
29 | csv = "1.4.0"
30 | quick-xml = { version = "0.38.3", features = ["serialize"] }
31 | chrono = "0.4.42"
32 | dyn-clone = "1.0.20"
33 | ratatui = "0.29.0"
34 | regex-lite = "0.1.8"
35 | reqwest = { version = "0.12.24", default-features = false, features = ["json", "rustls-tls", "gzip"] }
36 | async-trait = "0.1.89"
37 | open = "5.3.2"
38 | bitflags = "2.10.0"
39 | base64 = "0.22.1"
40 | itertools = "0.14.0"
41 | url = "2.5.7"
42 | 
43 | [target.'cfg(unix)'.dependencies]
44 | libc = "0.2.177"
45 | 
46 | [target.'cfg(windows)'.dependencies]
47 | rusqlite = { version = "0.37.0", features = ["bundled"]}
48 | 
49 | [features]
50 | bundled_sqlite = ["rusqlite/bundled"]
51 | 
52 | 
53 | [profile.release-lto]
54 | inherits = "release"
55 | lto = true
56 | codegen-units = 1
57 | panic = "abort"
58 | strip = "symbols"
59 | 


--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
 1 | name: Continuous Integration
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [master]
 6 |   pull_request:
 7 | 
 8 | jobs:
 9 |   test:
10 |     name: Test
11 |     runs-on: ${{ matrix.os }}
12 |     strategy:
13 |       matrix:
14 |         include:
15 |           - os: ubuntu-latest
16 |             target: x86_64-unknown-linux-gnu
17 |           - os: ubuntu-24.04-arm
18 |             target: aarch64-unknown-linux-gnu
19 |           - os: macos-latest
20 |             target: aarch64-apple-darwin
21 |           - os: macos-13
22 |             target: x86_64-apple-darwin
23 |           - os: windows-latest
24 |             target: x86_64-pc-windows-msvc
25 |     steps:
26 |       - name: Checkout repository
27 |         uses: actions/checkout@v4
28 | 
29 |       - name: Install Rust
30 |         uses: dtolnay/rust-toolchain@stable
31 |         with:
32 |           targets: ${{ matrix.target }}
33 | 
34 |       - uses: Swatinem/rust-cache@v2
35 | 
36 |       - name: Test
37 |         run: cargo test --target ${{ matrix.target }}
38 | 
39 |   clippy:
40 |     name: Clippy
41 |     runs-on: ubuntu-latest
42 |     steps:
43 |       - name: Checkout repository
44 |         uses: actions/checkout@v4
45 | 
46 |       - name: Install Rust
47 |         uses: dtolnay/rust-toolchain@stable
48 |         with:
49 |           components: clippy
50 | 
51 |       - uses: Swatinem/rust-cache@v2
52 | 
53 |       - name: Check Lints
54 |         run: cargo clippy -- -D warnings
55 | 
56 |   rustfmt:
57 |     name: Rustfmt
58 |     runs-on: ubuntu-latest
59 |     steps:
60 |       - name: Checkout repository
61 |         uses: actions/checkout@v4
62 | 
63 |       - name: Install Rust
64 |         uses: dtolnay/rust-toolchain@stable
65 |         with:
66 |           components: rustfmt
67 | 
68 |       - name: Check formatting
69 |         run: cargo fmt --all --check
70 | 


--------------------------------------------------------------------------------
/src/config/mod.rs:
--------------------------------------------------------------------------------
 1 | pub mod keys;
 2 | pub mod options;
 3 | pub mod theme;
 4 | 
 5 | use self::{
 6 |     keys::{KeyBindings, UserKeyBindings},
 7 |     options::{Options, UserOptions},
 8 |     theme::{Theme, UserTheme},
 9 | };
10 | use crate::{CLAP_ARGS, utils};
11 | use anyhow::Result;
12 | use serde::Deserialize;
13 | use std::{fs, path::PathBuf};
14 | 
15 | const CONFIG_FILE: &str = "config.toml";
16 | 
17 | #[derive(Deserialize)]
18 | struct UserConfig {
19 |     #[serde(flatten)]
20 |     options: Option<UserOptions>,
21 |     #[serde(flatten)]
22 |     theme: Option<UserTheme>,
23 |     key_bindings: Option<UserKeyBindings>,
24 | }
25 | 
26 | #[derive(Default)]
27 | pub struct Config {
28 |     pub options: Options,
29 |     pub theme: Theme,
30 |     pub key_bindings: KeyBindings,
31 | }
32 | 
33 | impl Config {
34 |     pub fn new() -> Result<Self> {
35 |         let config_file = match CLAP_ARGS.get_one::<PathBuf>("config") {
36 |             Some(path) => path.to_owned(),
37 |             None => utils::get_config_dir()?.join(CONFIG_FILE),
38 |         };
39 | 
40 |         let mut config = match fs::read_to_string(config_file) {
41 |             Ok(config_str) if !CLAP_ARGS.get_flag("no_config") => {
42 |                 Self::try_from(toml::from_str::<UserConfig>(&config_str)?)?
43 |             }
44 |             _ => Self::default(),
45 |         };
46 | 
47 |         config.options.override_with_clap_args();
48 | 
49 |         if config.options.database.as_os_str().is_empty() {
50 |             config.options.database = utils::get_default_database_file()?;
51 |         }
52 | 
53 |         if config.options.instances.as_os_str().is_empty() {
54 |             config.options.instances = utils::get_default_instances_file()?;
55 |         }
56 | 
57 |         Ok(config)
58 |     }
59 | }
60 | 
61 | impl TryFrom<UserConfig> for Config {
62 |     type Error = anyhow::Error;
63 | 
64 |     fn try_from(user_config: UserConfig) -> Result<Self, Self::Error> {
65 |         let mut config = Self::default();
66 | 
67 |         if let Some(options) = user_config.options {
68 |             config.options = options.into();
69 |         }
70 | 
71 |         if let Some(theme) = user_config.theme {
72 |             config.theme = theme.try_into()?;
73 |         }
74 | 
75 |         if let Some(key_bindings) = user_config.key_bindings {
76 |             config.key_bindings = key_bindings.try_into()?;
77 |         }
78 | 
79 |         Ok(config)
80 |     }
81 | }
82 | 


--------------------------------------------------------------------------------
/.github/workflows/cd.yml:
--------------------------------------------------------------------------------
 1 | name: Continuous Deployment
 2 | 
 3 | on:
 4 |   push:
 5 |     tags:
 6 |       - "v[0-9]+.[0-9]+.[0-9]+"
 7 | 
 8 | jobs:
 9 |   release:
10 |     name: Release
11 |     runs-on: ${{ matrix.os }}
12 |     strategy:
13 |       matrix:
14 |         include:
15 |           - os: ubuntu-latest
16 |             target: x86_64-unknown-linux-gnu
17 |           - os: ubuntu-24.04-arm
18 |             target: aarch64-unknown-linux-gnu
19 |           - os: macos-latest
20 |             target: aarch64-apple-darwin
21 |           - os: macos-13
22 |             target: x86_64-apple-darwin
23 |           - os: windows-latest
24 |             target: x86_64-pc-windows-msvc
25 | 
26 |     steps:
27 |       - name: Checkout repository
28 |         uses: actions/checkout@v4
29 | 
30 |       - name: Set the release version
31 |         run: echo "RELEASE_VERSION=${GITHUB_REF:11}" >> $GITHUB_ENV
32 | 
33 |       - name: Install Rust
34 |         uses: dtolnay/rust-toolchain@stable
35 |         with:
36 |           targets: ${{ matrix.target }}
37 | 
38 |       - name: Build
39 |         run: cargo build --profile release-lto --target ${{ matrix.target }}
40 | 
41 |       - name: Prepare assets
42 |         shell: bash
43 |         run: |
44 |           mkdir ytsub-${{ env.RELEASE_VERSION }}
45 |           cp LICENSE README.md target/${{ matrix.target }}/release-lto/ytsub \
46 |             ytsub-${{ env.RELEASE_VERSION }}
47 | 
48 |       - name: Package assets
49 |         shell: bash
50 |         run: |
51 |           if [ "${{ matrix.config.OS }}" = "windows-latest" ]; then
52 |             7z a -tzip ytsub-${{ env.RELEASE_VERSION }}-${{ matrix.target }}.zip \
53 |               ytsub-${{ env.RELEASE_VERSION }}
54 |           else
55 |             tar czvf ytsub-${{ env.RELEASE_VERSION }}-${{ matrix.target }}.tar.gz \
56 |               ytsub-${{ env.RELEASE_VERSION }}
57 |           fi
58 | 
59 |       - name: Upload
60 |         uses: softprops/action-gh-release@v1
61 |         with:
62 |           files: ytsub-${{ env.RELEASE_VERSION }}-${{ matrix.target }}.*
63 |         env:
64 |           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
65 | 
66 |   publish-cargo:
67 |     name: Publish on crates.io
68 |     runs-on: ubuntu-latest
69 |     steps:
70 |       - name: Checkout repository
71 |         uses: actions/checkout@v4
72 | 
73 |       - name: Install Rust
74 |         uses: dtolnay/rust-toolchain@stable
75 | 
76 |       - name: Publish
77 |         run: cargo publish
78 |         env:
79 |           CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
80 | 


--------------------------------------------------------------------------------
/flake.lock:
--------------------------------------------------------------------------------
 1 | {
 2 |   "nodes": {
 3 |     "crane": {
 4 |       "locked": {
 5 |         "lastModified": 1762538466,
 6 |         "narHash": "sha256-8zrIPl6J+wLm9MH5ksHcW7BUHo7jSNOu0/hA0ohOOaM=",
 7 |         "owner": "ipetkov",
 8 |         "repo": "crane",
 9 |         "rev": "0cea393fffb39575c46b7a0318386467272182fe",
10 |         "type": "github"
11 |       },
12 |       "original": {
13 |         "owner": "ipetkov",
14 |         "repo": "crane",
15 |         "type": "github"
16 |       }
17 |     },
18 |     "flake-utils": {
19 |       "inputs": {
20 |         "systems": "systems"
21 |       },
22 |       "locked": {
23 |         "lastModified": 1731533236,
24 |         "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
25 |         "owner": "numtide",
26 |         "repo": "flake-utils",
27 |         "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
28 |         "type": "github"
29 |       },
30 |       "original": {
31 |         "owner": "numtide",
32 |         "repo": "flake-utils",
33 |         "type": "github"
34 |       }
35 |     },
36 |     "nixpkgs": {
37 |       "locked": {
38 |         "lastModified": 1762482733,
39 |         "narHash": "sha256-g/da4FzvckvbiZT075Sb1/YDNDr+tGQgh4N8i5ceYMg=",
40 |         "owner": "NixOS",
41 |         "repo": "nixpkgs",
42 |         "rev": "e1ebeec86b771e9d387dd02d82ffdc77ac753abc",
43 |         "type": "github"
44 |       },
45 |       "original": {
46 |         "owner": "NixOS",
47 |         "ref": "nixpkgs-unstable",
48 |         "repo": "nixpkgs",
49 |         "type": "github"
50 |       }
51 |     },
52 |     "root": {
53 |       "inputs": {
54 |         "crane": "crane",
55 |         "flake-utils": "flake-utils",
56 |         "nixpkgs": "nixpkgs",
57 |         "rust-overlay": "rust-overlay"
58 |       }
59 |     },
60 |     "rust-overlay": {
61 |       "inputs": {
62 |         "nixpkgs": [
63 |           "nixpkgs"
64 |         ]
65 |       },
66 |       "locked": {
67 |         "lastModified": 1762655942,
68 |         "narHash": "sha256-hOM12KcQNQALrhB9w6KJmV5hPpm3GA763HRe9o7JUiI=",
69 |         "owner": "oxalica",
70 |         "repo": "rust-overlay",
71 |         "rev": "6ac961b02d4235572692241e333d0470637f5492",
72 |         "type": "github"
73 |       },
74 |       "original": {
75 |         "owner": "oxalica",
76 |         "repo": "rust-overlay",
77 |         "type": "github"
78 |       }
79 |     },
80 |     "systems": {
81 |       "locked": {
82 |         "lastModified": 1681028828,
83 |         "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
84 |         "owner": "nix-systems",
85 |         "repo": "default",
86 |         "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
87 |         "type": "github"
88 |       },
89 |       "original": {
90 |         "owner": "nix-systems",
91 |         "repo": "default",
92 |         "type": "github"
93 |       }
94 |     }
95 |   },
96 |   "root": "root",
97 |   "version": 7
98 | }
99 | 


--------------------------------------------------------------------------------
/src/cli.rs:
--------------------------------------------------------------------------------
  1 | use clap::{Arg, ArgAction, ArgMatches, Command, builder::ValueParser};
  2 | 
  3 | pub fn get_matches() -> ArgMatches {
  4 |     Command::new(env!("CARGO_PKG_NAME"))
  5 |         .version(env!("CARGO_PKG_VERSION"))
  6 |         .about(env!("CARGO_PKG_DESCRIPTION"))
  7 |         .arg(
  8 |             Arg::new("config")
  9 |                 .short('c')
 10 |                 .long("config")
 11 |                 .help("Path to configuration file")
 12 |                 .value_parser(ValueParser::path_buf())
 13 |                 .value_name("FILE"),
 14 |         )
 15 |         .arg(
 16 |             Arg::new("no_config")
 17 |                 .short('n')
 18 |                 .long("no-config")
 19 |                 .help("Ignore configuration file")
 20 |                 .conflicts_with("config")
 21 |                 .action(ArgAction::SetTrue),
 22 |         )
 23 |         .arg(
 24 |             Arg::new("database")
 25 |                 .short('d')
 26 |                 .long("database")
 27 |                 .help("Path to database file")
 28 |                 .value_parser(ValueParser::path_buf())
 29 |                 .value_name("FILE"),
 30 |         )
 31 |         .arg(
 32 |             Arg::new("instances")
 33 |                 .short('s')
 34 |                 .long("instances")
 35 |                 .help("Path to instances file")
 36 |                 .value_parser(ValueParser::path_buf())
 37 |                 .value_name("FILE"),
 38 |         )
 39 |         .arg(
 40 |             Arg::new("gen_instances_list")
 41 |                 .short('g')
 42 |                 .long("gen-instances")
 43 |                 .help("Generate Invidious instances file")
 44 |                 .action(ArgAction::SetTrue),
 45 |         )
 46 |         .arg(
 47 |             Arg::new("tick_rate")
 48 |                 .hide(true)
 49 |                 .short('t')
 50 |                 .long("tick-rate")
 51 |                 .help("Tick rate in milliseconds")
 52 |                 .value_name("TICK RATE")
 53 |                 .value_parser(clap::value_parser!(u64)),
 54 |         )
 55 |         .arg(
 56 |             Arg::new("request_timeout")
 57 |                 .hide(true)
 58 |                 .short('r')
 59 |                 .long("request-timeout")
 60 |                 .help("Timeout in seconds")
 61 |                 .value_name("TIMEOUT")
 62 |                 .value_parser(clap::value_parser!(u64)),
 63 |         )
 64 |         .arg(
 65 |             Arg::new("highlight_symbol")
 66 |                 .hide(true)
 67 |                 .long("highlight-symbol")
 68 |                 .help("Symbol to highlight selected items")
 69 |                 .value_name("SYMBOL"),
 70 |         )
 71 |         .subcommand(create_import_subcommand())
 72 |         .subcommand(create_export_subcommand())
 73 |         .get_matches()
 74 | }
 75 | 
 76 | fn create_import_subcommand() -> Command {
 77 |     Command::new("import")
 78 |         .about("Import subscriptions")
 79 |         .arg(
 80 |             Arg::new("format")
 81 |                 .short('f')
 82 |                 .long("format")
 83 |                 .help("Format of the import file")
 84 |                 .value_name("FORMAT")
 85 |                 .default_value("youtube_csv")
 86 |                 .value_parser(["youtube_csv", "newpipe"]),
 87 |         )
 88 |         .arg(
 89 |             Arg::new("source")
 90 |                 .help("Path to the import file")
 91 |                 .value_parser(ValueParser::path_buf())
 92 |                 .value_name("FILE")
 93 |                 .required(true),
 94 |         )
 95 | }
 96 | 
 97 | fn create_export_subcommand() -> Command {
 98 |     Command::new("export")
 99 |         .about("Export subscriptions")
100 |         .arg(
101 |             Arg::new("format")
102 |                 .short('f')
103 |                 .long("format")
104 |                 .help("Format of the export file")
105 |                 .value_name("FORMAT")
106 |                 .default_value("youtube_csv")
107 |                 .value_parser(["youtube_csv", "newpipe"]),
108 |         )
109 |         .arg(
110 |             Arg::new("target")
111 |                 .help("Path to the export file")
112 |                 .value_parser(ValueParser::path_buf())
113 |                 .value_name("FILE")
114 |                 .required(true),
115 |         )
116 | }
117 | 


--------------------------------------------------------------------------------
/src/search.rs:
--------------------------------------------------------------------------------
  1 | use crate::app::{State, StatefulList};
  2 | use std::fmt::Display;
  3 | 
  4 | #[derive(Default)]
  5 | pub enum SearchState {
  6 |     #[default]
  7 |     NotSearching,
  8 |     PoppedKey,
  9 |     PushedKey,
 10 | }
 11 | 
 12 | #[derive(Default, PartialEq, Eq, Debug, Clone)]
 13 | pub enum SearchDirection {
 14 |     #[default]
 15 |     Forward,
 16 |     Backward,
 17 | }
 18 | 
 19 | impl SearchDirection {
 20 |     fn reverse(&self) -> SearchDirection {
 21 |         match self {
 22 |             SearchDirection::Forward => SearchDirection::Backward,
 23 |             SearchDirection::Backward => SearchDirection::Forward,
 24 |         }
 25 |     }
 26 | }
 27 | 
 28 | type Match = (usize, String);
 29 | type LastSearch = (String, SearchDirection);
 30 | 
 31 | #[derive(Default)]
 32 | pub struct Search {
 33 |     matches: Vec<Match>,
 34 |     pub pattern: String,
 35 |     pub state: SearchState,
 36 |     pub direction: SearchDirection,
 37 |     pub recovery_index: Option<usize>,
 38 |     last_search: Option<LastSearch>,
 39 | }
 40 | 
 41 | impl Search {
 42 |     pub fn search<T: Display, S: State>(&mut self, list: &mut StatefulList<T, S>, pattern: &str) {
 43 |         if pattern.is_empty() {
 44 |             self.recover_item(list);
 45 |             return;
 46 |         }
 47 |         self.pattern = pattern.to_lowercase();
 48 |         match self.state {
 49 |             SearchState::NotSearching | SearchState::PoppedKey => {
 50 |                 if let SearchState::NotSearching = self.state {
 51 |                     self.recovery_index = list.state.selected();
 52 |                 }
 53 |                 self.matches = list
 54 |                     .items
 55 |                     .iter()
 56 |                     .enumerate()
 57 |                     .map(|(i, item)| (i, item.to_string().to_lowercase()))
 58 |                     .filter(|(_, item)| item.contains(&self.pattern))
 59 |                     .collect();
 60 |             }
 61 |             SearchState::PushedKey => {
 62 |                 self.matches = self
 63 |                     .matches
 64 |                     .drain(..)
 65 |                     .filter(|(_, text)| text.contains(&self.pattern))
 66 |                     .collect();
 67 |             }
 68 |         }
 69 |         if self.any_matches() {
 70 |             match self.direction {
 71 |                 SearchDirection::Forward => self.next_match(list),
 72 |                 SearchDirection::Backward => self.prev_match(list),
 73 |             }
 74 |         } else {
 75 |             self.recover_item(list);
 76 |         }
 77 |     }
 78 | 
 79 |     fn indices(&self) -> Vec<usize> {
 80 |         self.matches.iter().map(|m| m.0).collect()
 81 |     }
 82 | 
 83 |     pub fn any_matches(&self) -> bool {
 84 |         !self.matches.is_empty()
 85 |     }
 86 | 
 87 |     pub fn complete_search(&mut self, abort: bool) {
 88 |         self.state = SearchState::NotSearching;
 89 |         self.recovery_index = None;
 90 |         self.matches.clear();
 91 | 
 92 |         let pattern = std::mem::take(&mut self.pattern);
 93 | 
 94 |         if !abort {
 95 |             self.last_search = Some((pattern, self.direction.clone()));
 96 |         }
 97 |     }
 98 | 
 99 |     pub fn recover_item<T, S: State>(&mut self, list: &mut StatefulList<T, S>) {
100 |         if self.recovery_index.is_some() {
101 |             list.state.select(self.recovery_index);
102 |         }
103 |     }
104 | 
105 |     fn jump_to_match<T, S: State>(
106 |         &self,
107 |         list: &mut StatefulList<T, S>,
108 |         match_index: Option<usize>,
109 |     ) {
110 |         if match_index.is_some() {
111 |             list.state.select(match_index);
112 |         }
113 |     }
114 | 
115 |     pub fn next_match<T, S: State>(&mut self, list: &mut StatefulList<T, S>) {
116 |         let indices = self.indices();
117 |         let match_index = if let Some(recovery_index) = self.recovery_index {
118 |             indices
119 |                 .iter()
120 |                 .find(|index| **index > recovery_index)
121 |                 .or_else(|| indices.first())
122 |         } else {
123 |             indices.first()
124 |         }
125 |         .copied();
126 |         self.jump_to_match(list, match_index);
127 |     }
128 | 
129 |     pub fn prev_match<T, S: State>(&mut self, list: &mut StatefulList<T, S>) {
130 |         let indices = self.indices();
131 |         let match_index = if let Some(recovery_index) = self.recovery_index {
132 |             indices
133 |                 .iter()
134 |                 .rev()
135 |                 .find(|index| **index < recovery_index)
136 |                 .or_else(|| indices.last())
137 |         } else {
138 |             indices.last()
139 |         }
140 |         .copied();
141 |         self.jump_to_match(list, match_index);
142 |     }
143 | 
144 |     pub fn repeat_last<T: Display, S: State>(
145 |         &mut self,
146 |         list: &mut StatefulList<T, S>,
147 |         opposite_dir: bool,
148 |     ) {
149 |         if let Some((pattern, direction)) = &self.last_search {
150 |             let pattern = pattern.clone();
151 |             self.direction = if opposite_dir {
152 |                 direction.reverse()
153 |             } else {
154 |                 direction.clone()
155 |             };
156 |             self.search(list, &pattern);
157 |         }
158 |     }
159 | }
160 | 


--------------------------------------------------------------------------------
/src/import.rs:
--------------------------------------------------------------------------------
  1 | use crate::channel::{Channel, ListItem, RefreshState};
  2 | use anyhow::Result;
  3 | use serde::{Deserialize, Serialize};
  4 | use std::{fmt::Display, fs::File, io::BufReader, path::Path};
  5 | 
  6 | #[derive(Clone, Copy)]
  7 | pub enum Format {
  8 |     YoutubeCsv,
  9 |     NewPipe,
 10 | }
 11 | 
 12 | impl From<&str> for Format {
 13 |     fn from(format: &str) -> Self {
 14 |         match format {
 15 |             "newpipe" => Format::NewPipe,
 16 |             _ => Format::YoutubeCsv,
 17 |         }
 18 |     }
 19 | }
 20 | 
 21 | pub trait Import {
 22 |     fn channel_id(&self) -> String;
 23 |     fn channel_title(&self) -> String;
 24 | }
 25 | 
 26 | #[derive(Deserialize, Serialize)]
 27 | pub struct YoutubeCsv {
 28 |     #[serde(rename = "Channel Id")]
 29 |     pub channel_id: String,
 30 |     #[serde(rename = "Channel Url")]
 31 |     channel_url: String,
 32 |     #[serde(rename = "Channel Title")]
 33 |     pub channel_title: String,
 34 | }
 35 | 
 36 | impl YoutubeCsv {
 37 |     pub fn read_subscriptions(path: &Path) -> Result<Vec<ImportItem>> {
 38 |         let file = File::open(path)?;
 39 |         let mut rdr = csv::Reader::from_reader(file);
 40 | 
 41 |         let mut subscriptions: Vec<YoutubeCsv> = Vec::new();
 42 | 
 43 |         for record in rdr.deserialize() {
 44 |             subscriptions.push(record?);
 45 |         }
 46 | 
 47 |         Ok(subscriptions.into_iter().map(ImportItem::from).collect())
 48 |     }
 49 | 
 50 |     pub fn export(channels: &[Channel], path: &Path) -> Result<()> {
 51 |         let file = File::create(path)?;
 52 |         let mut wtr = csv::Writer::from_writer(file);
 53 | 
 54 |         for channel in channels {
 55 |             wtr.serialize(YoutubeCsv {
 56 |                 channel_id: channel.channel_id.clone(),
 57 |                 channel_url: format!("http://www.youtube.com/channel/{}", channel.channel_id),
 58 |                 channel_title: channel.channel_name.clone(),
 59 |             })?;
 60 |         }
 61 | 
 62 |         wtr.flush()?;
 63 | 
 64 |         Ok(())
 65 |     }
 66 | }
 67 | 
 68 | impl Import for YoutubeCsv {
 69 |     fn channel_id(&self) -> String {
 70 |         self.channel_id.clone()
 71 |     }
 72 | 
 73 |     fn channel_title(&self) -> String {
 74 |         self.channel_title.clone()
 75 |     }
 76 | }
 77 | 
 78 | #[derive(Deserialize, Serialize, Clone)]
 79 | pub struct NewPipeInner {
 80 |     service_id: u64,
 81 |     pub url: String,
 82 |     pub name: String,
 83 | }
 84 | 
 85 | impl NewPipeInner {
 86 |     fn new(channel: &Channel) -> Self {
 87 |         Self {
 88 |             service_id: 0,
 89 |             url: format!("http://www.youtube.com/channel/{}", channel.channel_id),
 90 |             name: channel.channel_name.clone(),
 91 |         }
 92 |     }
 93 | }
 94 | 
 95 | #[derive(Deserialize, Serialize)]
 96 | pub struct NewPipe {
 97 |     app_version: String,
 98 |     app_version_int: u64,
 99 |     pub subscriptions: Vec<NewPipeInner>,
100 | }
101 | 
102 | impl NewPipe {
103 |     fn new(subscriptions: Vec<NewPipeInner>) -> Self {
104 |         Self {
105 |             app_version: "0.23.0".to_string(),
106 |             app_version_int: 986,
107 |             subscriptions,
108 |         }
109 |     }
110 | 
111 |     pub fn read_subscriptions(path: &Path) -> Result<Vec<ImportItem>> {
112 |         let file = File::open(path)?;
113 |         let rdr = BufReader::new(file);
114 | 
115 |         let newpipe: NewPipe = serde_json::from_reader(rdr)?;
116 | 
117 |         Ok(newpipe
118 |             .subscriptions
119 |             .into_iter()
120 |             .map(ImportItem::from)
121 |             .collect())
122 |     }
123 | 
124 |     pub fn export(channels: &[Channel], path: &Path) -> Result<()> {
125 |         let file = File::create(path)?;
126 | 
127 |         let subs = channels.iter().map(NewPipeInner::new).collect();
128 | 
129 |         let newpipe = NewPipe::new(subs);
130 | 
131 |         Ok(serde_json::to_writer(file, &newpipe)?)
132 |     }
133 | }
134 | 
135 | impl Import for NewPipeInner {
136 |     fn channel_id(&self) -> String {
137 |         self.url
138 |             .rsplit_once('/')
139 |             .map(|(_, id)| id)
140 |             .unwrap()
141 |             .to_string()
142 |     }
143 | 
144 |     fn channel_title(&self) -> String {
145 |         self.name.clone()
146 |     }
147 | }
148 | 
149 | pub struct ImportItem {
150 |     pub sub_state: RefreshState,
151 |     pub channel_title: String,
152 |     pub channel_id: String,
153 | }
154 | 
155 | impl<T: Import> From<T> for ImportItem {
156 |     fn from(item: T) -> Self {
157 |         Self {
158 |             sub_state: RefreshState::Completed,
159 |             channel_title: item.channel_title(),
160 |             channel_id: item.channel_id(),
161 |         }
162 |     }
163 | }
164 | 
165 | impl ListItem for ImportItem {
166 |     fn id(&self) -> &str {
167 |         &self.channel_id
168 |     }
169 | }
170 | 
171 | impl Display for ImportItem {
172 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
173 |         write!(
174 |             f,
175 |             "{} {}",
176 |             match self.sub_state {
177 |                 RefreshState::ToBeRefreshed => "□",
178 |                 RefreshState::Refreshing => "■",
179 |                 _ => "",
180 |             },
181 |             self.channel_title
182 |         )
183 |     }
184 | }
185 | 


--------------------------------------------------------------------------------
/src/player.rs:
--------------------------------------------------------------------------------
  1 | use crate::TX;
  2 | use crate::client::{Client, ClientRequest};
  3 | use crate::{OPTIONS, api::Api, app::VideoPlayer, emit_msg, stream_formats::Formats};
  4 | use anyhow::Result;
  5 | use std::path::Path;
  6 | use std::process::Stdio;
  7 | use tokio::process::Command;
  8 | 
  9 | pub async fn run_detached(mut command: Command) -> Result<()> {
 10 |     #[cfg(unix)]
 11 |     unsafe {
 12 |         command.pre_exec(|| {
 13 |             if libc::setsid() < 0 {
 14 |                 return Err(std::io::Error::last_os_error());
 15 |             }
 16 | 
 17 |             Ok(())
 18 |         })
 19 |     };
 20 | 
 21 |     let mut child = command
 22 |         .stdin(Stdio::null())
 23 |         .stdout(Stdio::null())
 24 |         .stderr(Stdio::null())
 25 |         .spawn()?;
 26 | 
 27 |     let exit_status = child.wait().await?;
 28 | 
 29 |     if let Some(code) = exit_status.code()
 30 |         && code != 0
 31 |     {
 32 |         Err(anyhow::anyhow!("Process exited with status code {code}"))
 33 |     } else {
 34 |         Ok(())
 35 |     }
 36 | }
 37 | 
 38 | pub async fn play_from_formats(instance: Box<dyn Api>, formats: Formats) -> Result<()> {
 39 |     let (video_url, audio_url) = if formats.use_adaptive_streams {
 40 |         (
 41 |             formats.video_formats.get_selected_item().get_url(),
 42 |             Some(formats.audio_formats.get_selected_item().get_url()),
 43 |         )
 44 |     } else {
 45 |         (formats.formats.get_selected_item().get_url(), None)
 46 |     };
 47 | 
 48 |     let captions = instance.get_caption_paths(&formats).await;
 49 | 
 50 |     let chapters = formats
 51 |         .chapters
 52 |         .and_then(|chapters| chapters.write_to_file(&formats.id).ok());
 53 | 
 54 |     let player_command = gen_video_player_command(
 55 |         video_url,
 56 |         audio_url,
 57 |         &captions,
 58 |         chapters.as_deref(),
 59 |         &formats.title,
 60 |     );
 61 | 
 62 |     play_video(player_command, &formats.id).await
 63 | }
 64 | 
 65 | pub async fn play_using_ytdlp(video_id: &str) -> Result<()> {
 66 |     let url = format!("{}/watch?v={}", "https://www.youtube.com", video_id);
 67 | 
 68 |     let mut player_command = Command::new(&OPTIONS.mpv_path);
 69 |     player_command.arg(url);
 70 | 
 71 |     play_video(player_command, video_id).await
 72 | }
 73 | 
 74 | async fn play_video(player_command: Command, video_id: &str) -> Result<()> {
 75 |     emit_msg!("Launching video player");
 76 |     TX.send(ClientRequest::SetWatched(video_id.to_owned(), true))?;
 77 | 
 78 |     if let Err(e) = run_detached(player_command).await {
 79 |         emit_msg!(error, e.to_string());
 80 |         TX.send(ClientRequest::SetWatched(video_id.to_owned(), false))?;
 81 |     }
 82 | 
 83 |     Ok(())
 84 | }
 85 | 
 86 | fn gen_video_player_command(
 87 |     video_url: &str,
 88 |     audio_url: Option<&str>,
 89 |     captions: &[String],
 90 |     chapters: Option<&Path>,
 91 |     title: &str,
 92 | ) -> Command {
 93 |     let mut command;
 94 |     match OPTIONS.video_player_for_stream_formats {
 95 |         VideoPlayer::Mpv => {
 96 |             command = Command::new(&OPTIONS.mpv_path);
 97 |             command
 98 |                 .arg(format!("--force-media-title={title}"))
 99 |                 .arg("--no-ytdl")
100 |                 .arg(video_url);
101 | 
102 |             if let Some(audio_url) = audio_url {
103 |                 command.arg(format!("--audio-file={audio_url}"));
104 |             }
105 | 
106 |             for caption in captions {
107 |                 command.arg(format!("--sub-file={caption}"));
108 |             }
109 | 
110 |             if let Some(path) = chapters {
111 |                 command.arg(format!("--chapters-file={}", path.display()));
112 |             }
113 |         }
114 |         VideoPlayer::Vlc => {
115 |             command = Command::new(&OPTIONS.vlc_path);
116 |             command
117 |                 .arg("--no-video-title-show")
118 |                 .arg(format!("--input-title-format={title}"))
119 |                 .arg("--play-and-exit")
120 |                 .arg(video_url);
121 | 
122 |             if let Some(audio_url) = audio_url {
123 |                 command.arg(format!("--input-slave={audio_url}"));
124 |             }
125 | 
126 |             if !captions.is_empty() {
127 |                 command.arg(format!("--sub-file={}", captions.join(" ")));
128 |             }
129 |         }
130 |     }
131 | 
132 |     command
133 | }
134 | 
135 | pub async fn open_in_invidious(client: &mut Client, url_component: &str) -> Result<()> {
136 |     if client.invidious_instance.is_none()
137 |         && let Err(e) = client.set_instance().await
138 |     {
139 |         emit_msg!(error, e.to_string());
140 |         return Ok(());
141 |     }
142 | 
143 |     let instance = client
144 |         .invidious_instance
145 |         .as_ref()
146 |         .expect("The function should return before if an instance couldn't be set");
147 | 
148 |     let url = format!("{}/{}", instance.domain, url_component);
149 | 
150 |     open_in_browser(&url);
151 | 
152 |     Ok(())
153 | }
154 | 
155 | pub fn open_in_youtube(url_component: &str) {
156 |     open_in_browser(&format!("https://www.youtube.com/{url_component}"));
157 | }
158 | 
159 | pub fn open_in_browser(url: &str) {
160 |     let commands = open::commands(url);
161 |     let mut last_error = None;
162 | 
163 |     tokio::spawn(async move {
164 |         for cmd in commands {
165 |             let command = Command::from(cmd);
166 | 
167 |             match run_detached(command).await {
168 |                 Ok(()) => return Ok(()),
169 |                 Err(err) => last_error = Some(err),
170 |             }
171 |         }
172 | 
173 |         emit_msg!(error, &last_error.unwrap().to_string());
174 |         anyhow::Ok(())
175 |     });
176 | }
177 | 


--------------------------------------------------------------------------------
/src/channel.rs:
--------------------------------------------------------------------------------
  1 | use crate::{OPTIONS, THEME, config::options::EnabledTabs};
  2 | use bitflags::bitflags;
  3 | use chrono::DateTime;
  4 | use ratatui::text::{Line, Span};
  5 | use serde::{Deserialize, de};
  6 | use serde_json::Value;
  7 | use std::fmt::Display;
  8 | 
  9 | #[derive(Deserialize, PartialEq, Debug, Clone, Copy)]
 10 | #[serde(rename_all(deserialize = "lowercase"))]
 11 | pub enum ChannelTab {
 12 |     Videos,
 13 |     Shorts,
 14 |     Streams,
 15 | }
 16 | 
 17 | impl From<u8> for ChannelTab {
 18 |     fn from(value: u8) -> Self {
 19 |         match value {
 20 |             0b001 => ChannelTab::Videos,
 21 |             0b010 => ChannelTab::Shorts,
 22 |             0b100 => ChannelTab::Streams,
 23 |             _ => unreachable!("The function should only be used for `EnabledTabs` names."),
 24 |         }
 25 |     }
 26 | }
 27 | 
 28 | impl Display for ChannelTab {
 29 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 30 |         write!(
 31 |             f,
 32 |             "{}",
 33 |             match self {
 34 |                 ChannelTab::Videos => "videos",
 35 |                 ChannelTab::Shorts => "shorts",
 36 |                 ChannelTab::Streams => "streams",
 37 |             }
 38 |         )
 39 |     }
 40 | }
 41 | 
 42 | pub fn tabs_to_be_loaded() -> impl Iterator<Item = ChannelTab> {
 43 |     if OPTIONS.hide_disabled_tabs {
 44 |         OPTIONS.tabs.iter()
 45 |     } else {
 46 |         EnabledTabs::all().iter()
 47 |     }
 48 |     .map(|tab| tab.bits().into())
 49 | }
 50 | 
 51 | #[derive(Clone, Copy)]
 52 | pub enum RefreshState {
 53 |     ToBeRefreshed,
 54 |     Refreshing,
 55 |     Completed,
 56 |     Failed,
 57 | }
 58 | 
 59 | pub trait ListItem {
 60 |     fn id(&self) -> &str;
 61 | }
 62 | 
 63 | pub struct Channel {
 64 |     pub channel_id: String,
 65 |     pub channel_name: String,
 66 |     pub refresh_state: RefreshState,
 67 |     pub new_video: bool,
 68 |     pub last_refreshed: Option<u64>,
 69 | }
 70 | 
 71 | impl Channel {
 72 |     pub fn new(channel_id: String, channel_name: String, last_refreshed: Option<u64>) -> Self {
 73 |         Self {
 74 |             channel_id,
 75 |             channel_name,
 76 |             refresh_state: RefreshState::Completed,
 77 |             new_video: false,
 78 |             last_refreshed,
 79 |         }
 80 |     }
 81 | 
 82 |     pub fn set_to_be_refreshed(&mut self) {
 83 |         self.refresh_state = RefreshState::ToBeRefreshed;
 84 |     }
 85 | }
 86 | 
 87 | impl ListItem for Channel {
 88 |     fn id(&self) -> &str {
 89 |         &self.channel_id
 90 |     }
 91 | }
 92 | 
 93 | impl Display for Channel {
 94 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 95 |         write!(f, "{}", self.channel_name)
 96 |     }
 97 | }
 98 | 
 99 | impl From<&Channel> for Line<'_> {
100 |     fn from(value: &Channel) -> Self {
101 |         let refresh_indicator = match value.refresh_state {
102 |             RefreshState::ToBeRefreshed => "□ ",
103 |             RefreshState::Refreshing => "■ ",
104 |             RefreshState::Completed => "",
105 |             RefreshState::Failed => "✗ ",
106 |         };
107 | 
108 |         Line::from(vec![
109 |             Span::raw(format!("{}{}", refresh_indicator, value.channel_name)),
110 |             Span::styled(
111 |                 if value.new_video { " [N]" } else { "" },
112 |                 THEME.new_video_indicator,
113 |             ),
114 |         ])
115 |     }
116 | }
117 | 
118 | fn deserialize_published_date<'de, D>(deserializer: D) -> Result<u64, D::Error>
119 | where
120 |     D: de::Deserializer<'de>,
121 | {
122 |     let date_str: &str = de::Deserialize::deserialize(deserializer)?;
123 |     let date = DateTime::parse_from_rfc3339(date_str).unwrap();
124 | 
125 |     Ok(date.timestamp() as u64)
126 | }
127 | 
128 | bitflags! {
129 |     pub struct HideVideos: u8 {
130 |         const WATCHED      = 0b0001;
131 |         const MEMBERS_ONLY = 0b0010;
132 |     }
133 | }
134 | 
135 | #[derive(Deserialize)]
136 | pub struct Video {
137 |     #[serde(skip_deserializing)]
138 |     pub channel_name: Option<String>,
139 |     #[serde(rename = "videoId")]
140 |     pub video_id: String,
141 |     pub title: String,
142 |     #[serde(deserialize_with = "deserialize_published_date")]
143 |     pub published: u64,
144 |     #[serde(skip_deserializing)]
145 |     pub published_text: String,
146 |     pub length: Option<u32>,
147 |     #[serde(skip_deserializing)]
148 |     pub watched: bool,
149 |     #[serde(skip_deserializing)]
150 |     pub members_only: bool,
151 |     #[serde(skip_deserializing)]
152 |     pub new: bool,
153 | }
154 | 
155 | impl Video {
156 |     pub fn needs_update(&self, other: &Video) -> bool {
157 |         self.title != other.title
158 |             || self.length != other.length
159 |             || self.members_only != other.members_only
160 |     }
161 | }
162 | 
163 | impl From<&Value> for Video {
164 |     fn from(video_json: &Value) -> Self {
165 |         let is_upcoming = video_json["isUpcoming"].as_bool().unwrap();
166 |         let mut published = video_json["published"].as_u64().unwrap();
167 |         let published_text = video_json
168 |             .get("publishedText")
169 |             .and_then(Value::as_str)
170 |             .map(ToString::to_string)
171 |             .unwrap_or_default();
172 |         let mut length = video_json["lengthSeconds"].as_u64().unwrap();
173 | 
174 |         if is_upcoming {
175 |             let premiere_timestamp = video_json["premiereTimestamp"].as_u64().unwrap();
176 | 
177 |             // In Invidious API, all shorts are marked as upcoming but the published key needs to be
178 |             // used for the release time. If the premiere timestamp is 0, assume it is a shorts.
179 |             if premiere_timestamp != 0 {
180 |                 published = premiere_timestamp;
181 |             }
182 |         }
183 | 
184 |         if length == 0 {
185 |             length = 60;
186 |         }
187 | 
188 |         Video {
189 |             channel_name: None,
190 |             video_id: video_json["videoId"].as_str().unwrap().to_string(),
191 |             title: video_json["title"].as_str().unwrap().to_string(),
192 |             published,
193 |             published_text,
194 |             length: Some(length as u32),
195 |             watched: false,
196 |             members_only: false,
197 |             new: true,
198 |         }
199 |     }
200 | }
201 | 
202 | impl ListItem for Video {
203 |     fn id(&self) -> &str {
204 |         &self.video_id
205 |     }
206 | }
207 | 
208 | impl Display for Video {
209 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
210 |         write!(f, "{}", self.title)
211 |     }
212 | }
213 | 


--------------------------------------------------------------------------------
/src/stream_formats.rs:
--------------------------------------------------------------------------------
  1 | use crate::OPTIONS;
  2 | use crate::api::Chapters;
  3 | use crate::channel::ListItem;
  4 | use crate::{
  5 |     api::{Format, VideoInfo},
  6 |     app::SelectionList,
  7 | };
  8 | use std::fmt::Display;
  9 | 
 10 | #[derive(Default)]
 11 | pub struct Formats {
 12 |     pub title: String,
 13 |     pub id: String,
 14 |     pub video_formats: SelectionList<Format>,
 15 |     pub audio_formats: SelectionList<Format>,
 16 |     pub formats: SelectionList<Format>,
 17 |     pub captions: SelectionList<Format>,
 18 |     pub chapters: Option<Chapters>,
 19 |     pub selected_tab: usize,
 20 |     pub use_adaptive_streams: bool,
 21 | }
 22 | 
 23 | impl Formats {
 24 |     pub fn new(title: String, id: String, video_info: VideoInfo) -> Self {
 25 |         let mut formats = Formats {
 26 |             title,
 27 |             id,
 28 |             video_formats: SelectionList::new(video_info.video_formats),
 29 |             audio_formats: SelectionList::new(video_info.audio_formats),
 30 |             formats: SelectionList::new(video_info.format_streams),
 31 |             captions: SelectionList::new(video_info.captions),
 32 |             chapters: video_info.chapters,
 33 |             selected_tab: 0,
 34 |             use_adaptive_streams: OPTIONS.prefer_dash_formats,
 35 |         };
 36 | 
 37 |         formats.set_preferred();
 38 | 
 39 |         formats
 40 |     }
 41 | 
 42 |     fn set_preferred(&mut self) {
 43 |         let mut video_idx = None;
 44 | 
 45 |         for (idx, format) in self.video_formats.items.iter().enumerate() {
 46 |             if let Some(preferred_codec) = &OPTIONS.preferred_video_codec {
 47 |                 if OPTIONS.video_quality == format.get_quality() {
 48 |                     video_idx = Some(idx);
 49 |                 }
 50 | 
 51 |                 if *preferred_codec == format.get_codec() {
 52 |                     match video_idx {
 53 |                         Some(video_idx) if idx == video_idx => break,
 54 |                         None => video_idx = Some(idx),
 55 |                         _ => (),
 56 |                     }
 57 |                 }
 58 |             } else if OPTIONS.video_quality == format.get_quality() {
 59 |                 video_idx = Some(idx);
 60 |                 break;
 61 |             }
 62 |         }
 63 | 
 64 |         self.video_formats.items[video_idx.unwrap_or_default()].selected = true;
 65 | 
 66 |         let mut audio_idx = None;
 67 | 
 68 |         for (idx, format) in self.audio_formats.items.iter().enumerate() {
 69 |             if matches!(&format.item, Format::Audio { language,.. } if language.as_ref().is_some_and(|(_, is_default)| *is_default))
 70 |             {
 71 |                 audio_idx = Some(idx);
 72 | 
 73 |                 if OPTIONS.preferred_audio_codec.is_none() {
 74 |                     break;
 75 |                 }
 76 |             }
 77 | 
 78 |             if OPTIONS
 79 |                 .preferred_audio_codec
 80 |                 .as_ref()
 81 |                 .is_some_and(|preferred| *preferred == format.get_codec())
 82 |             {
 83 |                 match audio_idx {
 84 |                     Some(audio_idx) if idx == audio_idx => break,
 85 |                     None => audio_idx = Some(idx),
 86 |                     _ => (),
 87 |                 }
 88 |             }
 89 |         }
 90 | 
 91 |         self.audio_formats.items[audio_idx.unwrap_or_default()].selected = true;
 92 | 
 93 |         if let Some(item) = self.formats.items.first_mut() {
 94 |             item.selected = true;
 95 |         }
 96 | 
 97 |         for language in &OPTIONS.subtitle_languages {
 98 |             if let Some(caption) = self
 99 |                 .captions
100 |                 .items
101 |                 .iter_mut()
102 |                 .find(|caption| caption.item.id() == language)
103 |             {
104 |                 caption.selected = true;
105 |             }
106 |         }
107 | 
108 |         for caption in &mut self.captions.items {
109 |             if OPTIONS
110 |                 .subtitle_languages
111 |                 .iter()
112 |                 .any(|language| *language == caption.item.id() || matches!(caption.item.id().split_once('-'), Some((lang, _)) if lang == *language))
113 |             {
114 |                 caption.selected = true;
115 |             }
116 |         }
117 |     }
118 | 
119 |     pub fn switch_format_type(&mut self) {
120 |         self.use_adaptive_streams = !self.use_adaptive_streams;
121 |         self.selected_tab = 0;
122 |     }
123 | 
124 |     pub fn get_mut_selected_tab(&mut self) -> &mut SelectionList<Format> {
125 |         match self.selected_tab {
126 |             0 if self.use_adaptive_streams => &mut self.video_formats,
127 |             0 => &mut self.formats,
128 |             1 => &mut self.audio_formats,
129 |             2 => &mut self.captions,
130 |             _ => panic!(),
131 |         }
132 |     }
133 | 
134 |     pub fn next_tab(&mut self) {
135 |         self.selected_tab = (self.selected_tab + 1) % 3;
136 | 
137 |         if !self.use_adaptive_streams && self.selected_tab == 1 {
138 |             self.next_tab();
139 |         }
140 | 
141 |         if self.get_mut_selected_tab().items.is_empty() {
142 |             self.next_tab();
143 |         }
144 |     }
145 | 
146 |     pub fn previous_tab(&mut self) {
147 |         self.selected_tab = if self.selected_tab == 0 {
148 |             2
149 |         } else {
150 |             self.selected_tab - 1
151 |         };
152 | 
153 |         if !self.use_adaptive_streams && self.selected_tab == 1 {
154 |             self.previous_tab();
155 |         }
156 | 
157 |         if self.get_mut_selected_tab().items.is_empty() {
158 |             self.previous_tab();
159 |         }
160 |     }
161 | }
162 | 
163 | impl Display for Format {
164 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
165 |         match self {
166 |             Format::Video {
167 |                 quality,
168 |                 fps,
169 |                 r#type,
170 |                 ..
171 |             } => write!(f, "{quality} @ {fps} fps, {type}"),
172 |             Format::Audio {
173 |                 language,
174 |                 bitrate,
175 |                 r#type,
176 |                 ..
177 |             } => write!(
178 |                 f,
179 |                 "{}{}, {}",
180 |                 language
181 |                     .as_ref()
182 |                     .map_or(String::new(), |(language, _)| format!("{language}, ")),
183 |                 bitrate,
184 |                 r#type
185 |             ),
186 |             Format::Stream {
187 |                 quality,
188 |                 fps,
189 |                 bitrate,
190 |                 r#type,
191 |                 ..
192 |             } => write!(
193 |                 f,
194 |                 "{} @ {} fps, {}, {}",
195 |                 quality,
196 |                 fps,
197 |                 bitrate.clone().unwrap_or_default(),
198 |                 r#type
199 |             ),
200 |             Format::Caption { label, .. } => write!(f, "{label}"),
201 |         }
202 |     }
203 | }
204 | 


--------------------------------------------------------------------------------
/src/protobuf.rs:
--------------------------------------------------------------------------------
  1 | use base64::{Engine, prelude::BASE64_URL_SAFE_NO_PAD};
  2 | use itertools::Itertools;
  3 | use serde_json::Value;
  4 | 
  5 | #[derive(Debug, PartialEq)]
  6 | enum WireType {
  7 |     /// int32, int64, uint32, uint64, sint32, sint64, bool, enum
  8 |     Varint,
  9 |     /// fixed64, sfixed64, double
 10 |     I64,
 11 |     /// string, bytes, embedded messages, packed repeated fields
 12 |     Len,
 13 |     /// group start (deprecated)
 14 |     SGroup,
 15 |     /// group end (deprecated)
 16 |     EGroup,
 17 |     /// fixed32, sfixed32, float
 18 |     I32,
 19 | }
 20 | 
 21 | impl TryFrom<u64> for WireType {
 22 |     type Error = anyhow::Error;
 23 | 
 24 |     fn try_from(value: u64) -> Result<Self, Self::Error> {
 25 |         let id = match value {
 26 |             0 => WireType::Varint,
 27 |             1 => WireType::I64,
 28 |             2 => WireType::Len,
 29 |             3 => WireType::SGroup,
 30 |             4 => WireType::EGroup,
 31 |             5 => WireType::I32,
 32 |             _ => return Err(anyhow::anyhow!("invalid wire type id")),
 33 |         };
 34 | 
 35 |         Ok(id)
 36 |     }
 37 | }
 38 | 
 39 | #[derive(Debug, PartialEq)]
 40 | struct Tag {
 41 |     field_number: u64,
 42 |     wire_type: WireType,
 43 | }
 44 | 
 45 | fn parse_varint<T: Iterator<Item = u8>>(message: &mut T) -> Option<u64> {
 46 |     const MSB_MASK: u8 = 1 << 7;
 47 | 
 48 |     message
 49 |         .take_while_inclusive(|byte| byte & MSB_MASK != 0)
 50 |         .enumerate()
 51 |         .map(|(idx, byte)| u64::from(byte & !MSB_MASK) << (7 * idx))
 52 |         .reduce(|acc, byte| acc | byte)
 53 | }
 54 | 
 55 | fn parse_tag<T: Iterator<Item = u8>>(message: &mut T) -> Option<Tag> {
 56 |     let varint = parse_varint(message)?;
 57 | 
 58 |     Some(Tag {
 59 |         field_number: varint >> 3,
 60 |         wire_type: WireType::try_from(varint & 0b111).ok()?,
 61 |     })
 62 | }
 63 | 
 64 | fn parse_message<T: Iterator<Item = u8>>(message: &mut T) -> Option<Value> {
 65 |     let mut res = Value::default();
 66 | 
 67 |     while let Some(tag) = parse_tag(message) {
 68 |         let index = tag.field_number.to_string();
 69 | 
 70 |         match tag.wire_type {
 71 |             WireType::Varint => res[index] = parse_varint(message)?.into(),
 72 |             WireType::I64 => {
 73 |                 let bytes = message.take(8).collect::<Vec<u8>>();
 74 |                 res[index] = f64::from_le_bytes(bytes.try_into().ok()?).into();
 75 |             }
 76 |             WireType::Len => {
 77 |                 let len = parse_varint(message)?;
 78 |                 let submessage = message.take(len as usize).collect::<Vec<u8>>();
 79 | 
 80 |                 res[index] = if let Some(s) = String::from_utf8(submessage.clone())
 81 |                     .ok()
 82 |                     .filter(|s| !s.chars().any(char::is_control))
 83 |                 {
 84 |                     s.into()
 85 |                 } else {
 86 |                     let submessage = parse_message(&mut submessage.into_iter()).unwrap_or_default();
 87 |                     let mut value = res.get_mut(&index);
 88 | 
 89 |                     if let Some(value) = &mut value
 90 |                         && value.is_object()
 91 |                     {
 92 |                         Value::Array(vec![value.take(), submessage])
 93 |                     } else if let Some(value) = value.and_then(Value::as_array_mut) {
 94 |                         value.push(submessage);
 95 |                         continue;
 96 |                     } else {
 97 |                         submessage
 98 |                     }
 99 |                 }
100 |             }
101 |             WireType::I32 => {
102 |                 let bytes = message.take(4).collect::<Vec<u8>>();
103 |                 res[index] = f32::from_le_bytes(bytes.try_into().ok()?).into();
104 |             }
105 |             _ => return None,
106 |         };
107 |     }
108 | 
109 |     Some(res)
110 | }
111 | 
112 | pub fn decode_protobuf_from_binary(message: Vec<u8>) -> Option<Value> {
113 |     parse_message(&mut message.into_iter())
114 | }
115 | 
116 | pub fn decode_protobuf(message: &str) -> Option<Value> {
117 |     let bytes = BASE64_URL_SAFE_NO_PAD.decode(message).ok()?;
118 | 
119 |     decode_protobuf_from_binary(bytes)
120 | }
121 | 
122 | #[cfg(test)]
123 | mod tests {
124 |     use crate::protobuf::{Tag, WireType, decode_protobuf, decode_protobuf_from_binary, parse_tag};
125 | 
126 |     #[test]
127 |     fn tag() {
128 |         let bytes: [u8; 2] = [0xf2, 0x6];
129 | 
130 |         assert_eq!(
131 |             parse_tag(bytes.into_iter().by_ref()),
132 |             Some(Tag {
133 |                 field_number: 110,
134 |                 wire_type: WireType::Len
135 |             })
136 |         );
137 | 
138 |         let bytes = [0x8_u8];
139 | 
140 |         assert_eq!(
141 |             parse_tag(bytes.into_iter().by_ref()),
142 |             Some(Tag {
143 |                 field_number: 1,
144 |                 wire_type: WireType::Varint
145 |             })
146 |         );
147 |     }
148 | 
149 |     #[test]
150 |     fn a_simple_message() {
151 |         let bytes = vec![0x08, 0x96, 0x01];
152 | 
153 |         assert_eq!(
154 |             decode_protobuf_from_binary(bytes).unwrap()["1"].as_u64(),
155 |             Some(150)
156 |         );
157 |     }
158 | 
159 |     #[test]
160 |     fn string() {
161 |         let bytes = vec![0x12, 0x07, 0x74, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67];
162 | 
163 |         assert_eq!(
164 |             decode_protobuf_from_binary(bytes).unwrap()["2"].as_str(),
165 |             Some("testing")
166 |         );
167 |     }
168 | 
169 |     #[test]
170 |     fn non_varint32() {
171 |         let bytes = vec![0x5d, 0x00, 0x00, 0xde, 0x42];
172 | 
173 |         assert_eq!(
174 |             decode_protobuf_from_binary(bytes).unwrap()["11"].as_f64(),
175 |             Some(111.0)
176 |         );
177 |     }
178 | 
179 |     #[test]
180 |     fn non_varint64() {
181 |         let bytes = vec![0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x40];
182 | 
183 |         assert_eq!(
184 |             decode_protobuf_from_binary(bytes).unwrap()["12"].as_f64(),
185 |             Some(112.0)
186 |         );
187 |     }
188 | 
189 |     #[test]
190 |     fn submessage() {
191 |         let bytes = vec![0x1a, 0x03, 0x08, 0x96, 0x01];
192 | 
193 |         assert_eq!(
194 |             decode_protobuf_from_binary(bytes),
195 |             Some(serde_json::json!({
196 |                 "3": { "1": 150 }
197 |             }))
198 |         );
199 |     }
200 | 
201 |     #[test]
202 |     fn yt_tab() {
203 |         let message = "EgZ2aWRlb3PyBgQKAjoA";
204 | 
205 |         assert_eq!(
206 |             decode_protobuf(message),
207 |             Some(serde_json::json!({
208 |                 "2": "videos",
209 |                 "110": { "1": { "7": "" } }
210 |             }))
211 |         );
212 |     }
213 | 
214 |     #[test]
215 |     fn yt_xtags() {
216 |         let message = "ChQKBWFjb250EgtkdWJiZWQtYXV0bwoNCgRsYW5nEgVlbi1VUw";
217 | 
218 |         assert_eq!(
219 |             decode_protobuf(message),
220 |             Some(serde_json::json!({
221 |                 "1": [
222 |                     {"1": "acont", "2": "dubbed-auto"},
223 |                     {"1": "lang", "2": "en-US"},
224 |                 ]
225 |             }))
226 |         );
227 |     }
228 | }
229 | 


--------------------------------------------------------------------------------
/src/commands.rs:
--------------------------------------------------------------------------------
  1 | #[derive(Debug, PartialEq, Eq, Clone, Copy)]
  2 | pub enum Command {
  3 |     SetModeSubs,
  4 |     SetModeLatestVideos,
  5 |     OnDown,
  6 |     OnUp,
  7 |     OnLeft,
  8 |     OnRight,
  9 |     SelectFirst,
 10 |     SelectLast,
 11 |     NextTab,
 12 |     PreviousTab,
 13 |     JumpToChannel,
 14 |     ToggleHide,
 15 |     Subscribe,
 16 |     Unsubscribe,
 17 |     DeleteVideo,
 18 |     SearchForward,
 19 |     SearchBackward,
 20 |     RepeatLastSearch,
 21 |     RepeatLastSearchOpposite,
 22 |     SwitchApi,
 23 |     RefreshChannel,
 24 |     RefreshChannels,
 25 |     RefreshFailedChannels,
 26 |     LoadMoreVideos,
 27 |     OpenInInvidious,
 28 |     OpenInYoutube,
 29 |     PlayFromFormats,
 30 |     PlayUsingYtdlp,
 31 |     SelectFormats,
 32 |     ToggleWatched,
 33 |     ToggleHelp,
 34 |     ToggleTag,
 35 |     Quit,
 36 | }
 37 | 
 38 | impl TryFrom<&str> for Command {
 39 |     type Error = anyhow::Error;
 40 | 
 41 |     fn try_from(command: &str) -> Result<Self, Self::Error> {
 42 |         let command = match command {
 43 |             "set_mode_subs" => Command::SetModeSubs,
 44 |             "set_mode_latest_videos" => Command::SetModeLatestVideos,
 45 |             "on_down" => Command::OnDown,
 46 |             "on_up" => Command::OnUp,
 47 |             "on_left" => Command::OnLeft,
 48 |             "on_right" => Command::OnRight,
 49 |             "select_first" => Command::SelectFirst,
 50 |             "select_last" => Command::SelectLast,
 51 |             "next_tab" => Command::NextTab,
 52 |             "previous_tab" => Command::PreviousTab,
 53 |             "jump_to_channel" => Command::JumpToChannel,
 54 |             "toggle_hide" => Command::ToggleHide,
 55 |             "subscribe" => Command::Subscribe,
 56 |             "unsubscribe" => Command::Unsubscribe,
 57 |             "delete_video" => Command::DeleteVideo,
 58 |             "search_forward" => Command::SearchForward,
 59 |             "search_backward" => Command::SearchBackward,
 60 |             "repeat_last_search" => Command::RepeatLastSearch,
 61 |             "repeat_last_search_opposite" => Command::RepeatLastSearchOpposite,
 62 |             "switch_api" => Command::SwitchApi,
 63 |             "refresh_channel" => Command::RefreshChannel,
 64 |             "refresh_channels" => Command::RefreshChannels,
 65 |             "refresh_failed_channels" => Command::RefreshFailedChannels,
 66 |             "load_more_videos" => Command::LoadMoreVideos,
 67 |             "open_in_invidious" => Command::OpenInInvidious,
 68 |             "open_in_youtube" => Command::OpenInYoutube,
 69 |             "play_from_formats" => Command::PlayFromFormats,
 70 |             "play_using_ytdlp" => Command::PlayUsingYtdlp,
 71 |             "select_formats" => Command::SelectFormats,
 72 |             "toggle_watched" => Command::ToggleWatched,
 73 |             "toggle_help" => Command::ToggleHelp,
 74 |             "toggle_tag" => Command::ToggleTag,
 75 |             "quit" => Command::Quit,
 76 |             _ => anyhow::bail!("\"{}\" is an invalid command", command),
 77 |         };
 78 | 
 79 |         Ok(command)
 80 |     }
 81 | }
 82 | 
 83 | #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 84 | pub enum ImportCommand {
 85 |     Import,
 86 |     ToggleSelection,
 87 |     SelectAll,
 88 |     DeselectAll,
 89 | }
 90 | 
 91 | impl TryFrom<&str> for ImportCommand {
 92 |     type Error = anyhow::Error;
 93 | 
 94 |     fn try_from(command: &str) -> Result<Self, Self::Error> {
 95 |         let command = match command {
 96 |             "toggle_selection" => ImportCommand::ToggleSelection,
 97 |             "select_all" => ImportCommand::SelectAll,
 98 |             "deselect_all" => ImportCommand::DeselectAll,
 99 |             "import" => ImportCommand::Import,
100 |             _ => anyhow::bail!("\"{}\" is an invalid command", command),
101 |         };
102 | 
103 |         Ok(command)
104 |     }
105 | }
106 | 
107 | #[derive(Debug, PartialEq, Eq, Clone, Copy)]
108 | pub enum TagCommand {
109 |     CreateTag,
110 |     DeleteTag,
111 |     RenameTag,
112 |     SelectChannels,
113 |     ToggleSelection,
114 |     SelectAll,
115 |     DeselectAll,
116 |     Abort,
117 | }
118 | 
119 | impl TryFrom<&str> for TagCommand {
120 |     type Error = anyhow::Error;
121 | 
122 |     fn try_from(command: &str) -> Result<Self, Self::Error> {
123 |         let command = match command {
124 |             "toggle_selection" => TagCommand::ToggleSelection,
125 |             "select_all" => TagCommand::SelectAll,
126 |             "deselect_all" => TagCommand::DeselectAll,
127 |             "select_channels" => TagCommand::SelectChannels,
128 |             "create_tag" => TagCommand::CreateTag,
129 |             "delete_tag" => TagCommand::DeleteTag,
130 |             "rename_tag" => TagCommand::RenameTag,
131 |             "abort" => TagCommand::Abort,
132 |             _ => anyhow::bail!("\"{}\" is an invalid command", command),
133 |         };
134 | 
135 |         Ok(command)
136 |     }
137 | }
138 | 
139 | #[derive(Debug, PartialEq, Eq, Clone, Copy)]
140 | pub enum ChannelSelectionCommand {
141 |     Confirm,
142 |     Abort,
143 |     ToggleSelection,
144 |     SelectAll,
145 |     DeselectAll,
146 | }
147 | 
148 | impl TryFrom<&str> for ChannelSelectionCommand {
149 |     type Error = anyhow::Error;
150 | 
151 |     fn try_from(command: &str) -> Result<Self, Self::Error> {
152 |         let command = match command {
153 |             "confirm" => ChannelSelectionCommand::Confirm,
154 |             "abort" => ChannelSelectionCommand::Abort,
155 |             "toggle_selection" => ChannelSelectionCommand::ToggleSelection,
156 |             "select_all" => ChannelSelectionCommand::SelectAll,
157 |             "deselect_all" => ChannelSelectionCommand::DeselectAll,
158 |             _ => anyhow::bail!("\"{}\" is an invalid command", command),
159 |         };
160 | 
161 |         Ok(command)
162 |     }
163 | }
164 | 
165 | #[derive(Debug, PartialEq, Eq, Clone, Copy)]
166 | pub enum FormatSelectionCommand {
167 |     PreviousTab,
168 |     NextTab,
169 |     SwitchFormatType,
170 |     Select,
171 |     PlayVideo,
172 |     Abort,
173 | }
174 | 
175 | impl TryFrom<&str> for FormatSelectionCommand {
176 |     type Error = anyhow::Error;
177 | 
178 |     fn try_from(command: &str) -> Result<Self, Self::Error> {
179 |         let command = match command {
180 |             "previous_tab" => FormatSelectionCommand::PreviousTab,
181 |             "next_tab" => FormatSelectionCommand::NextTab,
182 |             "switch_format_type" => FormatSelectionCommand::SwitchFormatType,
183 |             "select" => FormatSelectionCommand::Select,
184 |             "play_video" => FormatSelectionCommand::PlayVideo,
185 |             "abort" => FormatSelectionCommand::Abort,
186 |             _ => anyhow::bail!("\"{}\" is an invalid command", command),
187 |         };
188 | 
189 |         Ok(command)
190 |     }
191 | }
192 | 
193 | #[derive(Debug, PartialEq, Eq, Clone, Copy)]
194 | pub enum HelpCommand {
195 |     ScrollUp,
196 |     ScrollDown,
197 |     GoToTop,
198 |     GoToBottom,
199 |     Abort,
200 | }
201 | 
202 | impl TryFrom<&str> for HelpCommand {
203 |     type Error = anyhow::Error;
204 | 
205 |     fn try_from(command: &str) -> Result<Self, Self::Error> {
206 |         let command = match command {
207 |             "scroll_up" => HelpCommand::ScrollUp,
208 |             "scroll_down" => HelpCommand::ScrollDown,
209 |             "go_to_top" => HelpCommand::GoToTop,
210 |             "go_to_bottom" => HelpCommand::GoToBottom,
211 |             "abort" => HelpCommand::Abort,
212 |             _ => anyhow::bail!("\"{}\" is an invalid command", command),
213 |         };
214 | 
215 |         Ok(command)
216 |     }
217 | }
218 | 


--------------------------------------------------------------------------------
/src/config/options.rs:
--------------------------------------------------------------------------------
  1 | use crate::{
  2 |     CLAP_ARGS,
  3 |     api::{ApiBackend, VideoFormat},
  4 |     app::VideoPlayer,
  5 |     channel::ChannelTab,
  6 | };
  7 | use bitflags::bitflags;
  8 | use serde::{Deserialize, de};
  9 | use std::path::PathBuf;
 10 | 
 11 | bitflags! {
 12 |     pub struct EnabledTabs: u8 {
 13 |         const VIDEOS  = 0b0001;
 14 |         const SHORTS  = 0b0010;
 15 |         const STREAMS = 0b0100;
 16 |     }
 17 | }
 18 | 
 19 | #[derive(Deserialize)]
 20 | pub struct UserOptions {
 21 |     database: Option<PathBuf>,
 22 |     instances: Option<PathBuf>,
 23 |     #[serde(default, deserialize_with = "deserialize_tabs")]
 24 |     tabs: Option<EnabledTabs>,
 25 |     hide_disabled_tabs: Option<bool>,
 26 |     api: Option<ApiBackend>,
 27 |     refresh_threshold: Option<u64>,
 28 |     rss_threshold: Option<usize>,
 29 |     tick_rate: Option<u64>,
 30 |     request_timeout: Option<u64>,
 31 |     highlight_symbol: Option<String>,
 32 |     video_player_for_stream_formats: Option<VideoPlayer>,
 33 |     #[serde(alias = "video_player")]
 34 |     mpv_path: Option<PathBuf>,
 35 |     vlc_path: Option<PathBuf>,
 36 |     hide_watched: Option<bool>,
 37 |     hide_members_only: Option<bool>,
 38 |     subtitle_languages: Option<Vec<String>>,
 39 |     prefer_dash_formats: Option<bool>,
 40 |     prefer_original_audio: Option<bool>,
 41 |     #[serde(default, deserialize_with = "deserialize_video_quality")]
 42 |     video_quality: Option<u16>,
 43 |     preferred_video_codec: Option<VideoFormat>,
 44 |     preferred_audio_codec: Option<VideoFormat>,
 45 |     chapters: Option<bool>,
 46 | }
 47 | 
 48 | pub struct Options {
 49 |     pub database: PathBuf,
 50 |     pub instances: PathBuf,
 51 |     pub tabs: EnabledTabs,
 52 |     pub hide_disabled_tabs: bool,
 53 |     pub api: ApiBackend,
 54 |     pub refresh_threshold: u64,
 55 |     pub rss_threshold: usize,
 56 |     pub tick_rate: u64,
 57 |     pub request_timeout: u64,
 58 |     pub highlight_symbol: String,
 59 |     pub video_player_for_stream_formats: VideoPlayer,
 60 |     pub mpv_path: PathBuf,
 61 |     pub vlc_path: PathBuf,
 62 |     pub hide_watched: bool,
 63 |     pub hide_members_only: bool,
 64 |     pub subtitle_languages: Vec<String>,
 65 |     pub prefer_dash_formats: bool,
 66 |     pub prefer_original_audio: bool,
 67 |     pub video_quality: u16,
 68 |     pub preferred_video_codec: Option<VideoFormat>,
 69 |     pub preferred_audio_codec: Option<VideoFormat>,
 70 |     pub chapters: bool,
 71 | }
 72 | 
 73 | impl Options {
 74 |     pub fn override_with_clap_args(&mut self) {
 75 |         if let Some(database) = CLAP_ARGS.get_one::<PathBuf>("database") {
 76 |             database.clone_into(&mut self.database);
 77 |         }
 78 | 
 79 |         if let Some(instances) = CLAP_ARGS.get_one::<PathBuf>("instances") {
 80 |             instances.clone_into(&mut self.instances);
 81 |         }
 82 | 
 83 |         if let Some(tick_rate) = CLAP_ARGS.get_one::<u64>("tick_rate") {
 84 |             self.tick_rate = *tick_rate;
 85 |         }
 86 | 
 87 |         if let Some(request_timeout) = CLAP_ARGS.get_one::<u64>("request_timeout") {
 88 |             self.request_timeout = *request_timeout;
 89 |         }
 90 | 
 91 |         if let Some(highlight_symbol) = CLAP_ARGS.get_one::<String>("highlight_symbol") {
 92 |             highlight_symbol.clone_into(&mut self.highlight_symbol);
 93 |         }
 94 |     }
 95 | }
 96 | 
 97 | impl Default for Options {
 98 |     fn default() -> Self {
 99 |         Options {
100 |             database: PathBuf::default(),
101 |             instances: PathBuf::default(),
102 |             tabs: EnabledTabs::VIDEOS,
103 |             hide_disabled_tabs: true,
104 |             api: ApiBackend::Local,
105 |             refresh_threshold: 600,
106 |             rss_threshold: 9999,
107 |             tick_rate: 10,
108 |             request_timeout: 5,
109 |             highlight_symbol: String::new(),
110 |             video_player_for_stream_formats: VideoPlayer::Mpv,
111 |             mpv_path: PathBuf::from("mpv"),
112 |             vlc_path: PathBuf::from("vlc"),
113 |             hide_watched: false,
114 |             hide_members_only: false,
115 |             subtitle_languages: Vec::new(),
116 |             prefer_dash_formats: true,
117 |             prefer_original_audio: true,
118 |             video_quality: u16::MAX,
119 |             preferred_video_codec: None,
120 |             preferred_audio_codec: None,
121 |             chapters: true,
122 |         }
123 |     }
124 | }
125 | 
126 | impl From<UserOptions> for Options {
127 |     fn from(user_options: UserOptions) -> Self {
128 |         let mut options = Options::default();
129 | 
130 |         macro_rules! set_options_field {
131 |             ($name: ident) => {
132 |                 if let Some(option) = user_options.$name {
133 |                     options.$name = option;
134 |                 }
135 |             };
136 |             ($name: ident |) => {
137 |                 options.$name = user_options.$name;
138 |             };
139 |         }
140 | 
141 |         set_options_field!(database);
142 |         set_options_field!(instances);
143 |         set_options_field!(tabs);
144 |         set_options_field!(hide_disabled_tabs);
145 |         set_options_field!(api);
146 |         set_options_field!(refresh_threshold);
147 |         set_options_field!(rss_threshold);
148 |         set_options_field!(tick_rate);
149 |         set_options_field!(request_timeout);
150 |         set_options_field!(highlight_symbol);
151 |         set_options_field!(hide_watched);
152 |         set_options_field!(hide_members_only);
153 |         set_options_field!(video_player_for_stream_formats);
154 |         set_options_field!(mpv_path);
155 |         set_options_field!(vlc_path);
156 |         set_options_field!(subtitle_languages);
157 |         set_options_field!(prefer_dash_formats);
158 |         set_options_field!(prefer_original_audio);
159 |         set_options_field!(video_quality);
160 |         set_options_field!(preferred_video_codec |);
161 |         set_options_field!(preferred_audio_codec |);
162 |         set_options_field!(chapters);
163 | 
164 |         options
165 |     }
166 | }
167 | 
168 | fn deserialize_tabs<'de, D>(deserializer: D) -> Result<Option<EnabledTabs>, D::Error>
169 | where
170 |     D: de::Deserializer<'de>,
171 | {
172 |     let Some(tabs): Option<Vec<ChannelTab>> = de::Deserialize::deserialize(deserializer)? else {
173 |         return Ok(None);
174 |     };
175 | 
176 |     let mut enabled = EnabledTabs::empty();
177 | 
178 |     if tabs.contains(&ChannelTab::Videos) {
179 |         enabled.insert(EnabledTabs::VIDEOS);
180 |     }
181 | 
182 |     if tabs.contains(&ChannelTab::Shorts) {
183 |         enabled.insert(EnabledTabs::SHORTS);
184 |     }
185 | 
186 |     if tabs.contains(&ChannelTab::Streams) {
187 |         enabled.insert(EnabledTabs::STREAMS);
188 |     }
189 | 
190 |     Ok(Some(enabled))
191 | }
192 | 
193 | fn deserialize_video_quality<'de, D>(deserializer: D) -> Result<Option<u16>, D::Error>
194 | where
195 |     D: de::Deserializer<'de>,
196 | {
197 |     use serde::de::Error;
198 | 
199 |     let Some(quality_str): Option<String> = de::Deserialize::deserialize(deserializer)? else {
200 |         return Ok(None);
201 |     };
202 | 
203 |     Ok(Some(if quality_str.to_lowercase() == "best" {
204 |         u16::MAX
205 |     } else if let Some(Ok(quality)) = quality_str.strip_suffix('p').map(str::parse::<u16>) {
206 |         quality
207 |     } else if let Ok(quality) = quality_str.parse::<u16>() {
208 |         quality
209 |     } else {
210 |         return Err(Error::custom(format!(
211 |             "\"{quality_str}\" is not a valid quality"
212 |         )));
213 |     }))
214 | }
215 | 


--------------------------------------------------------------------------------
/src/help.rs:
--------------------------------------------------------------------------------
  1 | use crate::KEY_BINDINGS;
  2 | use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
  3 | use std::ops::{Deref, DerefMut};
  4 | 
  5 | const DESCRIPTIONS_LEN: usize = 33;
  6 | const DESCRIPTIONS: [&str; DESCRIPTIONS_LEN] = [
  7 |     "Switch to subscriptions mode",
  8 |     "Switch to latest videos mode",
  9 |     "Go one line downward",
 10 |     "Go one line upward",
 11 |     "Switch to channels block",
 12 |     "Switch to videos block",
 13 |     "Jump to the first line",
 14 |     "Jump to the last line",
 15 |     "Select next tab",
 16 |     "Select previous tab",
 17 |     "Jump to the channel of the selected video from latest videos mode",
 18 |     "Hide/unhide watched videos",
 19 |     "Subscribe",
 20 |     "Unsubscribe",
 21 |     "Delete the selected video from database",
 22 |     "Search Forward",
 23 |     "Search backward",
 24 |     "Repeat last search",
 25 |     "Repeat last search in the opposite direction",
 26 |     "Switch API",
 27 |     "Refresh videos of the selected channel",
 28 |     "Refresh videos of every channel",
 29 |     "Refresh videos of channels which their latest refresh was a failure",
 30 |     "Load more videos",
 31 |     "Open channel or video Invidious page in browser",
 32 |     "Open channel or video Youtube page in browser",
 33 |     "Play video in video player using stream formats",
 34 |     "Play video in mpv using yt-dlp",
 35 |     "Toggle format selection window",
 36 |     "Mark/unmark video as watched",
 37 |     "Toggle help window",
 38 |     "Toggle tag selection window",
 39 |     "Quit application",
 40 | ];
 41 | 
 42 | const IMPORT_DESCRIPTIONS_LEN: usize = 4;
 43 | const IMPORT_DESCRIPTIONS: [&str; IMPORT_DESCRIPTIONS_LEN] = [
 44 |     " - Import, ",
 45 |     " - Toggle, ",
 46 |     " - Select all, ",
 47 |     " - Deselect all",
 48 | ];
 49 | 
 50 | const TAG_DESCRIPTIONS_LEN: usize = 8;
 51 | const TAG_DESCRIPTIONS: [&str; TAG_DESCRIPTIONS_LEN] = [
 52 |     " - Create tag, ",
 53 |     " - Delete tag, ",
 54 |     " - Rename tag, ",
 55 |     " - Pick channels, ",
 56 |     " - Toggle, ",
 57 |     " - Select all, ",
 58 |     " - Deselect all, ",
 59 |     " - Abort",
 60 | ];
 61 | 
 62 | const CHANNEL_SELECTION_DESCRIPTIONS_LEN: usize = 5;
 63 | const CHANNEL_SELECTION_DESCRIPTIONS: [&str; CHANNEL_SELECTION_DESCRIPTIONS_LEN] = [
 64 |     " - Confirm, ",
 65 |     " - Abort, ",
 66 |     " - Toggle, ",
 67 |     " - Select all, ",
 68 |     " - Deselect all",
 69 | ];
 70 | 
 71 | const FORMAT_SELECTION_DESCRIPTIONS_LEN: usize = 6;
 72 | const FORMAT_SELECTION_DESCRIPTIONS: [&str; FORMAT_SELECTION_DESCRIPTIONS_LEN] = [
 73 |     " - Previous tab, ",
 74 |     " - Next tab, ",
 75 |     " - Switch format, ",
 76 |     " - Select, ",
 77 |     " - Play video, ",
 78 |     " - Abort",
 79 | ];
 80 | 
 81 | pub struct HelpWindowState {
 82 |     pub show: bool,
 83 |     pub scroll: u16,
 84 |     pub max_scroll: u16,
 85 | }
 86 | 
 87 | impl HelpWindowState {
 88 |     pub fn new() -> Self {
 89 |         Self {
 90 |             show: false,
 91 |             scroll: 0,
 92 |             max_scroll: 0,
 93 |         }
 94 |     }
 95 | 
 96 |     pub fn toggle(&mut self) {
 97 |         self.show = !self.show;
 98 |     }
 99 | 
100 |     pub fn scroll_up(&mut self) {
101 |         self.scroll = self.scroll.saturating_sub(1);
102 |     }
103 | 
104 |     pub fn scroll_down(&mut self) {
105 |         self.scroll = std::cmp::min(self.scroll + 1, self.max_scroll);
106 |     }
107 | 
108 |     pub fn scroll_top(&mut self) {
109 |         self.scroll = 0;
110 |     }
111 | 
112 |     pub fn scroll_bottom(&mut self) {
113 |         self.scroll = self.max_scroll;
114 |     }
115 | }
116 | 
117 | const HELP_ENTRY: (String, &str) = (String::new(), "");
118 | 
119 | pub struct Help<'a> {
120 |     pub general: [(String, &'a str); DESCRIPTIONS_LEN],
121 |     pub import: [(String, &'a str); IMPORT_DESCRIPTIONS_LEN],
122 |     pub tag: [(String, &'a str); TAG_DESCRIPTIONS_LEN],
123 |     pub channel_selection: [(String, &'a str); CHANNEL_SELECTION_DESCRIPTIONS_LEN],
124 |     pub format_selection: [(String, &'a str); FORMAT_SELECTION_DESCRIPTIONS_LEN],
125 | }
126 | 
127 | impl Default for Help<'_> {
128 |     fn default() -> Self {
129 |         Self::new()
130 |     }
131 | }
132 | 
133 | impl Help<'_> {
134 |     pub fn new() -> Self {
135 |         let mut help = Self {
136 |             general: [HELP_ENTRY; DESCRIPTIONS_LEN],
137 |             import: [HELP_ENTRY; IMPORT_DESCRIPTIONS_LEN],
138 |             tag: [HELP_ENTRY; TAG_DESCRIPTIONS_LEN],
139 |             channel_selection: [HELP_ENTRY; CHANNEL_SELECTION_DESCRIPTIONS_LEN],
140 |             format_selection: [HELP_ENTRY; FORMAT_SELECTION_DESCRIPTIONS_LEN],
141 |         };
142 | 
143 |         macro_rules! generate_entries {
144 |             ($entries: expr, $bindings: expr, $descriptions: ident) => {
145 |                 for (key, command) in &$bindings {
146 |                     let idx = *command as usize;
147 | 
148 |                     if !$entries[idx].0.is_empty() {
149 |                         $entries[idx].0.push_str(", ");
150 |                     }
151 |                     $entries[idx].0.push_str(&key_event_to_string(key));
152 |                 }
153 | 
154 |                 for (idx, (_, desc)) in $entries.iter_mut().enumerate() {
155 |                     *desc = $descriptions[idx];
156 |                 }
157 |             };
158 |         }
159 | 
160 |         generate_entries!(help.general, KEY_BINDINGS.general, DESCRIPTIONS);
161 |         generate_entries!(help.import, KEY_BINDINGS.import, IMPORT_DESCRIPTIONS);
162 |         generate_entries!(help.tag, KEY_BINDINGS.tag, TAG_DESCRIPTIONS);
163 |         generate_entries!(
164 |             help.channel_selection,
165 |             KEY_BINDINGS.channel_selection,
166 |             CHANNEL_SELECTION_DESCRIPTIONS
167 |         );
168 |         generate_entries!(
169 |             help.format_selection,
170 |             KEY_BINDINGS.format_selection,
171 |             FORMAT_SELECTION_DESCRIPTIONS
172 |         );
173 | 
174 |         for (keys, _) in &mut help.general {
175 |             *keys = format!("{keys:10}  ");
176 |         }
177 | 
178 |         help
179 |     }
180 | }
181 | 
182 | impl<'a> Deref for Help<'a> {
183 |     type Target = [(String, &'a str); DESCRIPTIONS_LEN];
184 | 
185 |     fn deref(&self) -> &Self::Target {
186 |         &self.general
187 |     }
188 | }
189 | 
190 | impl DerefMut for Help<'_> {
191 |     fn deref_mut(&mut self) -> &mut Self::Target {
192 |         &mut self.general
193 |     }
194 | }
195 | 
196 | fn key_event_to_string(key_event: &KeyEvent) -> String {
197 |     let char;
198 |     let key_code = match key_event.code {
199 |         KeyCode::Backspace => "backspace",
200 |         KeyCode::Enter => "enter",
201 |         KeyCode::Left => "left",
202 |         KeyCode::Right => "right",
203 |         KeyCode::Up => "up",
204 |         KeyCode::Down => "down",
205 |         KeyCode::Home => "home",
206 |         KeyCode::End => "end",
207 |         KeyCode::PageUp => "pageup",
208 |         KeyCode::PageDown => "pagedown",
209 |         KeyCode::Tab => "tab",
210 |         KeyCode::BackTab => "backtab",
211 |         KeyCode::Delete => "delete",
212 |         KeyCode::Insert => "insert",
213 |         KeyCode::Char(' ') => "space",
214 |         KeyCode::Char(c) => {
215 |             char = c.to_string();
216 |             &char
217 |         }
218 |         KeyCode::Esc => "esc",
219 |         _ => "",
220 |     };
221 | 
222 |     let mut modifiers = Vec::with_capacity(3);
223 | 
224 |     if key_event.modifiers.intersects(KeyModifiers::CONTROL) {
225 |         modifiers.push("ctrl");
226 |     }
227 | 
228 |     if key_event.modifiers.intersects(KeyModifiers::SHIFT) {
229 |         modifiers.push("shift");
230 |     }
231 | 
232 |     if key_event.modifiers.intersects(KeyModifiers::ALT) {
233 |         modifiers.push("alt");
234 |     }
235 | 
236 |     let mut key = modifiers.join("-");
237 | 
238 |     if !key.is_empty() {
239 |         key.push('-');
240 |     }
241 |     key.push_str(key_code);
242 | 
243 |     key
244 | }
245 | 


--------------------------------------------------------------------------------
/src/api/invidious.rs:
--------------------------------------------------------------------------------
  1 | use super::{Api, ApiBackend, Chapters, Format, VideoInfo};
  2 | use crate::OPTIONS;
  3 | use crate::api::{ChannelFeed, ChannelTab};
  4 | use crate::channel::Video;
  5 | use crate::stream_formats::Formats;
  6 | use anyhow::Result;
  7 | use async_trait::async_trait;
  8 | use rand::prelude::*;
  9 | use reqwest::Client;
 10 | use serde_json::Value;
 11 | use std::collections::HashSet;
 12 | use std::time::Duration;
 13 | 
 14 | const API_BACKEND: ApiBackend = ApiBackend::Invidious;
 15 | 
 16 | fn extract_tab(videos_array: &Value) -> Option<Vec<Video>> {
 17 |     videos_array
 18 |         .as_array()
 19 |         .map(|array| array.iter().map(Video::from).collect())
 20 | }
 21 | 
 22 | #[derive(Clone)]
 23 | pub struct Instance {
 24 |     pub domain: String,
 25 |     client: Client,
 26 |     continuation: Option<String>,
 27 | }
 28 | 
 29 | impl Instance {
 30 |     pub fn new(invidious_instances: &[String]) -> Self {
 31 |         let mut rng = rand::rng();
 32 |         let domain =
 33 |             invidious_instances[rng.random_range(0..invidious_instances.len())].to_string();
 34 |         let client = Client::builder()
 35 |             .timeout(Duration::from_secs(OPTIONS.request_timeout))
 36 |             .build()
 37 |             .unwrap();
 38 | 
 39 |         Self {
 40 |             domain,
 41 |             client,
 42 |             continuation: None,
 43 |         }
 44 |     }
 45 | 
 46 |     async fn get_tab_of_channel(&self, channel_id: &str, tab: ChannelTab) -> Result<Value> {
 47 |         let url = format!("{}/api/v1/channels/{}/{}", self.domain, channel_id, tab);
 48 | 
 49 |         let response = self.client.get(&url).send().await?;
 50 |         let mut value = response.error_for_status()?.json::<Value>().await?;
 51 | 
 52 |         Ok(value["videos"].take())
 53 |     }
 54 | 
 55 |     async fn get_more_videos_helper(
 56 |         &mut self,
 57 |         channel_id: &str,
 58 |         tab: ChannelTab,
 59 |     ) -> Result<Vec<Video>> {
 60 |         let url = format!("{}/api/v1/channels/{}/{}", self.domain, channel_id, tab);
 61 |         let mut request = self.client.get(&url);
 62 | 
 63 |         if let Some(token) = &self.continuation {
 64 |             request = request.query(&[("continuation", token)]);
 65 |         }
 66 | 
 67 |         let response = request.send().await?;
 68 |         let value = response.error_for_status()?.json::<Value>().await?;
 69 | 
 70 |         self.continuation = value
 71 |             .get("continuation")
 72 |             .and_then(Value::as_str)
 73 |             .map(ToString::to_string);
 74 | 
 75 |         Ok(extract_tab(&value["videos"]).unwrap_or_default())
 76 |     }
 77 | }
 78 | 
 79 | #[async_trait]
 80 | impl Api for Instance {
 81 |     async fn resolve_url(&self, channel_url: &str) -> Result<String> {
 82 |         let url = format!("{}/api/v1/resolveurl", self.domain);
 83 |         let response = self
 84 |             .client
 85 |             .get(&url)
 86 |             .query(&[("url", channel_url)])
 87 |             .send()
 88 |             .await?;
 89 | 
 90 |         let value: Value = response.error_for_status()?.json().await?;
 91 | 
 92 |         Ok(value["ucid"].as_str().unwrap().to_string())
 93 |     }
 94 | 
 95 |     async fn get_videos_of_channel(&mut self, channel_id: &str) -> Result<ChannelFeed> {
 96 |         let mut channel_feed = ChannelFeed::new(channel_id);
 97 | 
 98 |         for tab in OPTIONS.tabs.iter().map(|tab| tab.bits().into()) {
 99 |             let videos_array = self.get_tab_of_channel(channel_id, tab).await?;
100 | 
101 |             if let Some(videos) = extract_tab(&videos_array) {
102 |                 *channel_feed.get_mut_videos(tab) = videos;
103 |             }
104 |         }
105 | 
106 |         Ok(channel_feed)
107 |     }
108 | 
109 |     async fn get_videos_for_the_first_time(&mut self, channel_id: &str) -> Result<ChannelFeed> {
110 |         let mut channel_feed = ChannelFeed::new(channel_id);
111 | 
112 |         for tab in OPTIONS.tabs.iter().map(|tab| tab.bits().into()) {
113 |             let videos_array = self.get_tab_of_channel(channel_id, tab).await?;
114 | 
115 |             if channel_feed.channel_title.is_none()
116 |                 && let Some(video) = videos_array.get(0)
117 |             {
118 |                 channel_feed.channel_title = video["author"].as_str().map(ToString::to_string);
119 |             }
120 | 
121 |             if let Some(videos) = extract_tab(&videos_array) {
122 |                 *channel_feed.get_mut_videos(tab) = videos;
123 |             }
124 |         }
125 | 
126 |         Ok(channel_feed)
127 |     }
128 | 
129 |     async fn get_rss_feed_of_channel(&self, channel_id: &str) -> Result<ChannelFeed> {
130 |         let url = format!("{}/feed/channel/{}", self.domain, channel_id);
131 |         let response = self.client.get(&url).send().await?.error_for_status()?;
132 | 
133 |         Ok(quick_xml::de::from_str(&response.text().await?)?)
134 |     }
135 | 
136 |     async fn get_more_videos(
137 |         &mut self,
138 |         channel_id: &str,
139 |         tab: ChannelTab,
140 |         present_videos: HashSet<String>,
141 |     ) -> Result<ChannelFeed> {
142 |         let mut feed = ChannelFeed::new(channel_id);
143 |         let videos = self.get_more_videos_helper(channel_id, tab).await?;
144 | 
145 |         match tab {
146 |             ChannelTab::Videos => feed.videos = videos,
147 |             ChannelTab::Shorts => feed.shorts = videos,
148 |             ChannelTab::Streams => feed.live_streams = videos,
149 |         }
150 | 
151 |         let new_video_present = |videos: &[Video]| {
152 |             !videos
153 |                 .iter()
154 |                 .all(|video| present_videos.contains(&video.video_id))
155 |         };
156 | 
157 |         if new_video_present(&feed.videos) {
158 |             return Ok(feed);
159 |         }
160 | 
161 |         while self.continuation.is_some()
162 |             && let Ok(videos) = self.get_more_videos_helper(channel_id, tab).await
163 |         {
164 |             let new = new_video_present(&videos);
165 |             feed.extend_videos(videos, tab);
166 | 
167 |             if new {
168 |                 return Ok(feed);
169 |             }
170 |         }
171 | 
172 |         Ok(ChannelFeed::default())
173 |     }
174 | 
175 |     async fn get_video_formats(&self, video_id: &str) -> Result<VideoInfo> {
176 |         let url = format!("{}/api/v1/videos/{}", self.domain, video_id);
177 |         let response = self.client.get(&url).send().await?;
178 |         let value = match response.error_for_status() {
179 |             Ok(response) => response.json::<Value>().await?,
180 |             Err(_e) => {
181 |                 anyhow::bail!(format!("Stream formats are not available: ",));
182 |             }
183 |         };
184 | 
185 |         let mut format_streams: Vec<Format> = value["formatStreams"]
186 |             .as_array()
187 |             .unwrap()
188 |             .iter()
189 |             .map(|format| Format::from_stream(format, API_BACKEND))
190 |             .collect();
191 | 
192 |         let adaptive_formats = value["adaptiveFormats"].as_array().unwrap();
193 | 
194 |         let mut video_formats = Vec::new();
195 |         let mut audio_formats = Vec::new();
196 | 
197 |         for format in adaptive_formats {
198 |             if format.get("qualityLabel").is_some() {
199 |                 video_formats.push(Format::from_video(format, API_BACKEND));
200 |             } else if format.get("audioQuality").is_some() {
201 |                 audio_formats.push(Format::from_audio(format, API_BACKEND));
202 |             }
203 |         }
204 | 
205 |         format_streams.reverse();
206 |         video_formats.reverse();
207 | 
208 |         let captions = value["captions"]
209 |             .as_array()
210 |             .unwrap()
211 |             .iter()
212 |             .filter_map(|caption| Format::from_caption(caption, API_BACKEND))
213 |             .collect();
214 | 
215 |         let chapters = OPTIONS
216 |             .chapters
217 |             .then(|| Chapters::try_from(value["description"].as_str()).ok())
218 |             .flatten();
219 | 
220 |         Ok(VideoInfo::new(
221 |             video_formats,
222 |             audio_formats,
223 |             format_streams,
224 |             captions,
225 |             chapters,
226 |         ))
227 |     }
228 | 
229 |     async fn get_caption_paths(&self, formats: &Formats) -> Vec<String> {
230 |         formats
231 |             .captions
232 |             .get_selected_items()
233 |             .iter()
234 |             .map(|caption| format!("{}{}", self.domain, caption.get_url()))
235 |             .collect()
236 |     }
237 | }
238 | 


--------------------------------------------------------------------------------
/src/utils.rs:
--------------------------------------------------------------------------------
  1 | use anyhow::{Result, bail};
  2 | use serde_json::Value;
  3 | use std::collections::HashMap;
  4 | use std::fs::File;
  5 | use std::io::{BufRead, BufReader, Write};
  6 | use std::path::PathBuf;
  7 | use std::time::{SystemTime, UNIX_EPOCH};
  8 | use url::Url;
  9 | 
 10 | use crate::CONFIG;
 11 | 
 12 | const PACKAGE_NAME: &str = env!("CARGO_PKG_NAME");
 13 | const INSTANCES_FILE: &str = "instances";
 14 | const DATABASE_FILE: &str = "videos.db";
 15 | 
 16 | pub fn get_config_dir() -> Result<PathBuf> {
 17 |     let path = match dirs::config_dir() {
 18 |         Some(path) => path.join(PACKAGE_NAME),
 19 |         None => bail!("Couldn't find config directory"),
 20 |     };
 21 | 
 22 |     Ok(path)
 23 | }
 24 | 
 25 | pub fn get_data_dir() -> Result<PathBuf> {
 26 |     let path = match dirs::data_local_dir() {
 27 |         Some(path) => path.join(PACKAGE_NAME),
 28 |         None => bail!("Couldn't find local data directory"),
 29 |     };
 30 | 
 31 |     if !path.exists() {
 32 |         std::fs::create_dir_all(&path)?;
 33 |     }
 34 | 
 35 |     Ok(path)
 36 | }
 37 | 
 38 | pub fn get_cache_dir() -> Result<PathBuf> {
 39 |     let path = match dirs::cache_dir() {
 40 |         Some(path) => path.join(PACKAGE_NAME),
 41 |         None => bail!("Couldn't find cache directory"),
 42 |     };
 43 | 
 44 |     if !path.exists() {
 45 |         std::fs::create_dir_all(&path)?;
 46 |     }
 47 | 
 48 |     Ok(path)
 49 | }
 50 | 
 51 | fn hyperlink(text: &str, link: &str) -> String {
 52 |     format!("\x1b]8;;{link}\x1b\\{text}\x1b]8;;\x1b\\")
 53 | }
 54 | 
 55 | pub async fn fetch_invidious_instances() -> Result<Vec<String>> {
 56 |     const REQUEST_URL: &str = "https://api.invidious.io/instances.json";
 57 |     const ONION: &str = "onion";
 58 |     let instances: Value = reqwest::get(REQUEST_URL).await?.json().await?;
 59 |     Ok(instances
 60 |         .as_array()
 61 |         .unwrap()
 62 |         .iter()
 63 |         .map(|arr| arr.as_array().unwrap())
 64 |         .filter(|instance| {
 65 |             let instance = &instance[1];
 66 |             instance["type"].as_str().unwrap() != ONION
 67 |                 && instance["api"].as_bool().unwrap_or(false)
 68 |         })
 69 |         .map(|instance| instance[1]["uri"].as_str().unwrap().to_string())
 70 |         .collect())
 71 | }
 72 | 
 73 | pub fn get_default_instances_file() -> Result<PathBuf> {
 74 |     Ok(get_config_dir()?.join(INSTANCES_FILE))
 75 | }
 76 | 
 77 | pub async fn generate_instances_file() -> Result<()> {
 78 |     let instances = fetch_invidious_instances().await?;
 79 |     let instances_file_path = &CONFIG.options.instances;
 80 |     let instances_dir = instances_file_path.parent().unwrap();
 81 | 
 82 |     if !instances_dir.exists() {
 83 |         std::fs::create_dir_all(instances_dir)?;
 84 |     }
 85 | 
 86 |     anyhow::ensure!(
 87 |         !instances.is_empty(),
 88 |         format!(
 89 |             "No suitable instance available on {}",
 90 |             hyperlink("api.invidious.io", "https://api.invidious.io/")
 91 |         )
 92 |     );
 93 | 
 94 |     let mut file = File::create(instances_file_path.as_path())?;
 95 |     println!(
 96 |         "Generated \"{}\" with the following instances:",
 97 |         instances_file_path.display()
 98 |     );
 99 |     for instance in instances {
100 |         writeln!(file, "{instance}")?;
101 |         println!("{instance}");
102 |     }
103 |     Ok(())
104 | }
105 | 
106 | pub fn read_instances() -> Result<Vec<String>> {
107 |     let file = File::open(&CONFIG.options.instances)?;
108 |     let mut instances = Vec::new();
109 |     for instance in BufReader::new(file).lines() {
110 |         instances.push(instance?);
111 |     }
112 |     Ok(instances)
113 | }
114 | 
115 | pub fn get_default_database_file() -> Result<PathBuf> {
116 |     Ok(get_data_dir()?.join(DATABASE_FILE))
117 | }
118 | 
119 | pub fn length_as_seconds(length: &str) -> u32 {
120 |     let mut total = 0;
121 | 
122 |     for t in length.split(':') {
123 |         total *= 60;
124 |         total += t.parse::<u32>().unwrap();
125 |     }
126 | 
127 |     total
128 | }
129 | 
130 | pub fn params_from_url(url: &str) -> Result<HashMap<String, String>> {
131 |     let parsed_url = Url::parse(url)?;
132 | 
133 |     Ok(parsed_url
134 |         .query_pairs()
135 |         .map(|(k, v)| (k.to_string(), v.to_string()))
136 |         .collect())
137 | }
138 | 
139 | pub fn length_as_hhmmss(length: u32) -> String {
140 |     let seconds = length % 60;
141 |     let minutes = (length / 60) % 60;
142 |     let hours = (length / 60) / 60;
143 |     match (hours, minutes, seconds) {
144 |         (0, 0, _) => format!("0:{seconds:02}"),
145 |         (0, _, _) => format!("{minutes}:{seconds:02}"),
146 |         _ => format!("{hours}:{minutes:02}:{seconds:02}"),
147 |     }
148 | }
149 | 
150 | const MINUTE: u64 = 60;
151 | const HOUR: u64 = 3600;
152 | const DAY: u64 = 86400;
153 | const WEEK: u64 = 604800;
154 | const MONTH: u64 = 2592000;
155 | const YEAR: u64 = 31536000;
156 | 
157 | pub fn published(published_text: &str) -> Result<u64> {
158 |     let (num, time_frame) = {
159 |         let v: Vec<&str> = published_text.splitn(2, ' ').collect();
160 | 
161 |         match v[0].parse::<u64>() {
162 |             Ok(num) => (num, v[1]),
163 |             _ => (
164 |                 v[0].trim_end_matches(char::is_alphabetic).parse()?,
165 |                 v[0].trim_start_matches(char::is_numeric),
166 |             ),
167 |         }
168 |     };
169 | 
170 |     let from_now = if time_frame.starts_with('s') {
171 |         num
172 |     } else if time_frame.starts_with("mi") {
173 |         num * MINUTE
174 |     } else if time_frame.starts_with('h') {
175 |         num * HOUR
176 |     } else if time_frame.starts_with('d') {
177 |         num * DAY
178 |     } else if time_frame.starts_with('w') {
179 |         num * WEEK
180 |     } else if time_frame.starts_with("mo") {
181 |         num * MONTH
182 |     } else if time_frame.starts_with('y') {
183 |         num * YEAR
184 |     } else {
185 |         return Err(anyhow::anyhow!("Not a valid published text"));
186 |     };
187 | 
188 |     Ok(now()?.saturating_sub(from_now))
189 | }
190 | 
191 | pub fn published_text(published: u64) -> Result<String> {
192 |     let now = now()?;
193 |     let time_diff = now.abs_diff(published);
194 |     let (num, mut time_frame) = if time_diff < MINUTE {
195 |         (time_diff, "second".to_string())
196 |     } else if time_diff < HOUR {
197 |         (time_diff / MINUTE, "minute".to_string())
198 |     } else if time_diff < DAY {
199 |         (time_diff / HOUR, "hour".to_string())
200 |     } else if time_diff < WEEK * 2 {
201 |         (time_diff / DAY, "day".to_string())
202 |     } else if time_diff < MONTH {
203 |         (time_diff / WEEK, "week".to_string())
204 |     } else if time_diff < YEAR {
205 |         (time_diff / MONTH, "month".to_string())
206 |     } else {
207 |         (time_diff / YEAR, "year".to_string())
208 |     };
209 |     if num > 1 {
210 |         time_frame.push('s');
211 |     }
212 |     Ok(if published > now {
213 |         format!("Premieres in {num} {time_frame}")
214 |     } else {
215 |         format!("Shared {num} {time_frame} ago")
216 |     })
217 | }
218 | 
219 | pub fn now() -> Result<u64> {
220 |     Ok(SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs())
221 | }
222 | 
223 | pub fn time_passed(time: u64) -> Result<u64> {
224 |     Ok(now()?.saturating_sub(time))
225 | }
226 | 
227 | #[cfg(test)]
228 | mod tests {
229 | 
230 |     use super::{
231 |         length_as_hhmmss, length_as_seconds, now, params_from_url, published, published_text,
232 |     };
233 | 
234 |     #[test]
235 |     fn extract_params() {
236 |         let url = "https://example.com/products?page=2&sort=desc";
237 |         let params = params_from_url(url).ok();
238 | 
239 |         assert_eq!(
240 |             params
241 |                 .as_ref()
242 |                 .and_then(|hm| hm.get("page").map(ToOwned::to_owned)),
243 |             Some(String::from("2"))
244 |         );
245 |         assert_eq!(
246 |             params.and_then(|hm| hm.get("sort").map(ToOwned::to_owned)),
247 |             Some(String::from("desc"))
248 |         );
249 |     }
250 | 
251 |     #[test]
252 |     fn length_conversion() {
253 |         const SECONDS: u32 = 5409;
254 |         const TEXT: &str = "1:30:09";
255 | 
256 |         assert_eq!(length_as_hhmmss(SECONDS), TEXT);
257 |         assert_eq!(length_as_seconds(TEXT), SECONDS);
258 |     }
259 | 
260 |     #[test]
261 |     fn published_conversion() {
262 |         const TEXT: &str = "5 days ago";
263 |         let time = now().unwrap().saturating_sub(432000);
264 | 
265 |         assert_eq!(published(TEXT).unwrap(), time);
266 |         assert_eq!(published_text(time).unwrap(), "Shared ".to_owned() + TEXT);
267 |     }
268 | }
269 | 


--------------------------------------------------------------------------------
/src/config/theme.rs:
--------------------------------------------------------------------------------
  1 | use anyhow::{Context, Result};
  2 | use ratatui::style::{Color, Modifier, Style};
  3 | use serde::Deserialize;
  4 | 
  5 | #[derive(Deserialize)]
  6 | struct UserStyle {
  7 |     fg: Option<String>,
  8 |     bg: Option<String>,
  9 |     modifiers: Option<String>,
 10 | }
 11 | 
 12 | impl UserStyle {
 13 |     fn to_style(&self) -> Result<Style> {
 14 |         let mut style = Style::default();
 15 | 
 16 |         if let Some(fg) = &self.fg {
 17 |             style = style.fg(str_to_color(fg)?);
 18 |         }
 19 | 
 20 |         if let Some(bg) = &self.bg {
 21 |             style = style.bg(str_to_color(bg)?);
 22 |         }
 23 | 
 24 |         if let Some(modifiers) = &self.modifiers {
 25 |             style.add_modifier = parse_modifiers(modifiers)?;
 26 |         }
 27 | 
 28 |         Ok(style)
 29 |     }
 30 | }
 31 | 
 32 | fn parse_hex(color: &str) -> Result<Color> {
 33 |     if color.len() != 7 {
 34 |         anyhow::bail!("Hex string must be 7 characters long.")
 35 |     }
 36 | 
 37 |     let red = u8::from_str_radix(&color[1..3], 16)?;
 38 |     let green = u8::from_str_radix(&color[3..5], 16)?;
 39 |     let blue = u8::from_str_radix(&color[5..7], 16)?;
 40 | 
 41 |     Ok(Color::Rgb(red, green, blue))
 42 | }
 43 | 
 44 | fn parse_rgb(color: &str) -> Result<Color> {
 45 |     let primaries: Vec<&str> = color.split(',').map(str::trim).collect();
 46 | 
 47 |     if primaries.len() != 3 {
 48 |         anyhow::bail!("RGB string must be composed of three primary colors.");
 49 |     }
 50 | 
 51 |     let red = primaries[0].parse()?;
 52 |     let green = primaries[1].parse()?;
 53 |     let blue = primaries[2].parse()?;
 54 | 
 55 |     Ok(Color::Rgb(red, green, blue))
 56 | }
 57 | 
 58 | fn str_to_color(color: &str) -> Result<Color> {
 59 |     let color = match color {
 60 |         "Black" => Color::Black,
 61 |         "Red" => Color::Red,
 62 |         "Green" => Color::Green,
 63 |         "Yellow" => Color::Yellow,
 64 |         "Blue" => Color::Blue,
 65 |         "Magenta" => Color::Magenta,
 66 |         "Cyan" => Color::Cyan,
 67 |         "Gray" => Color::Gray,
 68 |         "DarkGray" => Color::DarkGray,
 69 |         "LightRed" => Color::LightRed,
 70 |         "LightGreen" => Color::LightGreen,
 71 |         "LightYellow" => Color::LightYellow,
 72 |         "LightBlue" => Color::LightBlue,
 73 |         "LightMagenta" => Color::LightMagenta,
 74 |         "LightCyan" => Color::LightCyan,
 75 |         "White" => Color::White,
 76 |         "Reset" => Color::Reset,
 77 |         color if color.starts_with('#') => parse_hex(color).with_context(|| {
 78 |             format!(
 79 |                 "\"{color}\" is an invalid hex color. \
 80 |                     It must be of the form \"#xxxxxx\" where every x is a hexadecimal digit."
 81 |             )
 82 |         })?,
 83 |         color if color.contains(',') => parse_rgb(color).with_context(|| {
 84 |             format!(
 85 |                 "\"{color}\" is an invalid RGB color. \
 86 |                     It must be of the form \"x, x, x\" where every x is an integer from 0 to 255."
 87 |             )
 88 |         })?,
 89 |         _ => anyhow::bail!(
 90 |             "\"{}\" is not a valid color name. \
 91 |             Valid color names are Black, Red, Green, Yellow, Blue, Magenta \
 92 |             Cyan, Gray, DarkGray, LightRed, LightGreen, LightGreen, \
 93 |             LightYellow, LightBlue, LightMagenta, LightCyan, White and Reset.",
 94 |             color
 95 |         ),
 96 |     };
 97 | 
 98 |     Ok(color)
 99 | }
100 | 
101 | fn parse_modifiers(modifiers: &str) -> Result<Modifier> {
102 |     let mut res = Modifier::empty();
103 | 
104 |     for modifier in modifiers.split_whitespace() {
105 |         res.insert(match modifier {
106 |             "bold" => Modifier::BOLD,
107 |             "dim" => Modifier::DIM,
108 |             "italic" => Modifier::ITALIC,
109 |             "underlined" => Modifier::UNDERLINED,
110 |             "slow_blink" => Modifier::SLOW_BLINK,
111 |             "rapid_blink" => Modifier::RAPID_BLINK,
112 |             "reversed" => Modifier::REVERSED,
113 |             "hidden" => Modifier::HIDDEN,
114 |             "crossed_out" => Modifier::CROSSED_OUT,
115 |             _ => anyhow::bail!(
116 |                 "\"{}\" is not a valid modifier. \
117 |                 Valid modifiers are bold, dim, italic, underlined, \
118 |                 slow_blink, rapid_blink, reversed, hidden and crossed_out.",
119 |                 modifier
120 |             ),
121 |         });
122 |     }
123 | 
124 |     Ok(res)
125 | }
126 | 
127 | #[derive(Deserialize)]
128 | pub struct UserTheme {
129 |     title: Option<UserStyle>,
130 |     header: Option<UserStyle>,
131 |     selected: Option<UserStyle>,
132 |     focused: Option<UserStyle>,
133 |     watched: Option<UserStyle>,
134 |     selected_watched: Option<UserStyle>,
135 |     focused_watched: Option<UserStyle>,
136 |     new_video_indicator: Option<UserStyle>,
137 |     members_only_indicator: Option<UserStyle>,
138 |     selected_block: Option<UserStyle>,
139 |     error: Option<UserStyle>,
140 |     warning: Option<UserStyle>,
141 |     help: Option<UserStyle>,
142 | }
143 | 
144 | pub struct Theme {
145 |     pub title: Style,
146 |     pub header: Style,
147 |     pub selected: Style,
148 |     pub focused: Style,
149 |     pub watched: Style,
150 |     pub selected_watched: Style,
151 |     pub focused_watched: Style,
152 |     pub new_video_indicator: Style,
153 |     pub members_only_indicator: Style,
154 |     pub selected_block: Style,
155 |     pub error: Style,
156 |     pub warning: Style,
157 |     pub help: Style,
158 | }
159 | 
160 | impl Default for Theme {
161 |     fn default() -> Self {
162 |         Theme {
163 |             title: Style::default()
164 |                 .fg(Color::Cyan)
165 |                 .add_modifier(Modifier::BOLD),
166 |             header: Style::default()
167 |                 .fg(Color::Yellow)
168 |                 .add_modifier(Modifier::BOLD),
169 |             selected: Style::default()
170 |                 .fg(Color::Blue)
171 |                 .add_modifier(Modifier::BOLD),
172 |             focused: Style::default()
173 |                 .fg(Color::Magenta)
174 |                 .add_modifier(Modifier::BOLD),
175 |             watched: Style::default().fg(Color::DarkGray),
176 |             selected_watched: Style::default(),
177 |             focused_watched: Style::default(),
178 |             new_video_indicator: Style::default()
179 |                 .fg(Color::Red)
180 |                 .add_modifier(Modifier::ITALIC),
181 |             members_only_indicator: Style::default()
182 |                 .fg(Color::Green)
183 |                 .add_modifier(Modifier::ITALIC),
184 |             selected_block: Style::default().fg(Color::Magenta),
185 |             error: Style::default().fg(Color::Red),
186 |             warning: Style::default().fg(Color::Yellow),
187 |             help: Style::default().fg(Color::Green),
188 |         }
189 |     }
190 | }
191 | 
192 | impl TryFrom<UserTheme> for Theme {
193 |     type Error = anyhow::Error;
194 | 
195 |     fn try_from(user_theme: UserTheme) -> Result<Self, Self::Error> {
196 |         let mut theme = Theme::default();
197 | 
198 |         macro_rules! set_theme_field {
199 |             ($name: ident) => {
200 |                 if let Some(color) = user_theme.$name {
201 |                     theme.$name = UserStyle::to_style(&color).with_context(|| {
202 |                         format!("Error: couldn't set a field of \"{}\"", stringify!($name))
203 |                     })?;
204 |                 }
205 |             };
206 |         }
207 | 
208 |         set_theme_field!(title);
209 |         set_theme_field!(header);
210 |         set_theme_field!(selected);
211 |         set_theme_field!(focused);
212 |         set_theme_field!(watched);
213 |         set_theme_field!(selected_watched);
214 |         set_theme_field!(focused_watched);
215 |         set_theme_field!(new_video_indicator);
216 |         set_theme_field!(members_only_indicator);
217 |         set_theme_field!(selected_block);
218 |         set_theme_field!(error);
219 |         set_theme_field!(warning);
220 |         set_theme_field!(help);
221 | 
222 |         Ok(theme)
223 |     }
224 | }
225 | 
226 | #[cfg(test)]
227 | mod tests {
228 |     use super::{parse_modifiers, str_to_color};
229 |     use ratatui::style::{Color, Modifier};
230 | 
231 |     #[test]
232 |     fn valid_hexa() {
233 |         assert_eq!(str_to_color("#ffffff").unwrap(), Color::Rgb(255, 255, 255));
234 |     }
235 | 
236 |     #[test]
237 |     #[should_panic]
238 |     fn invalid_hexa() {
239 |         str_to_color("#aafffff").unwrap();
240 |     }
241 | 
242 |     #[test]
243 |     fn valid_rgb() {
244 |         assert_eq!(
245 |             str_to_color("255,255, 255").unwrap(),
246 |             Color::Rgb(255, 255, 255)
247 |         );
248 |     }
249 | 
250 |     #[test]
251 |     #[should_panic]
252 |     fn out_of_range() {
253 |         str_to_color("255, 255, 256").unwrap();
254 |     }
255 | 
256 |     #[test]
257 |     fn valid_modifiers() {
258 |         assert_eq!(
259 |             parse_modifiers("bold italic").unwrap(),
260 |             Modifier::BOLD | Modifier::ITALIC
261 |         );
262 |         assert_eq!(parse_modifiers("hidden").unwrap(), Modifier::HIDDEN);
263 |     }
264 | 
265 |     #[test]
266 |     #[should_panic]
267 |     fn invalid_modifier() {
268 |         parse_modifiers("rust bold").unwrap();
269 |     }
270 | }
271 | 


--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
  1 | mod api;
  2 | mod app;
  3 | mod channel;
  4 | mod cli;
  5 | mod client;
  6 | mod commands;
  7 | mod config;
  8 | mod database;
  9 | mod help;
 10 | mod import;
 11 | mod input;
 12 | mod message;
 13 | mod player;
 14 | mod protobuf;
 15 | mod ro_cell;
 16 | mod search;
 17 | mod stream_formats;
 18 | mod ui;
 19 | mod utils;
 20 | 
 21 | use crate::channel::ChannelTab;
 22 | use crate::config::Config;
 23 | use crate::config::keys::KeyBindings;
 24 | use crate::config::options::Options;
 25 | use crate::config::theme::Theme;
 26 | use anyhow::Result;
 27 | use api::ApiBackend;
 28 | use app::App;
 29 | use channel::RefreshState;
 30 | use clap::ArgMatches;
 31 | use client::ClientRequest;
 32 | use client::TX;
 33 | use crossterm::event::Event;
 34 | use crossterm::event::EventStream;
 35 | use crossterm::execute;
 36 | use crossterm::terminal::{
 37 |     EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode,
 38 | };
 39 | use futures_util::StreamExt;
 40 | use help::Help;
 41 | use input::InputMode;
 42 | use ratatui::DefaultTerminal;
 43 | use ratatui::Terminal;
 44 | use ratatui::backend::CrosstermBackend;
 45 | use std::collections::HashSet;
 46 | use std::io;
 47 | use std::panic;
 48 | use std::path::PathBuf;
 49 | use std::sync::LazyLock;
 50 | use std::time::Duration;
 51 | use std::time::Instant;
 52 | use stream_formats::Formats;
 53 | use tokio::sync::mpsc;
 54 | use tokio::sync::mpsc::UnboundedReceiver;
 55 | use tokio_util::sync::CancellationToken;
 56 | use ui::draw;
 57 | 
 58 | static CLAP_ARGS: LazyLock<ArgMatches> = LazyLock::new(cli::get_matches);
 59 | static CONFIG: LazyLock<Config> = LazyLock::new(|| match Config::new() {
 60 |     Ok(config) => config,
 61 |     Err(e) => {
 62 |         eprintln!("{e:?}");
 63 |         std::process::exit(1);
 64 |     }
 65 | });
 66 | static OPTIONS: LazyLock<&Options> = LazyLock::new(|| &CONFIG.options);
 67 | static KEY_BINDINGS: LazyLock<&KeyBindings> = LazyLock::new(|| &CONFIG.key_bindings);
 68 | static THEME: LazyLock<&Theme> = LazyLock::new(|| &CONFIG.theme);
 69 | static HELP: LazyLock<Help> = LazyLock::new(Help::new);
 70 | 
 71 | #[tokio::main]
 72 | async fn main() -> Result<()> {
 73 |     if CLAP_ARGS.get_flag("gen_instances_list") {
 74 |         utils::generate_instances_file().await?;
 75 |         return Ok(());
 76 |     }
 77 | 
 78 |     let (io_tx, io_rx) = mpsc::unbounded_channel();
 79 | 
 80 |     let mut app = App::new(io_tx)?;
 81 | 
 82 |     match CLAP_ARGS.subcommand() {
 83 |         Some(("import", matches)) => app.select_channels_to_import(
 84 |             matches.get_one::<PathBuf>("source").unwrap(),
 85 |             matches
 86 |                 .get_one::<String>("format")
 87 |                 .map(String::as_str)
 88 |                 .unwrap()
 89 |                 .into(),
 90 |         )?,
 91 |         Some(("export", matches)) => {
 92 |             return app.export_subscriptions(
 93 |                 matches.get_one::<PathBuf>("target").unwrap(),
 94 |                 matches
 95 |                     .get_one::<String>("format")
 96 |                     .map(String::as_str)
 97 |                     .unwrap()
 98 |                     .into(),
 99 |             );
100 |         }
101 |         _ => (),
102 |     }
103 | 
104 |     let default_hook = panic::take_hook();
105 | 
106 |     panic::set_hook(Box::new(move |info| {
107 |         reset_terminal().unwrap();
108 |         default_hook(info);
109 |     }));
110 | 
111 |     enable_raw_mode()?;
112 |     let mut stdout = io::stdout();
113 |     execute!(stdout, EnterAlternateScreen)?;
114 |     let backend = CrosstermBackend::new(stdout);
115 |     let mut terminal = Terminal::new(backend)?;
116 |     terminal.clear()?;
117 | 
118 |     let res = run_tui(&mut terminal, io_rx, app).await;
119 | 
120 |     reset_terminal()?;
121 | 
122 |     if let Err(e) = res {
123 |         eprintln!("{e:?}");
124 |     }
125 | 
126 |     Ok(())
127 | }
128 | 
129 | fn render(app: &mut App, terminal: &mut DefaultTerminal) -> Result<()> {
130 |     terminal.draw(|f| draw(f, app))?;
131 | 
132 |     const SEARCH_MODE_CURSOR_OFFSET: u16 = 1;
133 |     const SUBSCRIBE_MODE_CURSOR_OFFSET: u16 = 25;
134 |     const TAG_CREATION_MODE_CURSOR_OFFSET: u16 = 10;
135 | 
136 |     let cursor_position = app.cursor_position;
137 |     match &app.input_mode {
138 |         mode @ (InputMode::Subscribe
139 |         | InputMode::Search
140 |         | InputMode::TagCreation
141 |         | InputMode::TagRenaming) => {
142 |             let offset = match mode {
143 |                 InputMode::Search => SEARCH_MODE_CURSOR_OFFSET,
144 |                 InputMode::Subscribe => SUBSCRIBE_MODE_CURSOR_OFFSET,
145 |                 InputMode::TagCreation | InputMode::TagRenaming => TAG_CREATION_MODE_CURSOR_OFFSET,
146 |                 _ => 0,
147 |             };
148 |             terminal
149 |                 .set_cursor_position((cursor_position + offset, terminal.size()?.height - 1))?;
150 |             terminal.show_cursor()?;
151 |         }
152 |         _ => terminal.hide_cursor()?,
153 |     }
154 | 
155 |     Ok(())
156 | }
157 | 
158 | async fn sleep_if_timeout(timeout: &mut Option<Duration>) -> bool {
159 |     let Some(t) = timeout.take() else {
160 |         return false;
161 |     };
162 | 
163 |     tokio::time::sleep(t).await;
164 |     true
165 | }
166 | 
167 | async fn run_tui(
168 |     terminal: &mut DefaultTerminal,
169 |     rx: UnboundedReceiver<IoEvent>,
170 |     mut app: App,
171 | ) -> Result<()> {
172 |     let mut term_events = EventStream::new();
173 | 
174 |     let (req_tx, mut req_rx) = mpsc::unbounded_channel();
175 |     TX.init(req_tx);
176 | 
177 |     let mut client = client::Client::new(rx).await?;
178 |     tokio::spawn(async move { client.run().await });
179 | 
180 |     render(&mut app, terminal)?;
181 | 
182 |     let (mut timeout, mut last_render) = (None, Instant::now());
183 | 
184 |     loop {
185 |         tokio::select! {
186 |             true = sleep_if_timeout(&mut timeout) => {
187 |                 render(&mut app, terminal)?;
188 |                 last_render = Instant::now();
189 |             }
190 |             Some(Ok(term_event)) = term_events.next() => {
191 |                 if let Event::Key(key) = term_event
192 |                     && input::handle_event(key, &mut app)
193 |                 {
194 |                     break;
195 |                 }
196 | 
197 |                 render(&mut app, terminal)?;
198 |                 last_render = Instant::now();
199 |             },
200 |             Some(event) = req_rx.recv() => {
201 |                 handle_event(event, &mut app);
202 | 
203 |                 timeout = Duration::from_millis(OPTIONS.tick_rate).checked_sub(last_render.elapsed());
204 | 
205 |                 if timeout.is_none() {
206 |                     render(&mut app, terminal)?;
207 |                     last_render = Instant::now();
208 |                 }
209 |             }
210 |         }
211 |     }
212 | 
213 |     Ok(())
214 | }
215 | 
216 | fn reset_terminal() -> Result<()> {
217 |     disable_raw_mode()?;
218 |     execute!(io::stdout(), LeaveAlternateScreen)?;
219 | 
220 |     Ok(())
221 | }
222 | 
223 | fn handle_event(event: ClientRequest, app: &mut App) {
224 |     match event {
225 |         ClientRequest::SetRefreshState(id, state) => app.set_channel_refresh_state(&id, state),
226 |         ClientRequest::SetImportState(id, state) => {
227 |             let idx = app.import_state.find_by_id(&id).unwrap();
228 |             app.import_state.items[idx].sub_state = state;
229 | 
230 |             if let RefreshState::Completed = state {
231 |                 app.import_state.items.remove(idx);
232 |             }
233 |         }
234 |         ClientRequest::AddChannel(feed) => app.add_channel(feed),
235 |         ClientRequest::CheckChannel(id, tx) => {
236 |             tx.send(app.channels.get_mut_by_id(&id).is_some()).unwrap();
237 |         }
238 |         ClientRequest::FinalizeImport(imported_all) => {
239 |             if imported_all {
240 |                 app.input_mode = InputMode::Normal;
241 |             } else {
242 |                 for channel in &mut app.import_state.items {
243 |                     channel.sub_state = RefreshState::Completed;
244 |                 }
245 |             }
246 |         }
247 |         ClientRequest::UpdateChannel(feed) => app.add_tabs(feed),
248 |         ClientRequest::EnterFormatSelection(formats) => {
249 |             app.input_mode = InputMode::FormatSelection;
250 |             app.stream_formats = *formats;
251 |         }
252 |         ClientRequest::SetWatched(video_id, is_watched) => app.set_watched(&video_id, is_watched),
253 |         ClientRequest::SetMessage(msg, message_type, duration) => {
254 |             app.message.set_message(&msg);
255 |             app.message.message_type = message_type;
256 |             if let Some(duration) = duration {
257 |                 app.clear_message_after_duration(duration);
258 |             }
259 |         }
260 |         ClientRequest::ClearMessage => app.message.clear_message(),
261 |     }
262 | }
263 | 
264 | pub enum IoEvent {
265 |     SubscribeToChannel(String),
266 |     ImportChannels(Vec<String>),
267 |     RefreshChannels(Vec<String>),
268 |     LoadMoreVideos(String, ChannelTab, HashSet<String>),
269 |     FetchFormats(String, String, bool),
270 |     PlayFromFormats(Box<Formats>),
271 |     PlayUsingYtdlp(String),
272 |     OpenInBrowser(String, ApiBackend),
273 |     ClearMessage(CancellationToken, u64),
274 |     SwitchApi,
275 | }
276 | 


--------------------------------------------------------------------------------
/src/ui/utils.rs:
--------------------------------------------------------------------------------
  1 | use crate::{
  2 |     THEME,
  3 |     app::{State, StatefulList, Tab},
  4 |     channel::ChannelTab,
  5 | };
  6 | use ratatui::{
  7 |     layout::{Constraint, Direction, Layout, Rect},
  8 |     style::Color,
  9 |     text::Span,
 10 |     widgets::{BorderType, ListState},
 11 | };
 12 | use unicode_width::UnicodeWidthStr;
 13 | 
 14 | pub struct TitleBuilder<'a, T, S: State> {
 15 |     title: String,
 16 |     hide_flag: bool,
 17 |     list: Option<&'a StatefulList<T, S>>,
 18 |     tabs: Option<&'a StatefulList<Tab, ListState>>,
 19 |     tags: Option<Vec<&'a String>>,
 20 |     available_width: usize,
 21 | }
 22 | 
 23 | impl<'a, T, S: State> TitleBuilder<'a, T, S> {
 24 |     pub fn new(available_width: usize) -> Self {
 25 |         Self {
 26 |             title: String::new(),
 27 |             hide_flag: false,
 28 |             list: None,
 29 |             tabs: None,
 30 |             tags: None,
 31 |             available_width: available_width.saturating_sub(2),
 32 |         }
 33 |     }
 34 | 
 35 |     pub fn title(mut self, title: String) -> Self {
 36 |         self.title = title;
 37 |         self
 38 |     }
 39 | 
 40 |     pub fn hide_flag(mut self, hide: bool) -> Self {
 41 |         self.hide_flag = hide;
 42 |         self
 43 |     }
 44 | 
 45 |     pub fn list(mut self, list: &'a StatefulList<T, S>) -> Self {
 46 |         self.list = Some(list);
 47 |         self
 48 |     }
 49 | 
 50 |     pub fn tabs(mut self, tabs: &'a StatefulList<Tab, ListState>) -> Self {
 51 |         self.tabs = Some(tabs);
 52 |         self
 53 |     }
 54 | 
 55 |     pub fn tags(mut self, tags: Vec<&'a String>) -> Self {
 56 |         if !tags.is_empty() {
 57 |             self.tags = Some(tags);
 58 |         }
 59 | 
 60 |         self
 61 |     }
 62 | 
 63 |     pub fn build_title<'b>(mut self) -> Vec<Span<'b>> {
 64 |         const MIN_GAP: usize = 2;
 65 | 
 66 |         let mut title_sections = Vec::with_capacity(18);
 67 |         let border_symbols = BorderType::border_symbols(BorderType::Plain);
 68 |         let border_symbol_top = border_symbols.horizontal_top;
 69 | 
 70 |         if !self.title.is_empty() {
 71 |             let title = Span::styled(self.title, THEME.title);
 72 |             self.available_width = self.available_width.saturating_sub(title.width());
 73 | 
 74 |             title_sections.push(title);
 75 |         }
 76 | 
 77 |         if let Some(tabs) = self.tabs {
 78 |             let selected = tabs.get_selected().map(|tab| tab.variant);
 79 |             let mut sections = Vec::with_capacity(11);
 80 |             sections.push(Span::raw(border_symbol_top.repeat(2)));
 81 |             sections.push(Span::raw(format!("{} ", border_symbols.bottom_right)));
 82 | 
 83 |             for tab in &tabs.items {
 84 |                 let tab_title = match tab.variant {
 85 |                     ChannelTab::Videos => "Videos",
 86 |                     ChannelTab::Shorts => "Shorts",
 87 |                     ChannelTab::Streams => "Live",
 88 |                 };
 89 | 
 90 |                 sections.push(Span::styled(
 91 |                     tab_title,
 92 |                     if selected.is_some_and(|s| s == tab.variant) {
 93 |                         THEME.selected
 94 |                     } else {
 95 |                         Color::Reset.into()
 96 |                     },
 97 |                 ));
 98 | 
 99 |                 sections.push(Span::styled(
100 |                     if tab.has_new_video { " [N] " } else { " " },
101 |                     THEME.new_video_indicator,
102 |                 ));
103 | 
104 |                 sections.push(Span::raw(" "));
105 |             }
106 | 
107 |             if let Some(last) = sections.last_mut() {
108 |                 *last = Span::raw(border_symbols.bottom_left);
109 |             }
110 | 
111 |             let tabs_width = sections.iter().map(|s| s.width()).sum();
112 |             self.available_width = self.available_width.saturating_sub(tabs_width);
113 | 
114 |             title_sections.extend(sections);
115 |         }
116 | 
117 |         if self.hide_flag {
118 |             self.available_width = self.available_width.saturating_sub(4);
119 |         }
120 | 
121 |         let position = if let Some(list) = self.list {
122 |             Span::styled(
123 |                 format!(
124 |                     "{}/{}",
125 |                     if let Some(index) = list.state.selected() {
126 |                         index + 1
127 |                     } else {
128 |                         0
129 |                     },
130 |                     list.items.len()
131 |                 ),
132 |                 THEME.title,
133 |             )
134 |         } else {
135 |             Span::raw("")
136 |         };
137 | 
138 |         let required_width_for_position = if self.list.is_some() {
139 |             position.width() + MIN_GAP
140 |         } else {
141 |             0
142 |         };
143 | 
144 |         if let Some(tags) = self.tags {
145 |             let mut available_width = self
146 |                 .available_width
147 |                 .saturating_sub(required_width_for_position + 3);
148 | 
149 |             let mut shown_tags = Vec::new();
150 | 
151 |             for tag in tags {
152 |                 if tag.len() > available_width {
153 |                     if 2 > available_width {
154 |                         shown_tags.pop();
155 |                     }
156 | 
157 |                     shown_tags.push("..".to_string());
158 |                     break;
159 |                 }
160 | 
161 |                 shown_tags.push(tag.to_string());
162 |                 available_width = available_width.saturating_sub(tag.width() + 2);
163 |             }
164 | 
165 |             let tag_text = format!("[{}]", shown_tags.join(", "));
166 |             self.available_width = self.available_width.saturating_sub(tag_text.width() + 1);
167 | 
168 |             title_sections.push(Span::raw(border_symbol_top));
169 |             title_sections.push(Span::styled(tag_text, THEME.title));
170 |         }
171 | 
172 |         if self.hide_flag {
173 |             title_sections.push(Span::raw(border_symbol_top));
174 |             title_sections.push(Span::styled("[H]", THEME.title));
175 |         }
176 | 
177 |         if let Some(p_gap_width) = self
178 |             .available_width
179 |             .checked_sub(required_width_for_position)
180 |         {
181 |             let fill = Span::raw(border_symbol_top.repeat(p_gap_width + MIN_GAP));
182 |             title_sections.push(fill);
183 |             title_sections.push(position);
184 |         }
185 | 
186 |         title_sections
187 |     }
188 | }
189 | 
190 | #[derive(Debug, Copy, Clone, PartialEq)]
191 | pub struct Column<'a> {
192 |     pub header: &'a str,
193 |     pub constraint: Constraint,
194 |     min_width: u16,
195 | }
196 | 
197 | impl<'a> Column<'a> {
198 |     pub fn new(text: &'a str, constraint: Constraint, min_width: u16) -> Self {
199 |         Self {
200 |             header: text,
201 |             constraint,
202 |             min_width,
203 |         }
204 |     }
205 | }
206 | 
207 | pub fn filter_columns<'a>(
208 |     columns: &'a [Column],
209 |     available_width: u16,
210 |     spacing: u16,
211 | ) -> Vec<Column<'a>> {
212 |     let mut columns = Vec::from(columns);
213 |     let area = Rect::new(0, 0, available_width, 0);
214 | 
215 |     while let Some(idx) = Layout::new(Direction::Horizontal, columns.iter().map(|c| c.constraint))
216 |         .spacing(spacing)
217 |         .split(area)
218 |         .iter()
219 |         .zip(columns.iter())
220 |         .rev()
221 |         .position(|(chunk, column)| chunk.width < column.min_width)
222 |     {
223 |         columns.remove(columns.len() - 1 - idx);
224 |     }
225 | 
226 |     columns
227 | }
228 | 
229 | #[cfg(test)]
230 | mod tests {
231 |     use super::filter_columns;
232 |     use crate::ui::utils::Column;
233 |     use ratatui::layout::Constraint;
234 | 
235 |     #[test]
236 |     fn filter_length_and_min_constraints() {
237 |         let a = Column::new("a", Constraint::Length(5), 2);
238 |         let b = Column::new("b", Constraint::Min(10), 0);
239 |         let constraints = [a, b];
240 | 
241 |         assert_eq!(filter_columns(&constraints, 13, 0), vec![a, b]);
242 |         assert_eq!(filter_columns(&constraints, 11, 0), vec![b]);
243 |     }
244 | 
245 |     #[test]
246 |     fn filter_columns_with_fill() {
247 |         let a = Column::new("a", Constraint::Length(5), 2);
248 |         let b = Column::new("b", Constraint::Fill(1), 2);
249 |         let c = Column::new("c", Constraint::Min(10), 0);
250 |         let constraints = [a, b, c];
251 | 
252 |         assert_eq!(filter_columns(&constraints, 20, 0), vec![a, b, c]);
253 |         assert_eq!(filter_columns(&constraints, 16, 0), vec![a, c]);
254 |         assert_eq!(filter_columns(&constraints, 11, 0), vec![c]);
255 |     }
256 | 
257 |     #[test]
258 |     fn filter_columns_with_spacing() {
259 |         const SPACING: u16 = 2;
260 | 
261 |         let a = Column::new("a", Constraint::Length(45), 2);
262 |         let b = Column::new("b", Constraint::Min(90), 0);
263 |         let c = Column::new("c", Constraint::Fill(1), 5);
264 |         let d = Column::new("d", Constraint::Fill(1), 11);
265 |         let constraints = [a, b, c, d];
266 | 
267 |         assert_eq!(filter_columns(&constraints, 163, SPACING), constraints);
268 | 
269 |         let three = vec![a, b, c];
270 |         assert_eq!(filter_columns(&constraints, 162, SPACING), three);
271 |         assert_eq!(filter_columns(&constraints, 144, SPACING), three);
272 | 
273 |         let two = vec![a, b];
274 |         assert_eq!(filter_columns(&constraints, 143, SPACING), two);
275 |         assert_eq!(filter_columns(&constraints, 94, SPACING), two);
276 | 
277 |         let one = vec![b];
278 |         assert_eq!(filter_columns(&constraints, 93, SPACING), one);
279 |     }
280 | }
281 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # Changelog
  2 | All notable changes to this project will be documented in this file.
  3 | 
  4 | The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
  5 | and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
  6 | 
  7 | ## [Unreleased]
  8 | 
  9 | ## [0.7.0] - 2025-10-21
 10 | ### Added
 11 | - Show status messages related the video playing process.
 12 | [`de9cf6`](https://github.com/sarowish/ytsub/commit/de9cf6)
 13 | - Highlight new video indicators.
 14 | [`19ef92`](https://github.com/sarowish/ytsub/commit/19ef92)
 15 | - Add a command to load more videos for channels.
 16 | [`431917`](https://github.com/sarowish/ytsub/commit/431917)
 17 | - Automatically set Invidious instance when trying to open Invidous page in browser.
 18 | [`3b0e12`](https://github.com/sarowish/ytsub/commit/3b0e12)
 19 | - Update video title when refreshing if there is a change.
 20 | [`8fcc40`](https://github.com/sarowish/ytsub/commit/8fcc40)
 21 | - Show an indicator next to members only videos.
 22 | [`185c72`](https://github.com/sarowish/ytsub/commit/185c72)
 23 | - Separate videos, streams and shorts tabs.
 24 | [`62c17e`](https://github.com/sarowish/ytsub/commit/62c17e)
 25 | - Add an option for original audio track preference
 26 | [`a39c79`](https://github.com/sarowish/ytsub/commit/a39c79)
 27 | 
 28 | ### Changed
 29 | - Reduce `tick_rate` default value to 10 milliseconds.
 30 | [`69ffd7`](https://github.com/sarowish/ytsub/commit/69ffd7)
 31 | - Change the constraint type of the `Channel` column to `Length` from `Percentage`.
 32 | [`b688f7`](https://github.com/sarowish/ytsub/commit/b688f7)
 33 | - Rename `play_videos` command to `play_using_ytdlp` and swap its default
 34 | key binding with `play_from_formats` command.
 35 | [`7776f3`](https://github.com/sarowish/ytsub/commit/7776f3)
 36 | - Change the default value of the `rss_threshold` option to 9999.
 37 | [`b54f5c`](https://github.com/sarowish/ytsub/commit/b54f5c)
 38 | - Use videos endpoint in the Invidious API to get the videos tab
 39 | [`07fdf6`](https://github.com/sarowish/ytsub/commit/07fdf6)
 40 | - Jump to the selected video when jumping with `jump_to_channel`.
 41 | [`69caf7`](https://github.com/sarowish/ytsub/commit/69caf7)
 42 | 
 43 | ### Fixed
 44 | - Don't block when resolving channel ids.
 45 | [`f382a5`](https://github.com/sarowish/ytsub/commit/f382a5)
 46 | - Make buildable on non unix systems.
 47 | [`0853e6`](https://github.com/sarowish/ytsub/commit/0853e6)
 48 | - Add new videos in the correct order.
 49 | [`c221d7`](https://github.com/sarowish/ytsub/commit/c221d7)
 50 | - Preserve the order of videos videos when subscribing.
 51 | [`9860da`](https://github.com/sarowish/ytsub/commit/9860da)
 52 | - Ignore key release events.
 53 | [`419702`](https://github.com/sarowish/ytsub/commit/419702)
 54 | - Make the `video_quality` option in the config file optional.
 55 | [`ce79e9`](https://github.com/sarowish/ytsub/commit/ce79e9)
 56 | - Support extracting videos from `lockupViewModel`
 57 | [`f2d966`](https://github.com/sarowish/ytsub/commit/f2d966)
 58 | 
 59 | ## [0.6.0] - 2025-06-29
 60 | ### Added
 61 | - `esc` keybinding closes help and tag windows
 62 | [`ac35ee`](https://github.com/sarowish/ytsub/commit/ac35ee)
 63 | - Display a reason in the error message when the stream formats are not available for a video.
 64 | [`9e1ce2`](https://github.com/sarowish/ytsub/commit/9e1ce2)
 65 | - Don't generate instances file if there is no available Invidious instance.
 66 | [`9af0c4`](https://github.com/sarowish/ytsub/commit/9af0c4)
 67 | - Get chapter information for videos being played with `play_from_formats` command.
 68 | [`3d47fb`](https://github.com/sarowish/ytsub/commit/3d47fb)
 69 | 
 70 | ### Changed
 71 | - Lower the displayed precision of elapsed time on refresh completion.
 72 | [`8dd27a`](https://github.com/sarowish/ytsub/commit/8dd27a)
 73 | - Reverse the list of audio formats.
 74 | [`2eaecb`](https://github.com/sarowish/ytsub/commit/2eaecb)
 75 | 
 76 | ### Fixed
 77 | - Add missing value parsers to `database` and `instances` cli arguments.
 78 | [`80ffdf`](https://github.com/sarowish/ytsub/commit/80ffdf)
 79 | - Fix adaptive streams
 80 | [`4e4b12`](https://github.com/sarowish/ytsub/commit/4e4b12)
 81 | - Don't treat channels with no videos as nonexistent.
 82 | [`578f36`](https://github.com/sarowish/ytsub/commit/578f36)
 83 | - Do error handling for nonexistent channel handles when subscribing.
 84 | [`2fdbce`](https://github.com/sarowish/ytsub/commit/2fdbce)
 85 | - Apply the configurations for preferred video and audio codecs.
 86 | [`97449e`](https://github.com/sarowish/ytsub/commit/97449e)
 87 | 
 88 | ## [0.5.0] - 2025-01-07
 89 | ### Added
 90 | - Add a command to stream videos using formats
 91 | [`ffe7d1`](https://github.com/sarowish/ytsub/commit/ffe7d1)
 92 | - Resolve channel ID depending on the provided input while subscribing to a channel
 93 | [`7411b2`](https://github.com/sarowish/ytsub/commit/7411b2)
 94 | 
 95 | ### Changed
 96 | - Make Local API the default.
 97 | [`d28a4c`](https://github.com/sarowish/ytsub/commit/d28a4c)
 98 | 
 99 | ### Fixed
100 | - Handle short forms in published texts.
101 | [`547f6f`](https://github.com/sarowish/ytsub/commit/547f6f)
102 | - Take help text into account while determining floating window height.
103 | [`95c365`](https://github.com/sarowish/ytsub/commit/95c365)
104 | - Get channel name from a different field.
105 | [`b5bba5`](https://github.com/sarowish/ytsub/commit/b5bba5)
106 | - Don't assume the channel being subscribed to has at least 4 tabs
107 | [`9e3885`](https://github.com/sarowish/ytsub/commit/9e3885)
108 | - Fall back to Local API if no Invidious instance can be set.
109 | [`3c3058`](https://github.com/sarowish/ytsub/commit/3c3058)
110 | - Check for tabs in the whole tabs array.
111 | [`9abb22`](https://github.com/sarowish/ytsub/commit/9abb22)
112 | 
113 | ## [0.4.0] - 2023-02-06
114 | ### Added
115 | - Fetch instances from api.invidious.io after starting the tui.
116 | [`b6236d`](https://github.com/sarowish/ytsub/commit/b6236d)
117 | - Hide barely visable columns.
118 | [`0637d7`](https://github.com/sarowish/ytsub/commit/0637d7)
119 | - `O` key binding opens the channel or video Youtube page in browser.
120 | [`4ae403`](https://github.com/sarowish/ytsub/commit/4ae403)
121 | - Add Innertube API as an alternative.
122 | [`c53db8`](https://github.com/sarowish/ytsub/commit/c53db8)
123 | - Make channel refresh threshold and RSS threshold configurable.
124 | [`db3e1c`](https://github.com/sarowish/ytsub/commit/db3e1c)
125 | 
126 | ### Changed
127 | - Change `modify channels` help text to `pick channels`
128 | [`f7d456`](https://github.com/sarowish/ytsub/commit/f7d456)
129 | 
130 | ### Fixed
131 | - No longer crashes if no tag is selected when trying to modify channels of a tag.
132 | [`3b6276`](https://github.com/sarowish/ytsub/commit/3b6276)
133 | - Reload channels when a tag is deleted.
134 | [`4a63ae`](https://github.com/sarowish/ytsub/commit/4a63ae)
135 | - Don't automatically create config directory unless generating instances file.
136 | [`6ce6ec`](https://github.com/sarowish/ytsub/commit/6ce6ec)
137 | - Handle changes in Invidious API.
138 | [`d9ef23`](https://github.com/sarowish/ytsub/commit/d9ef23)
139 | - Ignore `refresh_threshold` when refreshing failed channels.
140 | [`bc6bbe`](https://github.com/sarowish/ytsub/commit/bc6bbe)
141 | 
142 | ## [0.3.1] - 2022-10-16
143 | ### Fixed
144 | - After a channel is successfully refreshed, set its `last_refreshed` field.
145 | [`f6a056a`](https://github.com/sarowish/ytsub/commit/f6a056a)
146 | 
147 | ## [0.3.0] - 2022-10-16
148 | ### Added
149 | - `D` key binding deletes the selected video from database.
150 | [`83238bc`](https://github.com/sarowish/ytsub/commit/83238bc)
151 | - Add import and export subcommands.
152 | [`4f3e073`](https://github.com/sarowish/ytsub/commit/4f3e073)
153 | - Classify some messages as warning.
154 | [`9d88336`](https://github.com/sarowish/ytsub/commit/9d88336)
155 | - Skip recently refreshed channels.
156 | [`89f8528`](https://github.com/sarowish/ytsub/commit/89f8528)
157 | - Group channels using tags.
158 | [`3e57063`](https://github.com/sarowish/ytsub/commit/3e57063)
159 | - Show warning if trying to subscribe to an already subscribed channel.
160 | [`ea83acc`](https://github.com/sarowish/ytsub/commit/ea83acc)
161 | 
162 | ### Changed
163 | - Ignore case when sorting channels list
164 | [`4e08381`](https://github.com/sarowish/ytsub/commit/4e08381)
165 | - Use rss if the number of channels exceeds 125.
166 | [`0bbca1d`](https://github.com/sarowish/ytsub/commit/0bbca1d)
167 | 
168 | ### Fixed
169 | - Mark new videos correctly.
170 | [`d91ce4e`](https://github.com/sarowish/ytsub/commit/d91ce4e)
171 | 
172 | ### Deprecated
173 | - Deprecate `--tick-rate`, `--request-timeout` and `--highlight-symbol` cli arguments.
174 | [`1fd5678`](https://github.com/sarowish/ytsub/commit/1fd5678)
175 | 
176 | ## [0.2.0] - 2022-05-31
177 | ### Added
178 | - Make theme, key bindings and options configurable through a configuration file.
179 | [`8688fb5`](https://github.com/sarowish/ytsub/commit/8688fb5)
180 | - `ctrl+h` opens a help window that shows the key bindings.
181 | [`c418969`](https://github.com/sarowish/ytsub/commit/c418969)
182 | 
183 | ### Changed
184 | - `o` key binding opens the channel page in browser if the channels is the selected block.
185 | [`2dc1e7c`](https://github.com/sarowish/ytsub/commit/2dc1e7c)
186 | 
187 | ### Fixed
188 | - Reset the terminal properly when the app panics or an error is propagated
189 | [`041aa75`](https://github.com/sarowish/ytsub/commit/041aa75)
190 | - Don't show an incorrect error message after aborting from search and trying to repeat the latest search.
191 | [`7e171cd`](https://github.com/sarowish/ytsub/commit/7e171cd)
192 | 
193 | ## [0.1.1] - 2022-05-13
194 | ### Fixed
195 | - Enable foreign key constraints in case they are disabled by default.
196 | [`029dc0c`](https://github.com/sarowish/ytsub/commit/029dc0c)
197 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # ytsub
  2 | 
  3 | ytsub is a subscriptions only tui youtube client.
  4 | 
  5 | ![demo](https://github.com/user-attachments/assets/974c8488-7963-4ed1-b300-2d7da8d460cc)
  6 | 
  7 | ## Dependencies
  8 | 
  9 | `mpv` and `yt-dlp` are optional dependencies for video playback. `yt-dlp` is not
 10 | needed for playback when using the `play_from_formats` command.
 11 | 
 12 | `sqlite` is a required dependency. If it is not available on the system,
 13 | it can be compiled and linked by enabling
 14 | the `bundled_sqlite` feature when building with cargo:
 15 | 
 16 | ```
 17 | cargo build --features bundled_sqlite
 18 | ```
 19 | 
 20 | ## Installation
 21 | 
 22 | ### Cargo
 23 | 
 24 | ```bash
 25 | cargo install ytsub
 26 | 
 27 | # or
 28 | cargo install ytsub --features bundled_sqlite
 29 | ```
 30 | 
 31 | ### Arch Linux
 32 | 
 33 | `ytsub` is available in the AUR as
 34 | [stable source package](https://aur.archlinux.org/packages/ytsub),
 35 | [stable binary package](https://aur.archlinux.org/packages/ytsub-bin) and
 36 | [latest development package](https://aur.archlinux.org/packages/ytsub-git).
 37 | You can install it using your preferred AUR helper.
 38 | 
 39 | ```bash
 40 | # stable source package
 41 | paru -S ytsub
 42 | 
 43 | # stable binary package
 44 | paru -S ytsub-bin
 45 | 
 46 | # latest development package
 47 | paru -S ytsub-git
 48 | ```
 49 | 
 50 | ## Usage
 51 | 
 52 | ```
 53 | Usage: ytsub [OPTIONS] [COMMAND]
 54 | 
 55 | Commands:
 56 |   import  Import subscriptions
 57 |   export  Export subscriptions
 58 |   help    Print this message or the help of the given subcommand(s)
 59 | 
 60 | Options:
 61 |   -c, --config <FILE>     Path to configuration file
 62 |   -n, --no-config         Ignore configuration file
 63 |   -d, --database <FILE>   Path to database file
 64 |   -s, --instances <FILE>  Path to instances file
 65 |   -g, --gen-instances     Generate Invidious instances file
 66 |   -h, --help              Print help
 67 |   -V, --version           Print version
 68 | ```
 69 | 
 70 | For default key bindings, press `ctrl-h` in the app or refer to
 71 | the [example `config.toml` file](#example-configtoml-with-default-values).
 72 | 
 73 | ### Subscribing
 74 | Pressing `i` prompts the user to enter a channel id or url. 
 75 | 
 76 | #### Example inputs
 77 | 
 78 | - `UCsXVk37bltHxD1rDPwtNM8Q`
 79 | - `https://youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q`
 80 | - `<INVIDIOUS_INSTANCE>/channel/UCsXVk37bltHxD1rDPwtNM8Q`
 81 | - `@kurzgesagt`
 82 | - `https://youtube.com/@kurzgesagt`
 83 | 
 84 | ## Configuration
 85 | 
 86 | Default directory of the configuration files is `$HOME/.config/ytsub`.
 87 | 
 88 | | File                         | Description                                   |
 89 | |------------------------------|-----------------------------------------------|
 90 | | [`config.toml`](#configtoml) | option, key binding and theme configurations  |
 91 | | [`instances`](#instances)    | list of invidious instances                   |
 92 | 
 93 | ### `config.toml`
 94 | 
 95 | Path to the configuration file can be specified with the `-c` flag.
 96 | 
 97 | #### Example `config.toml` with default values
 98 | 
 99 | ```toml
100 | # Options
101 | 
102 | database = "/home/username/.local/share/ytsub/videos.db" # Path to database file
103 | instances = "/home/username/.config/ytsub/instances" # Path to instances file
104 | tabs = ["videos"] # Tabs to fetch videos from [possible values: videos, shorts, streams]
105 | hide_disabled_tabs = true # Hide available tabs in the ui if they are not in the `tabs` option
106 | api = "local" # API to be used for fetching videos [possible values: invidious, local]
107 | refresh_threshold = 600 # Time in seconds that needs to pass before refreshing a channel using the refresh_channels command
108 | rss_threshold = 9999 # Use RSS if the number of channels being refreshed or being subscribed to exceeds the specified amount
109 | tick_rate = 10 # Tick rate in milliseconds
110 | request_timeout = 5 # Request timeout in seconds
111 | highlight_symbol = "" # Symbol to highlight selected items
112 | hide_watched = false # Hide watched videos by default
113 | hide_members_only = false # Hide members only videos
114 | video_player_for_stream_formats = "mpv" # Video player to use to play streams [possible values: mpv, vlc]
115 | mpv_path = "mpv" # Path to mpv
116 | vlc_path = "vlc" # Path to vlc
117 | 
118 | # the options below apply only while playing stream formats
119 | subtitle_languages = [] # Subtitle languages to add
120 | prefer_dash_formats = true # Use adaptive formats
121 | prefer_original_audio = true # Use original audio tracks
122 | video_quality = "best" # Preferred video quality
123 | # the commented out options below are `None` by default
124 | # preferred_video_codec = "webm" # [possible values: webm, mp4]
125 | # preferred_audio_codec = "webm"
126 | chapters = true # Get chapter information of videos
127 | 
128 | # Theme
129 | 
130 | # fg and bg fields can be set with rgb (ex: "255, 255, 255"),
131 | # hex (ex: "#ffffff") or named colors.
132 | # Valid color names are Black, Red, Green, Yellow, Blue, Magenta
133 | # Cyan, Gray, DarkGray, LightRed, LightGreen, LightGreen,
134 | # LightYellow, LightBlue, LightMagenta, LightCyan, White and Reset.
135 | 
136 | # Valid modifiers are bold, dim, italic, underlined,
137 | # slow_blink, rapid_blink, reversed, hidden and crossed_out.
138 | 
139 | # Example:
140 | # [title]
141 | # fg = "#123456"
142 | # bg = "10, 250, 99"
143 | # modifiers = "bold reversed italic"
144 | 
145 | # Example with alternative syntax:
146 | # title = { fg = "#123456", bg = "10, 250, 99", modifiers = "bold reversed italic" }
147 | 
148 | # Block titles
149 | [title]
150 | fg = "Cyan"
151 | modifiers = "bold"
152 | # Channel, Title, Length and Date headers
153 | [header]
154 | fg = "Yellow"
155 | modifiers = "bold"
156 | # Selected item in inactive block
157 | [selected]
158 | fg = "Blue"
159 | modifiers = "bold"
160 | # Selected item in active block
161 | [focused]
162 | fg = "Magenta"
163 | modifiers = "bold"
164 | # Watched videos
165 | [watched]
166 | fg = "DarkGray"
167 | # Selected watched video in inactive block
168 | # Overrides the modifiers of [selected]. If fg and bg are set, they are patched to [selected]
169 | [selected_watched]
170 | # Selected watched video in active block
171 | # Overrides the modifiers of [focused]. If fg and bg are set, they are patched to [focused]
172 | [focused_watched]
173 | # New video indicator
174 | [new_video_indicator]
175 | fg = "Red"
176 | modifiers = "italic"
177 | # Members only video indicator
178 | [members_only_indicator]
179 | fg = "Green"
180 | modifiers = "italic"
181 | # Border of selected block
182 | [selected_block]
183 | fg = "Magenta"
184 | # Error message
185 | [error]
186 | fg = "Red"
187 | # Warning message
188 | [warning]
189 | fg = "Yellow"
190 | # Key bindings in the help window
191 | [help]
192 | fg = "Green"
193 | 
194 | # Key Bindings
195 | 
196 | # Valid key codes are backspace, space, enter, left, right, up, down, home, end
197 | # pageup, pagedown, tab, backtab, del, delete, insert, esc, escape and characters.
198 | 
199 | # Valid modifiers are ctrl, shift and alt.
200 | 
201 | # Multiple key bindings can be set in a single line.
202 | # Example: "escape q ctrl-c" = "quit"
203 | 
204 | # A default binding can be removed by setting it to an empty string.
205 | # Example: "q" = ""
206 | 
207 | [key_bindings]
208 | "1" = "set_mode_subs" # Switch to subscriptions mode
209 | "2" = "set_mode_latest_videos" # Switch to latest videos mode
210 | "j down" = "on_down" # Go one line downward
211 | "k up" = "on_up" # Go one line upward
212 | "h left" = "on_left" # Switch to channels block
213 | "l right" = "on_right" # Switch to videos block
214 | "g" = "select_first" # Jump to the first line in the list
215 | "G" = "select_last" # Jump to the last line in the list
216 | "L" = "next_tab" # Select next video tab
217 | "H" = "previous_tab" # Select previous video tab
218 | "c" = "jump_to_channel" # Jump to the channel of the selected video from latest videos mode
219 | "t" = "toggle_hide" # Hide/unhide watched videos
220 | "i" = "subscribe" # Enter editing mode to enter channel id or url
221 | "d" = "unsubscribe" # Open confirmation window to unsubcribe from the selected channel
222 | "D" = "delete_video" # Delete the selected video from database
223 | "/" = "search_forward" # Enter editing mode to make a forward search
224 | "?" = "search_backward" # Enter editing mode to make a backward search
225 | "n" = "repeat_last_search" # Search with the latest pattern and direction
226 | "N" = "repeat_last_search_opposite" # Search with the latest pattern and opposite direction
227 | "s" = "switch_api" # Switch between the available APIs
228 | "r" = "refresh_channel" # Refresh videos of the selected channel
229 | "R" = "refresh_channels" # Refresh videos of every channel
230 | "J" = "load_more_videos" # Load more videos for the selected channel
231 | "F" = "refresh_failed_channels" # Refresh videos of channels which their latest refresh was a failure
232 | "o" = "open_in_youtube" # Open channel or video Youtube page in browser
233 | "O" = "open_in_invidious" # Open channel or video Invidious page in browser
234 | "p" = "play_from_formats" # Play selected video in a video player using stream formats
235 | "P" = "play_using_ytdlp" # Play selected video in mpv using yt-dlp
236 | "f" = "select_formats" # Toggle format selection window
237 | "m" = "toggle_watched" # Mark/unmark selected video as watched
238 | "ctrl-h" = "toggle_help" # Toggle help window
239 | "T" = "toggle_tag" # Toggle tag window
240 | "q ctrl-c" = "quit" # Quit application
241 | 
242 | [key_bindings.help]
243 | "ctrl-y" = "scroll_up" #general "on_up" binding also applies
244 | "ctrl-e" = "scroll_down" # general "on_down" binding also applies
245 | "g" = "go_to_top" # general "select_first" binding also applies
246 | "G" = "go_to_bottom" # general "select_last" binding also applies
247 | "escape" = "abort"
248 | 
249 | [key_bindings.import]
250 | "space" = "toggle_selection" # Select/Unselect channel
251 | "a" = "select_all" # Select all channels
252 | "z" = "deselect_all" # Deselect all channels
253 | "enter" = "import" # Import selected channels
254 | 
255 | [key_bindings.tag]
256 | "i" = "create_tag"
257 | "d" = "delete_tag"
258 | "r" = "rename_tag"
259 | "s" = "select_channels" # Pick channels for the tag
260 | "space" = "toggle_selection" # Select/Unselect tag
261 | "a" = "select_all" # Select all tags
262 | "z" = "deselect_all" # Deselect all tags
263 | "escape" = "abort" # Close window
264 | 
265 | [key_bindings.channel_selection]
266 | "enter" = "confirm" # Confirm the selection of channels
267 | "escape" = "abort" # Drop changes
268 | "space" = "toggle_selection" # Select/Unselect channel
269 | "a" = "select_all" # Select all channels
270 | "z" = "deselect_all" # Deselect all channels
271 | 
272 | [key_bindings.format_selection]
273 | "enter" = "play_video"
274 | "escape" = "abort"
275 | "space" = "select"
276 | "l right" = "next_tab"
277 | "h left" = "previous_tab"
278 | "s" = "switch_format_type"
279 | ```
280 | 
281 | ### `instances`
282 | 
283 | > [!NOTE]
284 | > At the time of writing, there are no suitable instances available on https://api.invidious.io,
285 | > and they've rarely been available for quite a while now.
286 | 
287 | A custom path to the `instances` file can be specified with the `-i` flag.
288 | The file can either be manually created by adding instances that have API enabled or
289 | automatically generated from the instances in https://api.invidious.io by running the app with `-g` flag.
290 | Every instance entry is separated by a line.
291 | If the `instances` file doesn't exist, instances list will be built from https://api.invidious.io when
292 | Invidious is selected as the API (as opposed to the local API).
293 | 
294 | #### Example `instances` file
295 | 
296 | ```
297 | https://vid.puffyan.us
298 | https://invidio.xamh.de
299 | https://inv.riverside.rocks
300 | https://yt.artemislena.eu
301 | ```
302 | 


--------------------------------------------------------------------------------
/src/input.rs:
--------------------------------------------------------------------------------
  1 | use crate::{
  2 |     KEY_BINDINGS, OPTIONS,
  3 |     api::ApiBackend,
  4 |     app::{App, VideoPlayer},
  5 |     commands::{
  6 |         ChannelSelectionCommand, Command, FormatSelectionCommand, HelpCommand, ImportCommand,
  7 |         TagCommand,
  8 |     },
  9 |     help::HelpWindowState,
 10 | };
 11 | use crossterm::event::{KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
 12 | 
 13 | #[derive(Clone)]
 14 | pub enum InputMode {
 15 |     Normal,
 16 |     Subscribe,
 17 |     Search,
 18 |     Confirmation,
 19 |     Import,
 20 |     Tag,
 21 |     TagCreation,
 22 |     TagRenaming,
 23 |     ChannelSelection,
 24 |     FormatSelection,
 25 | }
 26 | 
 27 | pub fn handle_event(key: KeyEvent, app: &mut App) -> bool {
 28 |     if key.kind == KeyEventKind::Release {
 29 |         return false;
 30 |     }
 31 | 
 32 |     match app.input_mode {
 33 |         _ if app.help_window_state.show => {
 34 |             return handle_key_help_mode(key, &mut app.help_window_state);
 35 |         }
 36 |         InputMode::Normal => return handle_key_normal_mode(key, app),
 37 |         InputMode::Confirmation => handle_key_confirmation_mode(key, app),
 38 |         InputMode::Import => return handle_key_import_mode(key, app),
 39 |         InputMode::Tag => return handle_key_tag_mode(key, app),
 40 |         InputMode::ChannelSelection => return handle_key_channel_selection_mode(key, app),
 41 |         InputMode::FormatSelection => return handle_key_format_selection_mode(key, app),
 42 |         _ => handle_key_editing_mode(key, app),
 43 |     }
 44 | 
 45 |     false
 46 | }
 47 | 
 48 | fn handle_key_normal_mode(key: KeyEvent, app: &mut App) -> bool {
 49 |     if let Some(command) = KEY_BINDINGS.get(&key) {
 50 |         match command {
 51 |             Command::SetModeSubs => app.set_mode_subs(),
 52 |             Command::SetModeLatestVideos => app.set_mode_latest_videos(),
 53 |             Command::OnDown => app.on_down(),
 54 |             Command::OnUp => app.on_up(),
 55 |             Command::OnLeft => app.on_left(),
 56 |             Command::OnRight => app.on_right(),
 57 |             Command::SelectFirst => app.select_first(),
 58 |             Command::SelectLast => app.select_last(),
 59 |             Command::NextTab => app.tabs.next(),
 60 |             Command::PreviousTab => app.tabs.previous(),
 61 |             Command::JumpToChannel => app.jump_to_channel(),
 62 |             Command::ToggleHide => app.toggle_hide(),
 63 |             Command::Subscribe => app.prompt_for_subscription(),
 64 |             Command::Unsubscribe => app.prompt_for_unsubscribing(),
 65 |             Command::DeleteVideo => app.delete_selected_video(),
 66 |             Command::SearchForward => app.search_forward(),
 67 |             Command::SearchBackward => app.search_backward(),
 68 |             Command::RepeatLastSearch => app.repeat_last_search(),
 69 |             Command::RepeatLastSearchOpposite => app.repeat_last_search_opposite(),
 70 |             Command::SwitchApi => app.switch_api(),
 71 |             Command::RefreshChannel => app.refresh_channel(),
 72 |             Command::RefreshChannels => app.refresh_channels(),
 73 |             Command::RefreshFailedChannels => app.refresh_failed_channels(),
 74 |             Command::LoadMoreVideos => app.get_more_videos(),
 75 |             Command::OpenInInvidious => app.open_in_browser(ApiBackend::Invidious),
 76 |             Command::OpenInYoutube => app.open_in_browser(ApiBackend::Local),
 77 |             Command::PlayFromFormats => app.play_from_formats(),
 78 |             Command::PlayUsingYtdlp => app.play_video(),
 79 |             Command::SelectFormats => app.enter_format_selection(),
 80 |             Command::ToggleWatched => app.toggle_watched(),
 81 |             Command::ToggleHelp => app.toggle_help(),
 82 |             Command::ToggleTag => app.toggle_tag_selection(),
 83 |             Command::Quit => return true,
 84 |         }
 85 |     }
 86 | 
 87 |     false
 88 | }
 89 | 
 90 | fn handle_key_help_mode(key: KeyEvent, help_window_state: &mut HelpWindowState) -> bool {
 91 |     if let Some(command) = KEY_BINDINGS.help.get(&key) {
 92 |         match command {
 93 |             HelpCommand::ScrollUp => help_window_state.scroll_up(),
 94 |             HelpCommand::ScrollDown => help_window_state.scroll_down(),
 95 |             HelpCommand::GoToTop => help_window_state.scroll_top(),
 96 |             HelpCommand::GoToBottom => help_window_state.scroll_bottom(),
 97 |             HelpCommand::Abort => help_window_state.toggle(),
 98 |         }
 99 |     } else if let Some(command) = KEY_BINDINGS.get(&key) {
100 |         match command {
101 |             Command::OnDown => help_window_state.scroll_down(),
102 |             Command::OnUp => help_window_state.scroll_up(),
103 |             Command::SelectFirst => help_window_state.scroll_top(),
104 |             Command::SelectLast => help_window_state.scroll_bottom(),
105 |             Command::ToggleHelp => help_window_state.toggle(),
106 |             Command::Quit => return true,
107 |             _ => (),
108 |         }
109 |     }
110 | 
111 |     false
112 | }
113 | 
114 | fn handle_key_confirmation_mode(key: KeyEvent, app: &mut App) {
115 |     match key.code {
116 |         KeyCode::Char('y') => app.unsubscribe(),
117 |         KeyCode::Char('n') => app.input_mode = InputMode::Normal,
118 |         _ => (),
119 |     }
120 | }
121 | 
122 | fn handle_key_import_mode(key: KeyEvent, app: &mut App) -> bool {
123 |     if let Some(command) = KEY_BINDINGS.import.get(&key) {
124 |         match command {
125 |             ImportCommand::ToggleSelection => app.import_state.toggle_selected(),
126 |             ImportCommand::SelectAll => app.import_state.select_all(),
127 |             ImportCommand::DeselectAll => app.import_state.deselect_all(),
128 |             ImportCommand::Import => app.confirm_import(),
129 |         }
130 |     } else if let Some(command) = KEY_BINDINGS.get(&key) {
131 |         match command {
132 |             Command::OnDown => app.import_state.next(),
133 |             Command::OnUp => app.import_state.previous(),
134 |             Command::SelectFirst => app.import_state.select_first(),
135 |             Command::SelectLast => app.import_state.select_last(),
136 |             Command::SearchForward => app.search_forward(),
137 |             Command::SearchBackward => app.search_backward(),
138 |             Command::RepeatLastSearch => app.repeat_last_search(),
139 |             Command::RepeatLastSearchOpposite => app.repeat_last_search_opposite(),
140 |             Command::Quit => return true,
141 |             _ => (),
142 |         }
143 |     }
144 | 
145 |     false
146 | }
147 | 
148 | fn handle_key_tag_mode(key: KeyEvent, app: &mut App) -> bool {
149 |     if let Some(command) = KEY_BINDINGS.tag.get(&key) {
150 |         let mut updated = false;
151 | 
152 |         match command {
153 |             TagCommand::ToggleSelection => {
154 |                 app.tags.toggle_selected();
155 |                 updated = true;
156 |             }
157 |             TagCommand::SelectAll => {
158 |                 app.tags.select_all();
159 |                 updated = true;
160 |             }
161 |             TagCommand::DeselectAll => {
162 |                 app.tags.deselect_all();
163 |                 updated = true;
164 |             }
165 |             TagCommand::SelectChannels => app.enter_channel_selection(),
166 |             TagCommand::CreateTag => app.enter_tag_creation(),
167 |             TagCommand::DeleteTag => app.delete_selected_tag(),
168 |             TagCommand::RenameTag => app.enter_tag_renaming(),
169 |             TagCommand::Abort => app.toggle_tag_selection(),
170 |         }
171 | 
172 |         if updated {
173 |             app.load_channels();
174 |             app.channels.select_first();
175 |             app.on_change_channel();
176 |         }
177 |     } else if let Some(command) = KEY_BINDINGS.get(&key) {
178 |         match command {
179 |             Command::OnDown => app.tags.next(),
180 |             Command::OnUp => app.tags.previous(),
181 |             Command::SelectFirst => app.tags.select_first(),
182 |             Command::SelectLast => app.tags.select_last(),
183 |             Command::SearchForward => app.search_forward(),
184 |             Command::SearchBackward => app.search_backward(),
185 |             Command::RepeatLastSearch => app.repeat_last_search(),
186 |             Command::RepeatLastSearchOpposite => app.repeat_last_search_opposite(),
187 |             Command::ToggleTag => app.toggle_tag_selection(),
188 |             Command::Quit => return true,
189 |             _ => (),
190 |         }
191 |     }
192 | 
193 |     false
194 | }
195 | 
196 | fn handle_key_channel_selection_mode(key: KeyEvent, app: &mut App) -> bool {
197 |     if let Some(command) = KEY_BINDINGS.channel_selection.get(&key) {
198 |         match command {
199 |             ChannelSelectionCommand::Confirm => app.update_tag(),
200 |             ChannelSelectionCommand::Abort => app.input_mode = InputMode::Tag,
201 |             ChannelSelectionCommand::ToggleSelection => app.channel_selection.toggle_selected(),
202 |             ChannelSelectionCommand::SelectAll => app.channel_selection.select_all(),
203 |             ChannelSelectionCommand::DeselectAll => app.channel_selection.deselect_all(),
204 |         }
205 |     } else if let Some(command) = KEY_BINDINGS.get(&key) {
206 |         match command {
207 |             Command::OnDown => app.channel_selection.next(),
208 |             Command::OnUp => app.channel_selection.previous(),
209 |             Command::SelectFirst => app.channel_selection.select_first(),
210 |             Command::SelectLast => app.channel_selection.select_last(),
211 |             Command::SearchForward => app.search_forward(),
212 |             Command::SearchBackward => app.search_backward(),
213 |             Command::RepeatLastSearch => app.repeat_last_search(),
214 |             Command::RepeatLastSearchOpposite => app.repeat_last_search_opposite(),
215 |             Command::Quit => return true,
216 |             _ => (),
217 |         }
218 |     }
219 | 
220 |     false
221 | }
222 | 
223 | fn handle_key_format_selection_mode(key: KeyEvent, app: &mut App) -> bool {
224 |     if let Some(command) = KEY_BINDINGS.format_selection.get(&key) {
225 |         match command {
226 |             FormatSelectionCommand::PlayVideo => app.confirm_selected_streams(),
227 |             FormatSelectionCommand::Abort => app.input_mode = InputMode::Normal,
228 |             FormatSelectionCommand::Select => {
229 |                 let tab_index = app.stream_formats.selected_tab;
230 |                 let formats = app.stream_formats.get_mut_selected_tab();
231 | 
232 |                 if tab_index == 2
233 |                     && matches!(OPTIONS.video_player_for_stream_formats, VideoPlayer::Mpv)
234 |                 {
235 |                     formats.toggle_selected();
236 |                 } else {
237 |                     formats.select();
238 |                 }
239 |             }
240 |             FormatSelectionCommand::PreviousTab => app.stream_formats.previous_tab(),
241 |             FormatSelectionCommand::NextTab => app.stream_formats.next_tab(),
242 |             FormatSelectionCommand::SwitchFormatType => app.stream_formats.switch_format_type(),
243 |         }
244 |     } else if let Some(command) = KEY_BINDINGS.get(&key) {
245 |         match command {
246 |             Command::OnDown => app.stream_formats.get_mut_selected_tab().next(),
247 |             Command::OnUp => app.stream_formats.get_mut_selected_tab().previous(),
248 |             Command::SelectFirst => app.stream_formats.get_mut_selected_tab().select_first(),
249 |             Command::SelectLast => app.stream_formats.get_mut_selected_tab().select_last(),
250 |             Command::SearchForward => app.search_forward(),
251 |             Command::SearchBackward => app.search_backward(),
252 |             Command::RepeatLastSearch => app.repeat_last_search(),
253 |             Command::RepeatLastSearchOpposite => app.repeat_last_search_opposite(),
254 |             Command::Quit => return true,
255 |             _ => (),
256 |         }
257 |     }
258 | 
259 |     false
260 | }
261 | 
262 | fn handle_key_editing_mode(key: KeyEvent, app: &mut App) {
263 |     match (key.code, key.modifiers) {
264 |         (KeyCode::Left, KeyModifiers::CONTROL) => app.move_cursor_one_word_left(),
265 |         (KeyCode::Right, KeyModifiers::CONTROL) => app.move_cursor_one_word_right(),
266 |         (KeyCode::Left, _) | (KeyCode::Char('b'), KeyModifiers::CONTROL) => app.move_cursor_left(),
267 |         (KeyCode::Right, _) | (KeyCode::Char('f'), KeyModifiers::CONTROL) => {
268 |             app.move_cursor_right();
269 |         }
270 |         (KeyCode::Char('a'), KeyModifiers::CONTROL) => app.move_cursor_to_beginning_of_line(),
271 |         (KeyCode::Char('e'), KeyModifiers::CONTROL) => app.move_cursor_to_end_of_line(),
272 |         (KeyCode::Char('w'), KeyModifiers::CONTROL) => app.delete_word_before_cursor(),
273 |         (KeyCode::Char('u'), KeyModifiers::CONTROL) => app.clear_line(),
274 |         (KeyCode::Char('k'), KeyModifiers::CONTROL) => app.clear_to_right(),
275 |         (KeyCode::Enter, _) => complete(app),
276 |         (KeyCode::Backspace, _) | (KeyCode::Char('h'), KeyModifiers::CONTROL) => app.pop_key(),
277 |         (KeyCode::Char(c), _) => app.push_key(c),
278 |         (KeyCode::Esc, _) => abort(app),
279 |         _ => {}
280 |     }
281 | }
282 | 
283 | fn complete(app: &mut App) {
284 |     match app.input_mode {
285 |         InputMode::Subscribe => app.subscribe(),
286 |         InputMode::Search => app.complete_search(),
287 |         InputMode::TagCreation => app.create_tag(),
288 |         InputMode::TagRenaming => app.rename_selected_tag(),
289 |         _ => (),
290 |     }
291 | }
292 | 
293 | fn abort(app: &mut App) {
294 |     match app.input_mode {
295 |         InputMode::Subscribe | InputMode::TagCreation | InputMode::TagRenaming => {
296 |             app.input_mode = app.prev_input_mode.clone();
297 |             app.input.clear();
298 |         }
299 |         InputMode::Search => app.abort_search(),
300 |         _ => (),
301 |     }
302 | }
303 | 


--------------------------------------------------------------------------------
/src/client.rs:
--------------------------------------------------------------------------------
  1 | use crate::{
  2 |     IoEvent, OPTIONS,
  3 |     api::{Api, ApiBackend, ChannelFeed, invidious::Instance, local::Local},
  4 |     channel::{ChannelTab, RefreshState},
  5 |     message::MessageType,
  6 |     player::{self, open_in_invidious, open_in_youtube, play_from_formats, play_using_ytdlp},
  7 |     ro_cell::RoCell,
  8 |     stream_formats::Formats,
  9 |     utils,
 10 | };
 11 | use anyhow::Result;
 12 | use futures_util::StreamExt;
 13 | use std::{collections::HashSet, time::Instant};
 14 | use tokio::{
 15 |     sync::{
 16 |         mpsc::{UnboundedReceiver, UnboundedSender},
 17 |         oneshot::{self, Sender},
 18 |     },
 19 |     time::sleep,
 20 | };
 21 | use tokio_util::sync::CancellationToken;
 22 | 
 23 | pub enum ClientRequest {
 24 |     SetRefreshState(String, RefreshState),
 25 |     SetImportState(String, RefreshState),
 26 |     AddChannel(ChannelFeed),
 27 |     CheckChannel(String, Sender<bool>),
 28 |     FinalizeImport(bool),
 29 |     UpdateChannel(ChannelFeed),
 30 |     EnterFormatSelection(Box<Formats>),
 31 |     SetWatched(String, bool),
 32 |     SetMessage(String, MessageType, Option<u64>),
 33 |     ClearMessage,
 34 | }
 35 | 
 36 | #[macro_export]
 37 | macro_rules! emit_msg {
 38 |     () => {
 39 |         TX.send($crate::client::ClientRequest::ClearMessage)?
 40 |     };
 41 |     ($message: expr) => {
 42 |         emit_msg!($message, $crate::message::MessageType::Normal)
 43 |     };
 44 |     (perm, $message: expr) => {
 45 |         TX.send($crate::client::ClientRequest::SetMessage(
 46 |             $message.to_owned(),
 47 |             $crate::message::MessageType::Normal,
 48 |             None,
 49 |         ))?
 50 |     };
 51 |     (error, $message: expr) => {
 52 |         emit_msg!($message, $crate::message::MessageType::Error)
 53 |     };
 54 |     (warning, $message: expr) => {
 55 |         emit_msg!($message, $crate::message::MessageType::Warning)
 56 |     };
 57 |     ($message: expr, $message_type: expr) => {
 58 |         TX.send($crate::client::ClientRequest::SetMessage(
 59 |             $message.to_owned(),
 60 |             $message_type,
 61 |             Some(5),
 62 |         ))?
 63 |     };
 64 | }
 65 | 
 66 | pub static TX: RoCell<UnboundedSender<ClientRequest>> = RoCell::new();
 67 | 
 68 | pub struct Client {
 69 |     rx: UnboundedReceiver<IoEvent>,
 70 |     pub invidious_instances: Option<Vec<String>>,
 71 |     pub invidious_instance: Option<Instance>,
 72 |     local_api: Local,
 73 |     pub selected_api: ApiBackend,
 74 | }
 75 | 
 76 | impl Client {
 77 |     pub async fn new(rx: UnboundedReceiver<IoEvent>) -> Result<Self> {
 78 |         let mut client = Self {
 79 |             rx,
 80 |             invidious_instances: utils::read_instances().ok(),
 81 |             invidious_instance: None,
 82 |             local_api: Local::new(),
 83 |             selected_api: OPTIONS.api,
 84 |         };
 85 | 
 86 |         if let ApiBackend::Invidious = client.selected_api {
 87 |             client.set_instance().await?;
 88 |         }
 89 | 
 90 |         Ok(client)
 91 |     }
 92 | 
 93 |     pub async fn run(&mut self) -> Result<()> {
 94 |         while let Some(event) = self.rx.recv().await {
 95 |             match event {
 96 |                 IoEvent::SubscribeToChannel(id) => {
 97 |                     let instance = self.instance();
 98 |                     tokio::spawn(async move { subscribe_to_channel(instance, id).await });
 99 |                 }
100 |                 IoEvent::ImportChannels(ids) => {
101 |                     let instance = self.instance();
102 |                     import_channels(instance, ids).await?;
103 |                 }
104 |                 IoEvent::RefreshChannels(ids) => {
105 |                     let instance = self.instance();
106 |                     tokio::spawn(async move { refresh_channels(instance, ids).await });
107 |                 }
108 |                 IoEvent::LoadMoreVideos(id, tab, present_videos) => {
109 |                     let instance = self.instance();
110 |                     tokio::spawn(async move {
111 |                         get_more_videos(instance, &id, tab, present_videos).await
112 |                     });
113 |                 }
114 |                 IoEvent::FetchFormats(title, video_id, play_selected) => {
115 |                     let instance = self.instance();
116 |                     tokio::spawn(async move {
117 |                         fetch_formats(instance, title, video_id, play_selected).await
118 |                     });
119 |                 }
120 |                 IoEvent::PlayFromFormats(formats) => {
121 |                     let instance = self.instance();
122 |                     tokio::spawn(async move { play_from_formats(instance, *formats).await });
123 |                 }
124 |                 IoEvent::PlayUsingYtdlp(video_id) => {
125 |                     tokio::spawn(async move { play_using_ytdlp(&video_id).await });
126 |                 }
127 |                 IoEvent::OpenInBrowser(url_component, api) => match api {
128 |                     ApiBackend::Local => open_in_youtube(&url_component),
129 |                     ApiBackend::Invidious => open_in_invidious(self, &url_component).await?,
130 |                 },
131 |                 IoEvent::ClearMessage(token, duration) => {
132 |                     tokio::spawn(async move { clear_message(token, duration).await });
133 |                 }
134 |                 IoEvent::SwitchApi => self.switch_api().await?,
135 |             }
136 |         }
137 | 
138 |         Ok(())
139 |     }
140 | 
141 |     fn instance(&self) -> Box<dyn Api> {
142 |         match self.selected_api {
143 |             ApiBackend::Invidious => Box::new(self.invidious_instance.as_ref().unwrap().clone()),
144 |             ApiBackend::Local => Box::new(self.local_api.clone()),
145 |         }
146 |     }
147 | 
148 |     async fn switch_api(&mut self) -> Result<()> {
149 |         self.selected_api = match self.selected_api {
150 |             ApiBackend::Local => ApiBackend::Invidious,
151 |             ApiBackend::Invidious => ApiBackend::Local,
152 |         };
153 | 
154 |         emit_msg!(format!("Selected API: {}", self.selected_api));
155 | 
156 |         if self.invidious_instance.is_none()
157 |             && let Err(e) = self.set_instance().await
158 |         {
159 |             self.selected_api = ApiBackend::Local;
160 |             emit_msg!(error, format!("{e} Falling back to the local API."));
161 |         }
162 | 
163 |         Ok(())
164 |     }
165 | 
166 |     pub async fn set_instance(&mut self) -> Result<()> {
167 |         if let Some(invidious_instances) = &self.invidious_instances {
168 |             if invidious_instances.is_empty() {
169 |                 return Err(anyhow::anyhow!("No Invidious instance available."));
170 |             }
171 | 
172 |             self.invidious_instance = Some(Instance::new(invidious_instances));
173 |         } else {
174 |             emit_msg!(perm, "Fetching instances");
175 | 
176 |             if let Ok(instances) = utils::fetch_invidious_instances().await {
177 |                 emit_msg!();
178 |                 self.invidious_instances = Some(instances);
179 |                 Box::pin(self.set_instance()).await?;
180 |             }
181 | 
182 |             return Err(anyhow::anyhow!("Failed to fetch instances"));
183 |         }
184 | 
185 |         Ok(())
186 |     }
187 | }
188 | 
189 | async fn subscribe_to_channel(mut instance: Box<dyn Api>, input: String) -> Result<()> {
190 |     let res = instance.resolve_channel_id(&input).await;
191 | 
192 |     let channel_id = match res {
193 |         Ok(id) => id,
194 |         Err(e) => {
195 |             emit_msg!(error, format!("Failed to subscribe: {e}"));
196 |             return Ok(());
197 |         }
198 |     };
199 | 
200 |     let (tx, rx) = oneshot::channel();
201 |     TX.send(ClientRequest::CheckChannel(channel_id.clone(), tx))?;
202 | 
203 |     if rx.await? {
204 |         emit_msg!(warning, "Already subscribed to the channel");
205 |         return Ok(());
206 |     }
207 | 
208 |     emit_msg!(perm, "Subscribing to channel");
209 | 
210 |     let channel_feed = instance.get_videos_for_the_first_time(&channel_id).await;
211 | 
212 |     match channel_feed {
213 |         Ok(channel_feed) => {
214 |             emit_msg!();
215 |             TX.send(ClientRequest::AddChannel(channel_feed))?;
216 |         }
217 |         Err(e) => emit_msg!(error, format!("Failed to subscribe: {e}")),
218 |     }
219 | 
220 |     Ok(())
221 | }
222 | 
223 | async fn import_channels(instance: Box<dyn Api>, channel_ids: Vec<String>) -> Result<()> {
224 |     let start = Instant::now();
225 |     let (mut count, total) = (0, channel_ids.len());
226 | 
227 |     emit_msg!(perm, format!("Subscribing to channels: {count}/{total}"));
228 | 
229 |     let streams = futures_util::stream::iter(channel_ids).map(|id| {
230 |         let id = id.clone();
231 |         let mut instance = dyn_clone::clone_box(&*instance);
232 | 
233 |         TX.send(ClientRequest::SetImportState(
234 |             id.clone(),
235 |             RefreshState::Refreshing,
236 |         ))
237 |         .unwrap();
238 | 
239 |         tokio::spawn(async move {
240 |             let feed = if total > OPTIONS.rss_threshold {
241 |                 instance.get_rss_feed_of_channel(&id)
242 |             } else {
243 |                 instance.get_videos_for_the_first_time(&id)
244 |             };
245 | 
246 |             (feed.await, id)
247 |         })
248 |     });
249 | 
250 |     let mut buffered = streams.buffer_unordered(num_cpus::get());
251 | 
252 |     while let Some(Ok((feed, id))) = buffered.next().await {
253 |         match feed {
254 |             Ok(feed) => {
255 |                 TX.send(ClientRequest::SetImportState(id, RefreshState::Completed))?;
256 |                 TX.send(ClientRequest::AddChannel(feed))?;
257 |                 emit_msg!(perm, format!("Subscribing to channels: {count}/{total}"));
258 |                 count += 1;
259 |             }
260 |             Err(_) => TX.send(ClientRequest::SetImportState(id, RefreshState::Failed))?,
261 |         }
262 |     }
263 | 
264 |     let elapsed = start.elapsed().as_secs_f64();
265 | 
266 |     match count {
267 |         0 => emit_msg!(error, "Failed to refresh channel"),
268 |         count => emit_msg!(format!(
269 |             "Subscribed to {count} out of {total} channels in {elapsed:.2}s"
270 |         )),
271 |     }
272 | 
273 |     TX.send(ClientRequest::FinalizeImport(count == total))?;
274 | 
275 |     Ok(())
276 | }
277 | 
278 | async fn refresh_channels(instance: Box<dyn Api>, channel_ids: Vec<String>) -> Result<()> {
279 |     let start = Instant::now();
280 |     let (mut count, total) = (0, channel_ids.len());
281 | 
282 |     if total == 1 {
283 |         emit_msg!(perm, "Refreshing channel");
284 |     } else {
285 |         emit_msg!(perm, format!("Refreshing channels: {count}/{total}"));
286 |     }
287 | 
288 |     let streams = futures_util::stream::iter(channel_ids).map(|id| {
289 |         let id = id.clone();
290 |         let mut instance = dyn_clone::clone_box(&*instance);
291 | 
292 |         TX.send(ClientRequest::SetRefreshState(
293 |             id.clone(),
294 |             RefreshState::Refreshing,
295 |         ))
296 |         .unwrap();
297 | 
298 |         tokio::spawn(async move {
299 |             let feed = if total > OPTIONS.rss_threshold {
300 |                 instance.get_rss_feed_of_channel(&id)
301 |             } else {
302 |                 instance.get_videos_of_channel(&id)
303 |             };
304 | 
305 |             (feed.await, id)
306 |         })
307 |     });
308 | 
309 |     let mut buffered = streams.buffer_unordered(num_cpus::get());
310 | 
311 |     while let Some(Ok((feed, id))) = buffered.next().await {
312 |         match feed {
313 |             Ok(feed) => {
314 |                 TX.send(ClientRequest::SetRefreshState(id, RefreshState::Completed))?;
315 |                 TX.send(ClientRequest::UpdateChannel(feed))?;
316 |                 emit_msg!(perm, format!("Refreshing channels: {count}/{total}"));
317 |                 count += 1;
318 |             }
319 |             Err(_) => TX.send(ClientRequest::SetRefreshState(id, RefreshState::Failed))?,
320 |         }
321 |     }
322 | 
323 |     let elapsed = start.elapsed().as_secs_f64();
324 | 
325 |     match (count, total) {
326 |         (0, 1) => emit_msg!(error, "Failed to refresh channel"),
327 |         (0, _) => emit_msg!(error, "Failed to refresh channels"),
328 |         (1, 1) => emit_msg!(format!("Refreshed channel in {elapsed:.2}s")),
329 |         (count, total) => emit_msg!(format!(
330 |             "Refreshed {count} out of {total} channels in {elapsed:.2}s"
331 |         )),
332 |     }
333 | 
334 |     Ok(())
335 | }
336 | 
337 | async fn get_more_videos(
338 |     mut instance: Box<dyn Api>,
339 |     id: &str,
340 |     tab: ChannelTab,
341 |     present: HashSet<String>,
342 | ) -> Result<()> {
343 |     match instance.get_more_videos(id, tab, present).await {
344 |         Ok(feed) => {
345 |             if feed.get_videos(tab).is_empty() {
346 |                 emit_msg!(warning, "There are no videos to load");
347 |             } else {
348 |                 emit_msg!();
349 |                 TX.send(ClientRequest::UpdateChannel(feed))?;
350 |             }
351 |         }
352 |         Err(e) => emit_msg!(error, &e.to_string()),
353 |     }
354 | 
355 |     Ok(())
356 | }
357 | 
358 | async fn fetch_formats(
359 |     instance: Box<dyn Api>,
360 |     title: String,
361 |     video_id: String,
362 |     play_selected: bool,
363 | ) -> Result<()> {
364 |     emit_msg!(perm, "Fetching formats");
365 |     let video_info = instance.get_video_formats(&video_id).await;
366 | 
367 |     let formats = match video_info {
368 |         Ok(video_info) => Formats::new(title, video_id, video_info),
369 |         Err(e) => {
370 |             emit_msg!(error, e.to_string());
371 |             return Ok(());
372 |         }
373 |     };
374 | 
375 |     if play_selected {
376 |         player::play_from_formats(instance, formats).await?;
377 |     } else {
378 |         emit_msg!();
379 |         TX.send(ClientRequest::EnterFormatSelection(Box::new(formats)))?;
380 |     }
381 | 
382 |     Ok(())
383 | }
384 | 
385 | async fn clear_message(token: CancellationToken, duration: u64) -> Result<()> {
386 |     tokio::select! {
387 |         () = token.cancelled() => {}
388 |         () = sleep(std::time::Duration::from_secs(duration)) => emit_msg!(),
389 | 
390 |     }
391 | 
392 |     Ok(())
393 | }
394 | 


--------------------------------------------------------------------------------
/src/config/keys.rs:
--------------------------------------------------------------------------------
  1 | use crate::commands::{
  2 |     ChannelSelectionCommand, Command, FormatSelectionCommand, HelpCommand, ImportCommand,
  3 |     TagCommand,
  4 | };
  5 | use anyhow::{Context, Result};
  6 | use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
  7 | use serde::Deserialize;
  8 | use std::collections::HashMap;
  9 | use std::ops::{Deref, DerefMut};
 10 | 
 11 | #[derive(Deserialize)]
 12 | pub struct UserKeyBindings {
 13 |     #[serde(flatten)]
 14 |     general: Option<HashMap<String, String>>,
 15 |     import: Option<HashMap<String, String>>,
 16 |     tag: Option<HashMap<String, String>>,
 17 |     channel_selection: Option<HashMap<String, String>>,
 18 |     format_selection: Option<HashMap<String, String>>,
 19 | }
 20 | 
 21 | fn parse_binding(binding: &str) -> Result<KeyEvent> {
 22 |     let mut tokens = binding.rsplit('-');
 23 | 
 24 |     let code = if let Some(token) = tokens.next() {
 25 |         match token {
 26 |             "backspace" => KeyCode::Backspace,
 27 |             "space" => KeyCode::Char(' '),
 28 |             "enter" => KeyCode::Enter,
 29 |             "left" => KeyCode::Left,
 30 |             "right" => KeyCode::Right,
 31 |             "up" => KeyCode::Up,
 32 |             "down" => KeyCode::Down,
 33 |             "home" => KeyCode::Home,
 34 |             "end" => KeyCode::End,
 35 |             "pageup" => KeyCode::PageUp,
 36 |             "pagedown" => KeyCode::PageDown,
 37 |             "tab" => KeyCode::Tab,
 38 |             "backtab" => KeyCode::BackTab,
 39 |             "del" | "delete" => KeyCode::Delete,
 40 |             "insert" => KeyCode::Insert,
 41 |             "esc" | "escape" => KeyCode::Esc,
 42 |             token if token.len() == 1 => KeyCode::Char(token.chars().next().unwrap()),
 43 |             _ => anyhow::bail!("\"{}\" is not a valid key", token),
 44 |         }
 45 |     } else {
 46 |         anyhow::bail!("\"{}\" is not a valid binding", binding)
 47 |     };
 48 | 
 49 |     let mut modifiers = KeyModifiers::NONE;
 50 | 
 51 |     for token in tokens {
 52 |         match token {
 53 |             "ctrl" => modifiers.insert(KeyModifiers::CONTROL),
 54 |             "shift" => modifiers.insert(KeyModifiers::SHIFT),
 55 |             "alt" => modifiers.insert(KeyModifiers::ALT),
 56 |             _ => anyhow::bail!("\"{}\" is not a valid modifier", token),
 57 |         }
 58 |     }
 59 | 
 60 |     Ok(KeyEvent::new(code, modifiers))
 61 | }
 62 | 
 63 | #[derive(PartialEq, Eq, Debug)]
 64 | pub struct KeyBindings {
 65 |     pub general: HashMap<KeyEvent, Command>,
 66 |     pub help: HashMap<KeyEvent, HelpCommand>,
 67 |     pub import: HashMap<KeyEvent, ImportCommand>,
 68 |     pub tag: HashMap<KeyEvent, TagCommand>,
 69 |     pub channel_selection: HashMap<KeyEvent, ChannelSelectionCommand>,
 70 |     pub format_selection: HashMap<KeyEvent, FormatSelectionCommand>,
 71 | }
 72 | 
 73 | impl Default for KeyBindings {
 74 |     #[rustfmt::skip]
 75 |     fn default() -> Self {
 76 |         let mut general = HashMap::new();
 77 |         let mut help = HashMap::new();
 78 |         let mut import = HashMap::new();
 79 |         let mut tag = HashMap::new();
 80 |         let mut channel_selection = HashMap::new();
 81 |         let mut format_selection = HashMap::new();
 82 | 
 83 |         macro_rules! insert_binding {
 84 |             ($map: expr, $key: expr, $command: expr) => {
 85 |                 $map.insert(parse_binding($key).unwrap(), $command);
 86 |             };
 87 |         }
 88 | 
 89 |         insert_binding!(general, "1", Command::SetModeSubs);
 90 |         insert_binding!(general, "2", Command::SetModeLatestVideos);
 91 |         insert_binding!(general, "j", Command::OnDown);
 92 |         insert_binding!(general, "down", Command::OnDown);
 93 |         insert_binding!(general, "k", Command::OnUp);
 94 |         insert_binding!(general, "up", Command::OnUp);
 95 |         insert_binding!(general, "h", Command::OnLeft);
 96 |         insert_binding!(general, "left", Command::OnLeft);
 97 |         insert_binding!(general, "l", Command::OnRight);
 98 |         insert_binding!(general, "right", Command::OnRight);
 99 |         insert_binding!(general, "g", Command::SelectFirst);
100 |         insert_binding!(general, "G", Command::SelectLast);
101 |         insert_binding!(general, "L", Command::NextTab);
102 |         insert_binding!(general, "H", Command::PreviousTab);
103 |         insert_binding!(general, "c", Command::JumpToChannel);
104 |         insert_binding!(general, "t", Command::ToggleHide);
105 |         insert_binding!(general, "i", Command::Subscribe);
106 |         insert_binding!(general, "d", Command::Unsubscribe);
107 |         insert_binding!(general, "D", Command::DeleteVideo);
108 |         insert_binding!(general, "/", Command::SearchForward);
109 |         insert_binding!(general, "?", Command::SearchBackward);
110 |         insert_binding!(general, "n", Command::RepeatLastSearch);
111 |         insert_binding!(general, "N", Command::RepeatLastSearchOpposite);
112 |         insert_binding!(general, "s", Command::SwitchApi);
113 |         insert_binding!(general, "r", Command::RefreshChannel);
114 |         insert_binding!(general, "R", Command::RefreshChannels);
115 |         insert_binding!(general, "F", Command::RefreshFailedChannels);
116 |         insert_binding!(general, "J", Command::LoadMoreVideos);
117 |         insert_binding!(general, "o", Command::OpenInYoutube);
118 |         insert_binding!(general, "O", Command::OpenInInvidious);
119 |         insert_binding!(general, "p", Command::PlayFromFormats);
120 |         insert_binding!(general, "P", Command::PlayUsingYtdlp);
121 |         insert_binding!(general, "f", Command::SelectFormats);
122 |         insert_binding!(general, "m", Command::ToggleWatched);
123 |         insert_binding!(general, "ctrl-h", Command::ToggleHelp);
124 |         insert_binding!(general, "T", Command::ToggleTag);
125 |         insert_binding!(general, "q", Command::Quit);
126 |         insert_binding!(general, "ctrl-c", Command::Quit);
127 | 
128 |         insert_binding!(tag, "space", TagCommand::ToggleSelection);
129 |         insert_binding!(tag, "a", TagCommand::SelectAll);
130 |         insert_binding!(tag, "z", TagCommand::DeselectAll);
131 |         insert_binding!(tag, "s", TagCommand::SelectChannels);
132 |         insert_binding!(tag, "i", TagCommand::CreateTag);
133 |         insert_binding!(tag, "d", TagCommand::DeleteTag);
134 |         insert_binding!(tag, "r", TagCommand::RenameTag);
135 |         insert_binding!(tag, "escape", TagCommand::Abort);
136 | 
137 |         insert_binding!(import, "space", ImportCommand::ToggleSelection);
138 |         insert_binding!(import, "a", ImportCommand::SelectAll);
139 |         insert_binding!(import, "z", ImportCommand::DeselectAll);
140 |         insert_binding!(import, "enter", ImportCommand::Import);
141 | 
142 |         insert_binding!(channel_selection, "enter", ChannelSelectionCommand::Confirm);
143 |         insert_binding!(channel_selection, "escape", ChannelSelectionCommand::Abort);
144 |         insert_binding!(channel_selection, "space", ChannelSelectionCommand::ToggleSelection);
145 |         insert_binding!(channel_selection, "a", ChannelSelectionCommand::SelectAll);
146 |         insert_binding!(channel_selection, "z", ChannelSelectionCommand::DeselectAll);
147 | 
148 |         insert_binding!(format_selection, "l", FormatSelectionCommand::NextTab);
149 |         insert_binding!(format_selection, "right", FormatSelectionCommand::NextTab);
150 |         insert_binding!(format_selection, "h", FormatSelectionCommand::PreviousTab);
151 |         insert_binding!(format_selection, "left", FormatSelectionCommand::PreviousTab);
152 |         insert_binding!(format_selection, "s", FormatSelectionCommand::SwitchFormatType);
153 |         insert_binding!(format_selection, "space", FormatSelectionCommand::Select);
154 |         insert_binding!(format_selection, "enter", FormatSelectionCommand::PlayVideo);
155 |         insert_binding!(format_selection, "escape", FormatSelectionCommand::Abort);
156 | 
157 |         insert_binding!(help, "ctrl-y", HelpCommand::ScrollUp);
158 |         insert_binding!(help, "ctrl-e", HelpCommand::ScrollDown);
159 |         insert_binding!(help, "g", HelpCommand::GoToTop);
160 |         insert_binding!(help, "G", HelpCommand::GoToBottom);
161 |         insert_binding!(help, "esc", HelpCommand::Abort);
162 | 
163 |         Self {
164 |             general,
165 |             help,
166 |             import,
167 |             tag,
168 |             channel_selection,
169 |             format_selection
170 |         }
171 |     }
172 | }
173 | 
174 | fn set_bindings<'a, T, E>(
175 |     key_bindings: &mut HashMap<KeyEvent, T>,
176 |     user_key_bindings: &'a HashMap<String, String>,
177 | ) -> Result<(), anyhow::Error>
178 | where
179 |     T: TryFrom<&'a str, Error = E>,
180 |     E: Into<anyhow::Error>,
181 | {
182 |     for (bindings, command) in user_key_bindings {
183 |         for binding in bindings.split_whitespace() {
184 |             let binding = parse_binding(binding)
185 |                 .with_context(|| format!("Error: failed to parse binding \"{binding}\""))?;
186 |             if command.is_empty() {
187 |                 key_bindings.remove(&binding);
188 |             } else {
189 |                 key_bindings.insert(
190 |                     binding,
191 |                     T::try_from(command.as_str())
192 |                         .map_err(|e| anyhow::anyhow!(e))
193 |                         .with_context(|| format!("Error: failed to parse command \"{command}\""))?,
194 |                 );
195 |             }
196 |         }
197 |     }
198 | 
199 |     Ok(())
200 | }
201 | 
202 | impl TryFrom<UserKeyBindings> for KeyBindings {
203 |     type Error = anyhow::Error;
204 | 
205 |     fn try_from(user_key_bindings: UserKeyBindings) -> Result<Self, Self::Error> {
206 |         let mut key_bindings = KeyBindings::default();
207 | 
208 |         if let Some(bindings) = user_key_bindings.general {
209 |             set_bindings(&mut key_bindings, &bindings)?;
210 |         }
211 | 
212 |         if let Some(bindings) = user_key_bindings.import {
213 |             set_bindings(&mut key_bindings.import, &bindings)?;
214 |         }
215 | 
216 |         if let Some(bindings) = user_key_bindings.tag {
217 |             set_bindings(&mut key_bindings.tag, &bindings)?;
218 |         }
219 | 
220 |         if let Some(bindings) = user_key_bindings.channel_selection {
221 |             set_bindings(&mut key_bindings.channel_selection, &bindings)?;
222 |         }
223 | 
224 |         if let Some(bindings) = user_key_bindings.format_selection {
225 |             set_bindings(&mut key_bindings.format_selection, &bindings)?;
226 |         }
227 | 
228 |         Ok(key_bindings)
229 |     }
230 | }
231 | 
232 | impl Deref for KeyBindings {
233 |     type Target = HashMap<KeyEvent, Command>;
234 | 
235 |     fn deref(&self) -> &Self::Target {
236 |         &self.general
237 |     }
238 | }
239 | 
240 | impl DerefMut for KeyBindings {
241 |     fn deref_mut(&mut self) -> &mut Self::Target {
242 |         &mut self.general
243 |     }
244 | }
245 | 
246 | #[cfg(test)]
247 | mod tests {
248 |     use super::{KeyBindings, UserKeyBindings, parse_binding};
249 |     use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
250 | 
251 |     #[test]
252 |     fn valid_bindings() {
253 |         assert_eq!(
254 |             parse_binding("s").unwrap(),
255 |             KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE)
256 |         );
257 |         assert_eq!(
258 |             parse_binding("up").unwrap(),
259 |             KeyEvent::new(KeyCode::Up, KeyModifiers::NONE)
260 |         );
261 |         assert_eq!(
262 |             parse_binding("ctrl-s").unwrap(),
263 |             KeyEvent::new(KeyCode::Char('s'), KeyModifiers::CONTROL)
264 |         );
265 |         assert_eq!(
266 |             parse_binding("shift-ctrl-s").unwrap(),
267 |             KeyEvent::new(
268 |                 KeyCode::Char('s'),
269 |                 KeyModifiers::CONTROL | KeyModifiers::SHIFT
270 |             )
271 |         );
272 |         assert_eq!(
273 |             parse_binding("shift-alt-left").unwrap(),
274 |             KeyEvent::new(KeyCode::Left, KeyModifiers::SHIFT | KeyModifiers::ALT)
275 |         );
276 |     }
277 | 
278 |     #[test]
279 |     #[should_panic]
280 |     fn no_key_code() {
281 |         parse_binding("ctrl-shift").unwrap();
282 |     }
283 | 
284 |     #[test]
285 |     #[should_panic]
286 |     fn multiple_key_codes() {
287 |         parse_binding("esc-s").unwrap();
288 |     }
289 | 
290 |     #[test]
291 |     #[should_panic]
292 |     fn invalid_token() {
293 |         parse_binding("rust").unwrap();
294 |     }
295 | 
296 |     #[test]
297 |     fn configure_bindings() {
298 |         use crate::commands::Command;
299 |         use std::collections::HashMap;
300 | 
301 |         let mut user_key_bindings = UserKeyBindings {
302 |             general: Some(HashMap::new()),
303 |             import: None,
304 |             tag: None,
305 |             channel_selection: None,
306 |             format_selection: None,
307 |         };
308 | 
309 |         let general_bindings = user_key_bindings.general.as_mut().unwrap();
310 | 
311 |         general_bindings.insert("l right".to_string(), "on_left".to_string());
312 | 
313 |         general_bindings.insert("esc".to_string(), "quit".to_string());
314 | 
315 |         let key_bindings = KeyBindings::try_from(user_key_bindings).unwrap();
316 | 
317 |         assert_eq!(
318 |             *key_bindings
319 |                 .general
320 |                 .get(&KeyEvent::new(KeyCode::Char('l'), KeyModifiers::NONE))
321 |                 .unwrap(),
322 |             Command::OnLeft,
323 |         );
324 |         assert_eq!(
325 |             *key_bindings
326 |                 .general
327 |                 .get(&KeyEvent::new(KeyCode::Right, KeyModifiers::NONE))
328 |                 .unwrap(),
329 |             Command::OnLeft
330 |         );
331 |         assert_eq!(
332 |             *key_bindings
333 |                 .general
334 |                 .get(&KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE))
335 |                 .unwrap(),
336 |             Command::Quit
337 |         );
338 |     }
339 | 
340 |     #[test]
341 |     fn remove_binding() {
342 |         use std::collections::HashMap;
343 | 
344 |         let mut user_key_bindings = UserKeyBindings {
345 |             general: Some(HashMap::new()),
346 |             import: None,
347 |             tag: None,
348 |             channel_selection: None,
349 |             format_selection: None,
350 |         };
351 | 
352 |         user_key_bindings
353 |             .general
354 |             .as_mut()
355 |             .unwrap()
356 |             .insert("q".to_string(), String::new());
357 | 
358 |         let key_bindings = KeyBindings::try_from(user_key_bindings).unwrap();
359 | 
360 |         assert!(
361 |             !key_bindings
362 |                 .general
363 |                 .contains_key(&KeyEvent::new(KeyCode::Char('q'), KeyModifiers::NONE))
364 |         );
365 |     }
366 | }
367 | 


--------------------------------------------------------------------------------
/src/api/mod.rs:
--------------------------------------------------------------------------------
  1 | pub mod invidious;
  2 | pub mod local;
  3 | 
  4 | use crate::{
  5 |     OPTIONS,
  6 |     channel::{ChannelTab, ListItem, Video},
  7 |     protobuf::decode_protobuf,
  8 |     stream_formats::Formats,
  9 |     utils,
 10 | };
 11 | use anyhow::Result;
 12 | use async_trait::async_trait;
 13 | use dyn_clone::DynClone;
 14 | use regex_lite::Regex;
 15 | use serde::Deserialize;
 16 | use serde_json::Value;
 17 | use std::{collections::HashSet, fmt::Display, io::Write, path::PathBuf, sync::LazyLock};
 18 | 
 19 | #[derive(Default, Deserialize)]
 20 | pub struct ChannelFeed {
 21 |     #[serde(rename = "title")]
 22 |     pub channel_title: Option<String>,
 23 |     #[serde(rename = "channelId")]
 24 |     pub channel_id: Option<String>,
 25 |     #[serde(rename = "entry")]
 26 |     pub videos: Vec<Video>,
 27 |     pub live_streams: Vec<Video>,
 28 |     pub shorts: Vec<Video>,
 29 | }
 30 | 
 31 | impl ChannelFeed {
 32 |     pub fn new(channel_id: &str) -> Self {
 33 |         Self {
 34 |             channel_id: Some(channel_id.to_owned()),
 35 |             ..Self::default()
 36 |         }
 37 |     }
 38 | 
 39 |     pub fn channel_title(mut self, channel_title: Option<String>) -> Self {
 40 |         self.channel_title = channel_title;
 41 |         self
 42 |     }
 43 | 
 44 |     pub fn videos(mut self, videos: Vec<Video>) -> Self {
 45 |         self.videos = videos;
 46 |         self
 47 |     }
 48 | 
 49 |     pub fn get_videos(&self, tab: ChannelTab) -> &[Video] {
 50 |         match tab {
 51 |             ChannelTab::Videos => &self.videos,
 52 |             ChannelTab::Shorts => &self.shorts,
 53 |             ChannelTab::Streams => &self.live_streams,
 54 |         }
 55 |     }
 56 | 
 57 |     pub fn get_mut_videos(&mut self, tab: ChannelTab) -> &mut Vec<Video> {
 58 |         match tab {
 59 |             ChannelTab::Videos => &mut self.videos,
 60 |             ChannelTab::Shorts => &mut self.shorts,
 61 |             ChannelTab::Streams => &mut self.live_streams,
 62 |         }
 63 |     }
 64 | 
 65 |     pub fn extend_videos(&mut self, videos: Vec<Video>, tab: ChannelTab) {
 66 |         let Some(published_of_first) = videos.first().map(|video| video.published_text.clone())
 67 |         else {
 68 |             return;
 69 |         };
 70 | 
 71 |         let present_videos = self.get_mut_videos(tab);
 72 |         present_videos.extend(videos);
 73 | 
 74 |         present_videos
 75 |             .iter_mut()
 76 |             .filter(|video| video.published_text == published_of_first)
 77 |             .for_each(|video| {
 78 |                 if let Ok(published) = utils::published(&video.published_text) {
 79 |                     video.published = published;
 80 |                 }
 81 |             });
 82 |     }
 83 | }
 84 | 
 85 | pub struct VideoInfo {
 86 |     pub video_formats: Vec<Format>,
 87 |     pub audio_formats: Vec<Format>,
 88 |     pub format_streams: Vec<Format>,
 89 |     pub captions: Vec<Format>,
 90 |     pub chapters: Option<Chapters>,
 91 | }
 92 | 
 93 | impl VideoInfo {
 94 |     pub fn new(
 95 |         video_formats: Vec<Format>,
 96 |         mut audio_formats: Vec<Format>,
 97 |         format_streams: Vec<Format>,
 98 |         captions: Vec<Format>,
 99 |         chapters: Option<Chapters>,
100 |     ) -> Self {
101 |         audio_formats.reverse();
102 | 
103 |         Self {
104 |             video_formats,
105 |             audio_formats,
106 |             format_streams,
107 |             captions,
108 |             chapters,
109 |         }
110 |     }
111 | }
112 | 
113 | fn extract_track_type(format: &Value) -> Option<String> {
114 |     format
115 |         .get("xtags")
116 |         .and_then(Value::as_str)
117 |         .and_then(decode_protobuf)
118 |         .and_then(|v| v["1"][0]["2"].as_str().map(ToOwned::to_owned))
119 | }
120 | 
121 | pub enum Format {
122 |     Video {
123 |         url: String,
124 |         quality: String,
125 |         fps: u64,
126 |         r#type: String,
127 |     },
128 |     Audio {
129 |         url: String,
130 |         bitrate: String,
131 |         language: Option<(String, bool)>,
132 |         r#type: String,
133 |     },
134 |     Stream {
135 |         url: String,
136 |         quality: String,
137 |         fps: u64,
138 |         bitrate: Option<String>,
139 |         r#type: String,
140 |     },
141 |     Caption {
142 |         url: String,
143 |         label: String,
144 |         language_code: String,
145 |     },
146 | }
147 | 
148 | impl Format {
149 |     pub fn from_video(format_json: &Value, api_backend: ApiBackend) -> Self {
150 |         let mime_type = match api_backend {
151 |             ApiBackend::Local => &format_json["mimeType"],
152 |             ApiBackend::Invidious => &format_json["type"],
153 |         };
154 | 
155 |         Format::Video {
156 |             url: format_json["url"].as_str().unwrap().to_string(),
157 |             quality: format_json["qualityLabel"].as_str().unwrap().to_string(),
158 |             fps: format_json["fps"].as_u64().unwrap(),
159 |             r#type: mime_type.as_str().unwrap().to_string(),
160 |         }
161 |     }
162 | 
163 |     pub fn from_audio(format_json: &Value, api_backend: ApiBackend) -> Self {
164 |         let url = format_json["url"].as_str().unwrap().to_string();
165 |         let mime_type;
166 |         let bitrate;
167 |         let language;
168 | 
169 |         match api_backend {
170 |             ApiBackend::Local => {
171 |                 mime_type = &format_json["mimeType"];
172 |                 bitrate = format_json["bitrate"].as_u64().unwrap().to_string();
173 |                 language = format_json.get("audioTrack").map(|audio_track| {
174 |                     (
175 |                         audio_track["displayName"].as_str().unwrap().to_string(),
176 |                         OPTIONS
177 |                             .prefer_original_audio
178 |                             .then(|| extract_track_type(format_json).map(|s| s == "original"))
179 |                             .flatten()
180 |                             .or(audio_track["audioIsDefault"].as_bool())
181 |                             .unwrap_or_default(),
182 |                     )
183 |                 });
184 |             }
185 |             ApiBackend::Invidious => {
186 |                 mime_type = &format_json["type"];
187 |                 bitrate = format_json["bitrate"].as_str().unwrap().to_string();
188 |                 let mut default = None;
189 |                 let mut lang = None;
190 | 
191 |                 if let Some(param) = utils::params_from_url(&url)
192 |                     .ok()
193 |                     .as_mut()
194 |                     .and_then(|params| params.remove("xtags"))
195 |                 {
196 |                     param
197 |                         .split(':')
198 |                         .filter_map(|param| param.split_once('='))
199 |                         .for_each(|(key, value)| match key {
200 |                             "acont" => default = Some(value == "original"),
201 |                             "lang" => lang = Some(value.to_owned()),
202 |                             _ => {}
203 |                         });
204 |                 };
205 | 
206 |                 language = lang.zip(default);
207 |             }
208 |         }
209 | 
210 |         Format::Audio {
211 |             url,
212 |             bitrate,
213 |             r#type: mime_type.as_str().unwrap().to_string(),
214 |             language,
215 |         }
216 |     }
217 | 
218 |     pub fn from_stream(format_json: &Value, api_backend: ApiBackend) -> Self {
219 |         let (mime_type, bitrate) = match api_backend {
220 |             ApiBackend::Local => (
221 |                 &format_json["mimeType"],
222 |                 Some(format_json["audioSampleRate"].as_str().unwrap().to_string()),
223 |             ),
224 |             ApiBackend::Invidious => (&format_json["type"], None),
225 |         };
226 | 
227 |         Format::Stream {
228 |             url: format_json["url"].as_str().unwrap().to_string(),
229 |             quality: format_json["qualityLabel"].as_str().unwrap().to_string(),
230 |             fps: format_json["fps"].as_u64().unwrap(),
231 |             bitrate,
232 |             r#type: mime_type.as_str().unwrap().to_string(),
233 |         }
234 |     }
235 | 
236 |     pub fn from_caption(format_json: &Value, api_backend: ApiBackend) -> Option<Self> {
237 |         let caption = match api_backend {
238 |             ApiBackend::Local => Format::Caption {
239 |                 url: format_json["baseUrl"].as_str().unwrap().to_string(),
240 |                 label: format_json["name"]["runs"][0]["text"]
241 |                     .as_str()
242 |                     .unwrap()
243 |                     .to_string(),
244 |                 language_code: format_json["languageCode"].as_str().unwrap().to_string(),
245 |             },
246 |             ApiBackend::Invidious => Format::Caption {
247 |                 url: format_json["url"].as_str().unwrap().to_string(),
248 |                 label: format_json["label"].as_str().unwrap().to_string(),
249 |                 language_code: format_json["language_code"].as_str().unwrap().to_string(),
250 |             },
251 |         };
252 | 
253 |         if matches!(&caption, Format::Caption { label, .. } if label.contains("auto-generated")) {
254 |             return None;
255 |         }
256 | 
257 |         Some(caption)
258 |     }
259 | 
260 |     pub fn get_url(&self) -> &str {
261 |         match self {
262 |             Format::Video { url, .. }
263 |             | Format::Audio { url, .. }
264 |             | Format::Stream { url, .. }
265 |             | Format::Caption { url, .. } => url,
266 |         }
267 |     }
268 | 
269 |     pub fn get_quality(&self) -> u16 {
270 |         if let Format::Video { quality, .. } = self {
271 |             quality
272 |                 .split_once('p')
273 |                 .and_then(|(quality, _)| quality.parse().ok())
274 |                 .unwrap_or_default()
275 |         } else {
276 |             panic!()
277 |         }
278 |     }
279 | 
280 |     pub fn get_codec(&self) -> VideoFormat {
281 |         static RE: LazyLock<Regex> =
282 |             LazyLock::new(|| Regex::new(r"(video|audio)\/(?<codec>webm|mp4);").unwrap());
283 | 
284 |         let (Format::Video { r#type, .. }
285 |         | Format::Audio { r#type, .. }
286 |         | Format::Stream { r#type, .. }) = self
287 |         else {
288 |             unreachable!()
289 |         };
290 | 
291 |         let Some(captures) = RE.captures(r#type) else {
292 |             return VideoFormat::Mp4;
293 |         };
294 | 
295 |         match &captures["codec"] {
296 |             "mp4" => VideoFormat::Mp4,
297 |             "webm" => VideoFormat::WebM,
298 |             _ => unreachable!(),
299 |         }
300 |     }
301 | }
302 | 
303 | #[derive(Deserialize, Eq, PartialEq)]
304 | #[serde(rename_all(deserialize = "lowercase"))]
305 | pub enum VideoFormat {
306 |     WebM,
307 |     Mp4,
308 | }
309 | 
310 | impl Display for VideoFormat {
311 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
312 |         write!(
313 |             f,
314 |             "{}",
315 |             match self {
316 |                 VideoFormat::Mp4 => "mp4",
317 |                 VideoFormat::WebM => "webm",
318 |             }
319 |         )
320 |     }
321 | }
322 | 
323 | impl ListItem for Format {
324 |     fn id(&self) -> &str {
325 |         match self {
326 |             Format::Video { url, .. } | Format::Audio { url, .. } | Format::Stream { url, .. } => {
327 |                 url
328 |             }
329 |             Format::Caption { language_code, .. } => language_code,
330 |         }
331 |     }
332 | }
333 | 
334 | #[derive(Default)]
335 | pub struct Chapters {
336 |     inner: Vec<Chapter>,
337 | }
338 | 
339 | impl Chapters {
340 |     pub fn write_to_file(&self, video_id: &str) -> Result<PathBuf> {
341 |         let path = utils::get_cache_dir()?.join(format!("{video_id}.ffmetadata"));
342 | 
343 |         if let Ok(true) = path.try_exists() {
344 |             return Ok(path);
345 |         }
346 | 
347 |         let mut file = std::fs::File::create(&path)?;
348 | 
349 |         writeln!(file, ";FFMETADATA1")?;
350 | 
351 |         for chapter in &self.inner {
352 |             writeln!(file, "[CHAPTER]")?;
353 |             writeln!(file, "TIMEBASE=1/1")?;
354 |             writeln!(file, "START={}", chapter.start)?;
355 |             writeln!(file, "END={}", chapter.end)?;
356 |             writeln!(file, "TITLE={}", chapter.title)?;
357 |         }
358 | 
359 |         Ok(path)
360 |     }
361 | }
362 | 
363 | impl TryFrom<Option<&str>> for Chapters {
364 |     type Error = anyhow::Error;
365 | 
366 |     fn try_from(value: Option<&str>) -> std::result::Result<Self, Self::Error> {
367 |         let Some(description) = value else {
368 |             return Err(anyhow::anyhow!("There is no description"));
369 |         };
370 | 
371 |         let mut chapters = description
372 |             .lines()
373 |             .filter_map(|line| Chapter::try_from(line).ok())
374 |             .collect::<Vec<_>>();
375 | 
376 |         let len = chapters.len();
377 | 
378 |         if len == 0 {
379 |             return Err(anyhow::anyhow!("No chapters available in the description"));
380 |         } else if len > 1 {
381 |             // This doesn't set `end` for the last chapter. It should be fine since `end` doesn't
382 |             // seem to be necessary to have functioning chapters in mpv.
383 |             for idx in 1..chapters.len() {
384 |                 chapters[idx - 1].end = chapters[idx].start;
385 |             }
386 |         }
387 | 
388 |         Ok(Chapters { inner: chapters })
389 |     }
390 | }
391 | 
392 | // Can also use /next for this
393 | pub struct Chapter {
394 |     title: String,
395 |     start: u64,
396 |     end: u64,
397 | }
398 | 
399 | impl TryFrom<&str> for Chapter {
400 |     type Error = anyhow::Error;
401 | 
402 |     fn try_from(value: &str) -> std::result::Result<Self, Self::Error> {
403 |         static RE: LazyLock<Regex> = LazyLock::new(|| {
404 |             Regex::new(r"^((?<hours>\d+):)?(?<minutes>\d+):(?<seconds>\d+)(\s*[–—-]\s*(?:\d+:){1,2}\d+)?\s+([–—•-]\s*)?(?<title>.+)$").unwrap()
405 |         });
406 | 
407 |         if let Some(captures) = RE.captures(value) {
408 |             let hours = captures
409 |                 .name("hours")
410 |                 .map_or(0, |num| num.as_str().parse().unwrap());
411 |             let minutes = captures["minutes"].parse::<u64>()?;
412 |             let seconds = captures["seconds"].parse::<u64>()?;
413 | 
414 |             let timestamp = hours * 3600 + minutes * 60 + seconds;
415 | 
416 |             Ok(Chapter {
417 |                 title: captures["title"].to_owned(),
418 |                 start: timestamp,
419 |                 end: timestamp,
420 |             })
421 |         } else {
422 |             Err(anyhow::anyhow!("No pattern match"))
423 |         }
424 |     }
425 | }
426 | 
427 | #[derive(Deserialize, Copy, Clone)]
428 | #[serde(rename_all(deserialize = "lowercase"))]
429 | pub enum ApiBackend {
430 |     Local,
431 |     Invidious,
432 | }
433 | 
434 | impl Display for ApiBackend {
435 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
436 |         write!(
437 |             f,
438 |             "{}",
439 |             match self {
440 |                 ApiBackend::Invidious => "Invidious",
441 |                 ApiBackend::Local => "Local",
442 |             }
443 |         )
444 |     }
445 | }
446 | 
447 | #[async_trait]
448 | pub trait Api: Sync + Send + DynClone {
449 |     async fn resolve_channel_id(&self, input: &str) -> Result<String> {
450 |         if let Some((rest, channel_id)) = input.rsplit_once('/') {
451 |             if let Some((_, path)) = rest.rsplit_once('/')
452 |                 && path == "channel"
453 |             {
454 |                 return Ok(channel_id.to_owned());
455 |             }
456 |             self.resolve_url(input).await
457 |         } else if input.starts_with('@') {
458 |             self.resolve_url(&format!("youtube.com/{input}")).await
459 |         } else {
460 |             Ok(input.to_owned())
461 |         }
462 |     }
463 |     async fn resolve_url(&self, channel_url: &str) -> Result<String>;
464 |     async fn get_videos_for_the_first_time(&mut self, channel_id: &str) -> Result<ChannelFeed>;
465 |     async fn get_videos_of_channel(&mut self, channel_id: &str) -> Result<ChannelFeed>;
466 |     async fn get_rss_feed_of_channel(&self, channel_id: &str) -> Result<ChannelFeed>;
467 |     async fn get_more_videos(
468 |         &mut self,
469 |         channel_id: &str,
470 |         tab: ChannelTab,
471 |         present_videos: HashSet<String>,
472 |     ) -> Result<ChannelFeed>;
473 |     async fn get_video_formats(&self, video_id: &str) -> Result<VideoInfo>;
474 |     async fn get_caption_paths(&self, formats: &Formats) -> Vec<String>;
475 | }
476 | 


--------------------------------------------------------------------------------
/src/database.rs:
--------------------------------------------------------------------------------
  1 | use crate::{
  2 |     channel::{Channel, ChannelTab, Video},
  3 |     utils,
  4 | };
  5 | use anyhow::Result;
  6 | use rusqlite::{Connection, params};
  7 | use std::ops::RangeInclusive;
  8 | 
  9 | const LATEST_USER_VERSION: u8 = 3;
 10 | 
 11 | pub fn initialize_db(conn: &mut Connection) -> Result<()> {
 12 |     conn.pragma_update(None, "foreign_keys", "on")?;
 13 | 
 14 |     let current_user_version =
 15 |         conn.pragma_query_value(None, "user_version", |value| value.get(0))?;
 16 | 
 17 |     for i in current_user_version..LATEST_USER_VERSION {
 18 |         apply_migration(conn, i)?;
 19 |     }
 20 | 
 21 |     Ok(())
 22 | }
 23 | 
 24 | fn apply_migration(conn: &mut Connection, current_user_version: u8) -> Result<()> {
 25 |     match current_user_version {
 26 |         0 => {
 27 |             conn.execute(
 28 |                 "
 29 |                 CREATE TABLE IF NOT EXISTS channels (
 30 |                     channel_id TEXT PRIMARY KEY,
 31 |                     channel_name TEXT
 32 |                     )
 33 |                 ",
 34 |                 [],
 35 |             )?;
 36 | 
 37 |             conn.execute(
 38 |                 "
 39 |                 CREATE TABLE IF NOT EXISTS videos (
 40 |                     video_id TEXT PRIMARY KEY,
 41 |                     channel_id TEXT,
 42 |                     title TEXT,
 43 |                     published INTEGER,
 44 |                     length INTEGER,
 45 |                     watched BOOL,
 46 |                     FOREIGN KEY(channel_id) REFERENCES channels(channel_id) ON DELETE CASCADE
 47 |                     )
 48 |                 ",
 49 |                 [],
 50 |             )?;
 51 | 
 52 |             conn.execute(
 53 |                 "
 54 |                 CREATE TABLE IF NOT EXISTS tags (
 55 |                     tag_name TEXT PRIMARY KEY
 56 |                     )
 57 |                 ",
 58 |                 [],
 59 |             )?;
 60 | 
 61 |             conn.execute(
 62 |                 "
 63 |                 CREATE TABLE IF NOT EXISTS tag_relations (
 64 |                     tag_name TEXT,
 65 |                     channel_id TEXT,
 66 |                     PRIMARY KEY(tag_name, channel_id),
 67 |                     FOREIGN KEY(channel_id) REFERENCES channels(channel_id) ON DELETE CASCADE,
 68 |                     FOREIGN KEY(tag_name) REFERENCES tags(tag_name) ON DELETE CASCADE ON UPDATE CASCADE
 69 |                     )
 70 |                 ",
 71 |                 [],
 72 |             )?;
 73 | 
 74 |             conn.pragma_update(None, "user_version", 1)?;
 75 |         }
 76 |         1 => {
 77 |             conn.execute("ALTER TABLE channels ADD COLUMN last_refreshed INTEGER", [])?;
 78 |             conn.pragma_update(None, "user_version", 2)?;
 79 |         }
 80 |         2 => {
 81 |             let tx = conn.transaction()?;
 82 | 
 83 |             tx.execute("ALTER TABLE videos ADD COLUMN tab INTEGER DEFAULT 0", [])?;
 84 |             tx.execute("ALTER TABLE videos ADD COLUMN members_only BOOL", [])?;
 85 | 
 86 |             {
 87 |                 let mut stmt = tx.prepare("SELECT video_id FROM videos WHERE watched=true")?;
 88 | 
 89 |                 let watched_videos = stmt
 90 |                     .query_map([], |row| row.get::<usize, String>(0))?
 91 |                     .filter_map(Result::ok)
 92 |                     .collect::<Vec<_>>();
 93 | 
 94 |                 tx.execute(
 95 |                     "CREATE TABLE IF NOT EXISTS watched (video_id TEXT PRIMARY KEY)",
 96 |                     [],
 97 |                 )?;
 98 | 
 99 |                 if !watched_videos.is_empty() {
100 |                     let query = build_bulk_stmt(
101 |                         StatementType::AddWatched,
102 |                         &["video_id"],
103 |                         1..=watched_videos.len(),
104 |                     );
105 |                     tx.execute(&query, rusqlite::params_from_iter(watched_videos.iter()))?;
106 |                 }
107 | 
108 |                 tx.execute("ALTER TABLE videos DROP COLUMN watched", [])?;
109 |             }
110 | 
111 |             tx.pragma_update(None, "user_version", 3)?;
112 | 
113 |             tx.commit()?;
114 |         }
115 |         _ => unreachable!(),
116 |     }
117 | 
118 |     Ok(())
119 | }
120 | 
121 | pub fn create_channel(conn: &Connection, channel: &Channel) -> Result<()> {
122 |     conn.execute(
123 |         "INSERT INTO channels (channel_id, channel_name, last_refreshed)
124 |         VALUES (?1, ?2, ?3)",
125 |         params![channel.channel_id, channel.channel_name, utils::now().ok()],
126 |     )?;
127 | 
128 |     Ok(())
129 | }
130 | 
131 | pub fn delete_channel(conn: &Connection, channel_id: &str) -> Result<()> {
132 |     if let Err(e) = conn.execute(
133 |         "DELETE FROM channels WHERE channel_id=?1",
134 |         params![channel_id],
135 |     ) {
136 |         match e {
137 |             rusqlite::Error::SqliteFailure(
138 |                 rusqlite::ffi::Error {
139 |                     code: rusqlite::ErrorCode::ConstraintViolation,
140 |                     ..
141 |                 },
142 |                 _,
143 |             ) => {
144 |                 // if the table was created without the "ON DELETE CASCADE" option, delete the
145 |                 // videos manually
146 |                 conn.execute(
147 |                     "DELETE FROM videos WHERE channel_id=?1",
148 |                     params![channel_id],
149 |                 )?;
150 |                 conn.execute(
151 |                     "DELETE FROM channels WHERE channel_id=?1",
152 |                     params![channel_id],
153 |                 )?;
154 |             }
155 |             _ => return Err(anyhow::anyhow!(e)),
156 |         }
157 |     }
158 | 
159 |     Ok(())
160 | }
161 | 
162 | pub fn set_last_refreshed_field(
163 |     conn: &Connection,
164 |     channel_id: &str,
165 |     time: Option<u64>,
166 | ) -> Result<()> {
167 |     let mut stmt = conn.prepare("UPDATE channels SET last_refreshed=?1 WHERE channel_id=?2")?;
168 |     stmt.execute(params![time, channel_id])?;
169 |     Ok(())
170 | }
171 | 
172 | #[derive(Copy, Clone)]
173 | enum StatementType {
174 |     AddVideo,
175 |     AddToTag,
176 |     RemoveFromTag,
177 |     GetChannels,
178 |     GetLatestVideos,
179 |     AddWatched,
180 | }
181 | 
182 | fn build_bulk_stmt(
183 |     query_type: StatementType,
184 |     columns: &[&str],
185 |     indices: RangeInclusive<usize>,
186 | ) -> String {
187 |     let columns_str = columns.join(", ");
188 |     let idxs = indices.collect::<Vec<_>>();
189 |     let values_string = idxs
190 |         .chunks(columns.len())
191 |         .map(|chunk| {
192 |             format!(
193 |                 "({})",
194 |                 chunk
195 |                     .iter()
196 |                     .map(|i| format!("?{i}"))
197 |                     .collect::<Vec<_>>()
198 |                     .join(", ")
199 |             )
200 |         })
201 |         .collect::<Vec<_>>()
202 |         .join(", ");
203 | 
204 |     match query_type {
205 |         StatementType::AddVideo => format!(
206 |             "INSERT OR REPLACE INTO videos ({columns_str})
207 |             VALUES {values_string}
208 |             "
209 |         ),
210 |         StatementType::AddToTag => format!(
211 |             "INSERT INTO tag_relations ({columns_str})
212 |             VALUES {values_string}"
213 |         ),
214 |         StatementType::RemoveFromTag => format!(
215 |             "DELETE FROM tag_relations WHERE ({columns_str}) IN ({values_string})"
216 |         ),
217 |         StatementType::GetChannels => format!(
218 |             "SELECT DISTINCT channels.channel_id, channel_name, last_refreshed
219 |             FROM channels, tag_relations
220 |             WHERE tag_relations.channel_id=channels.channel_id AND tag_relations.tag_name IN ({values_string})
221 |             ORDER BY channel_name COLLATE NOCASE ASC
222 |             "
223 |         ),
224 |         StatementType::GetLatestVideos => format!(
225 |             "SELECT DISTINCT video_id, title, published, length, members_only, channel_name,
226 |             EXISTS (SELECT * FROM watched WHERE watched.video_id=videos.video_id)
227 |             FROM videos, channels, tag_relations
228 |             WHERE videos.channel_id = channels.channel_id AND tag_relations.tag_name IN ({values_string}) AND tab=?1
229 |             AND tag_relations.channel_id=channels.channel_id
230 |             ORDER BY published DESC
231 |             LIMIT 100
232 |             "
233 |         ),
234 |         StatementType::AddWatched => format!(
235 |             "INSERT INTO watched ({columns_str})
236 |             VALUES {values_string}
237 |             "
238 |         )
239 |     }
240 | }
241 | 
242 | pub fn add_videos(
243 |     conn: &Connection,
244 |     channel_id: &str,
245 |     videos: &[Video],
246 |     tab: ChannelTab,
247 | ) -> Result<()> {
248 |     let columns = [
249 |         "video_id",
250 |         "channel_id",
251 |         "title",
252 |         "published",
253 |         "length",
254 |         "members_only",
255 |         "tab",
256 |     ];
257 | 
258 |     let mut videos_values = Vec::with_capacity(videos.len() * columns.len());
259 |     let tab = tab as u8;
260 | 
261 |     for video in videos {
262 |         let values = params![
263 |             video.video_id,
264 |             channel_id,
265 |             video.title,
266 |             video.published,
267 |             video.length,
268 |             video.members_only,
269 |             tab
270 |         ];
271 |         videos_values.extend_from_slice(values);
272 |     }
273 | 
274 |     let query = build_bulk_stmt(StatementType::AddVideo, &columns, 1..=videos_values.len());
275 | 
276 |     conn.execute(&query, videos_values.as_slice())?;
277 | 
278 |     Ok(())
279 | }
280 | 
281 | pub fn delete_video(conn: &Connection, video_id: &str) -> Result<()> {
282 |     conn.execute("DELETE FROM videos WHERE video_id=?1", params![video_id])?;
283 |     Ok(())
284 | }
285 | 
286 | pub fn get_channels(conn: &Connection, tags: &[&str]) -> Result<Vec<Channel>> {
287 |     let mut stmt;
288 |     let values;
289 | 
290 |     if tags.is_empty() {
291 |         values = rusqlite::params_from_iter([].iter());
292 | 
293 |         stmt = conn.prepare(
294 |             "SELECT channel_id, channel_name, last_refreshed
295 |             FROM channels
296 |             ORDER BY channel_name COLLATE NOCASE ASC
297 |             ",
298 |         )?;
299 |     } else {
300 |         values = rusqlite::params_from_iter(tags.iter());
301 | 
302 |         stmt = conn.prepare(&build_bulk_stmt(
303 |             StatementType::GetChannels,
304 |             &["tag_name"],
305 |             1..=tags.len(),
306 |         ))?;
307 |     }
308 | 
309 |     let mut channels = Vec::new();
310 |     for channel in stmt.query_map(values, |row| {
311 |         let channel_id: String = row.get(0)?;
312 |         let channel_name: String = row.get(1)?;
313 |         let last_refreshed: Option<u64> = row.get(2)?;
314 |         Ok(Channel::new(channel_id, channel_name, last_refreshed))
315 |     })? {
316 |         channels.push(channel?);
317 |     }
318 | 
319 |     Ok(channels)
320 | }
321 | 
322 | pub fn get_videos(conn: &Connection, channel_id: &str, tab: ChannelTab) -> Result<Vec<Video>> {
323 |     let mut stmt = conn.prepare(
324 |         "SELECT videos.video_id, title, published, length, members_only,
325 |         EXISTS (SELECT * FROM watched WHERE watched.video_id=videos.video_id)
326 |         FROM videos
327 |         WHERE channel_id=?1 AND tab=?2
328 |         ORDER BY published DESC
329 |         ",
330 |     )?;
331 |     let mut videos = Vec::new();
332 |     for video in stmt.query_map(params![channel_id, tab as u8], |row| {
333 |         Ok(Video {
334 |             channel_name: None,
335 |             video_id: row.get(0)?,
336 |             title: row.get(1)?,
337 |             published: row.get(2)?,
338 |             published_text: utils::published_text(row.get(2)?).unwrap_or_default(),
339 |             length: row.get(3)?,
340 |             watched: row.get(5)?,
341 |             members_only: row.get(4).unwrap_or_default(),
342 |             new: false,
343 |         })
344 |     })? {
345 |         videos.push(video?);
346 |     }
347 | 
348 |     Ok(videos)
349 | }
350 | 
351 | pub fn get_latest_videos(conn: &Connection, tags: &[&str], tab: ChannelTab) -> Result<Vec<Video>> {
352 |     let mut stmt;
353 |     let mut values = Vec::with_capacity(tags.len() + 1);
354 |     let tab = params![tab as u8];
355 |     values.extend_from_slice(tab);
356 | 
357 |     if tags.is_empty() {
358 |         stmt = conn.prepare(
359 |             "SELECT video_id, title, published, length, members_only, channel_name,
360 |             EXISTS (SELECT * FROM watched WHERE watched.video_id=videos.video_id)
361 |             FROM videos, channels
362 |             WHERE videos.channel_id = channels.channel_id AND tab=?1
363 |             ORDER BY published DESC
364 |             LIMIT 100
365 |             ",
366 |         )?;
367 |     } else {
368 |         for tag in tags {
369 |             let tag = params![*tag];
370 |             values.extend_from_slice(tag);
371 |         }
372 | 
373 |         stmt = conn.prepare(&build_bulk_stmt(
374 |             StatementType::GetLatestVideos,
375 |             &["tag_name"],
376 |             2..=values.len(),
377 |         ))?;
378 |     }
379 |     let mut videos = Vec::new();
380 | 
381 |     for video in stmt.query_map(values.as_slice(), |row| {
382 |         Ok(Video {
383 |             channel_name: Some(row.get(5)?),
384 |             video_id: row.get(0)?,
385 |             title: row.get(1)?,
386 |             published: row.get(2)?,
387 |             published_text: utils::published_text(row.get(2)?).unwrap_or_default(),
388 |             length: row.get(3)?,
389 |             watched: row.get(6)?,
390 |             members_only: row.get(4).unwrap_or_default(),
391 |             new: false,
392 |         })
393 |     })? {
394 |         videos.push(video?);
395 |     }
396 | 
397 |     Ok(videos)
398 | }
399 | 
400 | pub fn add_watched(conn: &Connection, video_id: &str, watched: bool) -> Result<()> {
401 |     let mut stmt = if watched {
402 |         conn.prepare("INSERT OR IGNORE INTO watched (video_id) VALUES (?1)")?
403 |     } else {
404 |         conn.prepare("DELETE FROM watched WHERE video_id=?1")?
405 |     };
406 | 
407 |     stmt.execute(params![video_id])?;
408 |     Ok(())
409 | }
410 | 
411 | pub fn create_tag(conn: &Connection, tag_name: &str) -> Result<()> {
412 |     conn.execute(
413 |         "INSERT INTO tags (tag_name)
414 |         VALUES (?1)",
415 |         params![tag_name],
416 |     )?;
417 | 
418 |     Ok(())
419 | }
420 | 
421 | pub fn rename_tag(conn: &Connection, old_name: &str, new_name: &str) -> Result<()> {
422 |     conn.execute(
423 |         "UPDATE tags SET tag_name=?1 WHERE tag_name=?2",
424 |         params![new_name, old_name],
425 |     )?;
426 | 
427 |     Ok(())
428 | }
429 | 
430 | pub fn get_tags(conn: &Connection) -> Result<Vec<String>> {
431 |     let mut stmt = conn.prepare("SELECT tag_name FROM tags")?;
432 | 
433 |     let mut tags = Vec::new();
434 | 
435 |     for tag in stmt.query_map([], |row| row.get(0))? {
436 |         tags.push(tag?);
437 |     }
438 | 
439 |     Ok(tags)
440 | }
441 | 
442 | pub fn delete_tag(conn: &Connection, tag_name: &str) -> Result<()> {
443 |     conn.execute("DELETE FROM tags WHERE tag_name=?1", params![tag_name])?;
444 |     Ok(())
445 | }
446 | 
447 | pub fn update_channels_of_tag(
448 |     conn: &Connection,
449 |     tag_name: &str,
450 |     channel_ids: &[String],
451 | ) -> Result<()> {
452 |     let present_channels = get_channels(conn, &[tag_name])?;
453 | 
454 |     let columns = ["tag_name", "channel_id"];
455 | 
456 |     let new: Vec<&String> = channel_ids
457 |         .iter()
458 |         .filter(|channel_id| {
459 |             !present_channels
460 |                 .iter()
461 |                 .any(|other_channel| other_channel.channel_id == **channel_id)
462 |         })
463 |         .collect();
464 | 
465 |     let mut values = Vec::with_capacity(new.len() * columns.len());
466 |     for channel_id in new {
467 |         let v = params![tag_name, *channel_id];
468 |         values.extend_from_slice(v);
469 |     }
470 | 
471 |     if !values.is_empty() {
472 |         let query = build_bulk_stmt(StatementType::AddToTag, &columns, 1..=values.len());
473 |         conn.execute(&query, values.as_slice())?;
474 |     }
475 | 
476 |     let removed: Vec<&String> = present_channels
477 |         .iter()
478 |         .map(|channel| &channel.channel_id)
479 |         .filter(|channel| {
480 |             !channel_ids
481 |                 .iter()
482 |                 .any(|other_channel| other_channel == *channel)
483 |         })
484 |         .collect();
485 | 
486 |     let mut values = Vec::with_capacity(removed.len() * columns.len());
487 |     for channel in removed {
488 |         let v = params![tag_name, *channel];
489 |         values.extend_from_slice(v);
490 |     }
491 | 
492 |     let query = build_bulk_stmt(StatementType::RemoveFromTag, &columns, 1..=values.len());
493 |     conn.execute(&query, values.as_slice())?;
494 | 
495 |     Ok(())
496 | }
497 | 


--------------------------------------------------------------------------------