Drop PKGBUILD action

.github/workflows/PKGBUILD

@@ -1,7 +1,7 @@
 # Maintainer: Alexandr Bogomyakov (ultradesu) <ab@hexor.ru>
 
 pkgname=tmux-helper
-pkgver=0.2.1
+pkgver=0.3.4
 pkgrel=1
 pkgdesc="Tmux helper"
 url="https://github.com/house-of-vanity/tmux-helper.git"

.github/workflows/build.yml

@@ -1,95 +1,95 @@
 name: Build and publish
+
 on:
   push:
-    # Sequence of patterns matched against refs/tags
     tags:
-    - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
+      - 'v*'
+
+env:
+  BINARY_NAME: tmux-helper
 
 jobs:
-  make_bin:
+  build:
-    name: Build binary
+    name: Build binaries
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        include:
+          - os: ubuntu-latest
+            platform_name: linux-amd64
+          - os: macos-latest
+            platform_name: macos-arm64
     steps:
-      - name: Checkout code
+      - uses: actions/checkout@v4
-        uses: actions/checkout@v2
+
-      - name: Pre-build
+      - name: Pre-build (Linux)
+        if: matrix.os == 'ubuntu-latest'
         run: sudo apt install -y libdbus-1-dev pkg-config libdbus-1-3 libfuse-dev
-      - uses: actions/checkout@v2
+
+      - name: Pre-build (macOS)
+        if: matrix.os == 'macos-latest'
+        run: brew install dbus
+
       - name: Build binary
         run: cargo build --release
-      - name: Upload binary
-        uses: actions/upload-artifact@v1
-        with:
-          name: tmux-helper
-          path: ./target/release/tmux-helper
-  make_arch:
-      name: Make Arch Linux package
-      runs-on: ubuntu-latest
-      container:
-        image: archlinux
-        options: --privileged
-        volumes:
-          - /sys/fs/cgroup:/sys/fs/cgroup
-      steps:
-        - uses: actions/checkout@v2
-        - name: Build Arch Linux package
-          uses: FFY00/build-arch-package@master
-          with:
-            PKGBUILD: $GITHUB_WORKSPACE/.github/workflows/PKGBUILD
-            OUTDIR: $HOME/arch-packages
-        - run: mv $HOME/arch-packages/*pkg.tar.zst tmux-helper-x86_64.pkg.tar.zst
-        - name: Upload Arch Package
-          uses: actions/upload-artifact@v1
-          with:
-            name: arch_linux_tmux-helper-x86_64.pkg.tar.zst
-            path: ./tmux-helper-x86_64.pkg.tar.zst
 
-  publish:
+      - name: Rename binary
-    name: Publish release
-    needs: [make_bin, make_arch]
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get the version (git tag)
-        id: get_version
         run: |
-          echo ${GITHUB_REF/refs\/tags\/v/}
+          mkdir -p ${{ env.BINARY_NAME }}_${{ matrix.platform_name }}
-          echo ::set-output name=VERSION::${GITHUB_REF/refs\/tags\/v/}
+          cp target/release/${{ env.BINARY_NAME }} ${{ env.BINARY_NAME }}_${{ matrix.platform_name }}/${{ env.BINARY_NAME }}
-          echo ::set-output name=FULL_TAG::${GITHUB_REF/refs\/tags\//}
+
-      - name: Create Release
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ${{ env.BINARY_NAME }}_${{ matrix.platform_name }}
+          path: ${{ env.BINARY_NAME }}_${{ matrix.platform_name }}
+
+  release:
+    name: Create Release Page
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    outputs:
+      upload_url: ${{ steps.create_release.outputs.upload_url }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ncipollo/release-action@v1
         id: create_release
-        uses: actions/create-release@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          tag_name: ${{ github.ref }}
+          allowUpdates: true
-          release_name: Release ${{ github.ref }}
+          tag: ${{ github.ref_name }}
-          draft: false
-          prerelease: false
-      - name: Download binary
-        uses: actions/download-artifact@v1
-        with:
-          name: tmux-helper
-          path: ./
-      - name: Download Arch Package
-        uses: actions/download-artifact@v1
-        with:
-          name: arch_linux_tmux-helper-x86_64.pkg.tar.zst
-          path: ./
-      - name: Upload binary assets
-        run: |
-           wget https://github.com/aktau/github-release/releases/download/v0.7.2/linux-amd64-github-release.tar.bz2
-           tar xjf linux-amd64-github-release.tar.bz2
-           export GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }}
-           ./bin/linux/amd64/github-release upload -u house-of-vanity -r tmux-helper --tag ${{ steps.get_version.outputs.FULL_TAG }} --name arch_linux_tmux-helper-${{ steps.get_version.outputs.VERSION }}-x86_64.pkg.tar.zst --file ./tmux-helper-x86_64.pkg.tar.zst
-           ./bin/linux/amd64/github-release upload -u house-of-vanity -r tmux-helper --tag ${{ steps.get_version.outputs.FULL_TAG }} --name tmux-helper-${{ steps.get_version.outputs.VERSION }} --file ./tmux-helper
 
-      # SCP to arch repo
+  upload:
-      - name: Copy package to repository
+    name: Upload Release Assets
-        uses: appleboy/scp-action@master
+    needs: release
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        include:
+          - os: ubuntu-latest
+            platform_name: linux-amd64
+          - os: macos-latest
+            platform_name: macos-arm64
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/download-artifact@v4
+        name: Download ${{ matrix.platform_name }} artifact
         with:
-          host: ${{ secrets.SSH_HOST }}
+          name: ${{ env.BINARY_NAME }}_${{ matrix.platform_name }}
-          username: github_deploy
+          path: ${{ env.BINARY_NAME }}_${{ matrix.platform_name }}
-          port: 22
+
-          key: ${{ secrets.SSH_KEY }}
+      - name: Upload Release Asset
-          source: "./tmux-helper-x86_64.pkg.tar.zst"
+        uses: actions/upload-release-asset@v1
-          target: "/srv/arch-repo/"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.release.outputs.upload_url }}
+          asset_path: ${{ env.BINARY_NAME }}_${{ matrix.platform_name }}/${{ env.BINARY_NAME }}
+          asset_name: ${{ env.BINARY_NAME }}_${{ matrix.platform_name }}
+          asset_content_type: application/octet-stream
+

Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "tmux-helper"
-version = "0.3.2"
+version = "0.3.5"
 description = "Utility for printing system info for tmux status line."
 authors = ["Ultra Desu <ultradesu@hexor.ru>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
 sys-info = "*"
@@ -11,3 +11,4 @@ dbus = "*"
 chrono = "*"
 mpd = "*"
 clap = "*"
+size_format = "1.0"

README.md

@@ -3,14 +3,37 @@ Small app that perform system check and print TMUX friendly output.
 
 ![Preview](.github/prev.png)
 
-### Features:
-1. `tmux-helper -cb` print cpu load with bar.
-2. `tmux-helper -mb` print memory usage with bar.
-3. `tmux-helper -p` show current player status using d-bus.
-
 ### Building 
 `cargo build --release`
 or get binary on release page
 
-### Customization
+### Fetures
-Colours are hardcoded but it's easy to change it. It defined as CONST in very beginning of main.rs file.
+```shell
+tmux-helper 0.3.2
+Ultra Desu <ultradesu@hexor.ru>
+Utility for printing system info for tmux status line.
+
+USAGE:
+    tmux-helper [FLAGS] [OPTIONS]
+
+FLAGS:
+    -c, --cpu        Print cpu load bar.
+    -h, --help       Prints help information
+    -m, --mem        Print mem usage bar.
+    -d, --mpd        Show mpd player using MPD native protocol.
+    -p, --mpris      Show player info using MPRIS2 interface.
+    -V, --version    Prints version information
+
+OPTIONS:
+        --COLOR_END <COLOR_END>                      Default color using to terminate others.
+        --COLOR_HIGH <COLOR_HIGH>                    CPU and MEM bar color while high usage.
+        --COLOR_LOW <COLOR_LOW>                      CPU and MEM bar color while low usage.
+        --COLOR_MID <COLOR_MID>                      CPU and MEM bar color while mid usage.
+        --COLOR_TRACK_ARTIST <COLOR_TRACK_ARTIST>    Color of artist name filed.
+        --COLOR_TRACK_NAME <COLOR_TRACK_NAME>        Color of track name filed.
+        --COLOR_TRACK_TIME <COLOR_TRACK_TIME>        Color of playing time field.
+    -l, --localtime <localtime>                      Local time
+    -a, --mpd-address <mpd_address>                  <ADDR>:<PORT> of MPD server.
+    -u, --utctime <utctime>                          UTC time
+```
+

src/config.rs

@@ -1,4 +1,4 @@
-use clap::{App, Arg};
+use clap::{Arg, Command};
 
 #[derive(Debug)]
 pub enum Action {
@@ -36,191 +36,142 @@ fn colorize(color: String) -> String {
 }
 
 pub fn read() -> Config {
-    // Parse opts and args
+    let cli_args = Command::new(env!("CARGO_PKG_NAME"))
-    let cli_args = App::new(env!("CARGO_PKG_NAME"))
         .version(env!("CARGO_PKG_VERSION"))
         .author(env!("CARGO_PKG_AUTHORS"))
         .about(env!("CARGO_PKG_DESCRIPTION"))
-        // Flags
         .arg(
-            Arg::with_name("cpu")
+            Arg::new("cpu")
-                .short("c")
+                .short('c')
                 .long("cpu")
                 .help("Print cpu load bar.")
-                .conflicts_with_all(&["mem", "mpris", "mpd", "localtime", "utctime"])
+                .action(clap::ArgAction::SetTrue)
-                .required(false),
+                .conflicts_with_all(["mem", "mpris", "mpd", "localtime", "utctime"]),
         )
         .arg(
-            Arg::with_name("mem")
+            Arg::new("mem")
-                .short("m")
+                .short('m')
                 .long("mem")
-                .help("Print mem usage bar.")
+                .action(clap::ArgAction::SetTrue)
-//              .conflicts_with("cpu")
+                .help("Print mem usage bar."),
-//              .conflicts_with("mpris")
-//              .conflicts_with("mpd")
-//              .conflicts_with("localtime")
-//              .conflicts_with("utctime")
-                .required(false),
         )
         .arg(
-            Arg::with_name("mpris")
+            Arg::new("mpris")
-                .short("p")
+                .short('p')
                 .long("mpris")
-                .help("Show player info using MPRIS2 interface.")
+                .action(clap::ArgAction::SetTrue)
-//              .conflicts_with("cpu")
+                .help("Show player info using MPRIS2 interface."),
-//              .conflicts_with("mem")
-//              .conflicts_with("localtime")
-//              .conflicts_with("mpd")
-//              .conflicts_with("utctime")
-                .required(false),
         )
         .arg(
-            Arg::with_name("mpd")
+            Arg::new("mpd")
-                .short("d")
+                .short('d')
                 .long("mpd")
-                .help("Show mpd player using MPD native protocol.")
+                .action(clap::ArgAction::SetTrue)
-//              .conflicts_with("cpu")
+                .help("Show mpd player using MPD native protocol."),
-//              .conflicts_with("mem")
-//              .conflicts_with("localtime")
-//              .conflicts_with("mpris")
-//              .conflicts_with("utctime")
-                .required(false),
         )
-        // Options
         .arg(
-            Arg::with_name("localtime")
+            Arg::new("localtime")
-                .short("l")
+                .short('l')
                 .long("localtime")
                 .help("Local time")
-//              .conflicts_with_all(&["mem", "mpris", "mpd", "cpu", "utctime"])
+                .num_args(0..=1)
-                .takes_value(true)
+                .default_missing_value("%H:%M"),
-                .required(false),
         )
         .arg(
-            Arg::with_name("utctime")
+            Arg::new("utctime")
-                .short("u")
+                .short('u')
                 .long("utctime")
                 .help("UTC time")
-//              .conflicts_with_all(&["mem", "mpris", "mpd", "cpu", "localtime"])
+                .num_args(0..=1)
-                .takes_value(true)
+                .default_missing_value("%H:%M"),
-                .required(false),
         )
         .arg(
-            Arg::with_name("mpd_address")
+            Arg::new("mpd_address")
-                .short("a")
+                .short('a')
                 .long("mpd-address")
                 .help("<ADDR>:<PORT> of MPD server.")
-                .takes_value(true)
+                .default_value("127.0.0.1:6600"),
-                .default_value("127.0.0.1:6600")
-                .required(false),
         )
         .arg(
-            Arg::with_name("COLOR_LOW")
+            Arg::new("COLOR_LOW")
                 .long("COLOR_LOW")
                 .help("CPU and MEM bar color while low usage.")
-                .takes_value(true)
+                .default_value("119"),
-                .default_value("119")
-                .required(false),
         )
         .arg(
-            Arg::with_name("COLOR_MID")
+            Arg::new("COLOR_MID")
                 .long("COLOR_MID")
                 .help("CPU and MEM bar color while mid usage.")
-                .takes_value(true)
+                .default_value("220"),
-                .default_value("220")
-                .required(false),
         )
         .arg(
-            Arg::with_name("COLOR_HIGH")
+            Arg::new("COLOR_HIGH")
                 .long("COLOR_HIGH")
                 .help("CPU and MEM bar color while high usage.")
-                .takes_value(true)
+                .default_value("197"),
-                .default_value("197")
-                .required(false),
         )
         .arg(
-            Arg::with_name("COLOR_TRACK_NAME")
+            Arg::new("COLOR_TRACK_NAME")
                 .long("COLOR_TRACK_NAME")
                 .help("Color of track name filed.")
-                .takes_value(true)
+                .default_value("46"),
-                .default_value("46")
-                .required(false),
         )
         .arg(
-            Arg::with_name("COLOR_TRACK_ARTIST")
+            Arg::new("COLOR_TRACK_ARTIST")
                 .long("COLOR_TRACK_ARTIST")
                 .help("Color of artist name filed.")
-                .takes_value(true)
+                .default_value("46"),
-                .default_value("46")
-                .required(false),
         )
         .arg(
-            Arg::with_name("COLOR_TRACK_TIME")
+            Arg::new("COLOR_TRACK_TIME")
                 .long("COLOR_TRACK_TIME")
                 .help("Color of playing time field.")
-                .takes_value(true)
+                .default_value("153"),
-                .default_value("153")
-                .required(false),
         )
         .arg(
-            Arg::with_name("COLOR_END")
+            Arg::new("COLOR_END")
                 .long("COLOR_END")
                 .help("Default color using to terminate others.")
-                .takes_value(true)
+                .default_value("153"),
-                .default_value("153")
-                .required(false),
         )
         .get_matches();
 
-    // cpu          - cpu usage bar
+    let lt_format = cli_args.get_one::<String>("localtime").map(|s| s.to_string());
-    // mem          - mem usage bar
+    let ut_format = cli_args.get_one::<String>("utctime").map(|s| s.to_string());
-    // mpris        - player info using MPRIS2 interface
-    // mpd          - player info using MPD native interface
-    // utctime      - utc time
-    // localtime    - local time
-    // lt_format    - local time format
-    // ut_format    - utc time format
-
-    let lt_format = Some(match cli_args.value_of("localtime") {
-                Some(format) => format.to_string(),
-                None => "%H:%M".to_string(),
-            });
-    let ut_format = Some(match cli_args.value_of("utctime") {
-                Some(format) => format.to_string(),
-                None => "%H:%M".to_string(),
-            });
 
     let mut cfg = Config {
         action: Action::Cpu,
-        mpd_server: cli_args.value_of("mpd_address").unwrap().to_string(),
+        mpd_server: cli_args.get_one::<String>("mpd_address").unwrap().to_string(),
-        lt_format: lt_format,
+        lt_format,
-        ut_format: ut_format,
+        ut_format,
-        color_low: colorize(cli_args.value_of("COLOR_LOW").unwrap().to_string()),
+        color_low: colorize(cli_args.get_one::<String>("COLOR_LOW").unwrap().to_string()),
-        color_mid: colorize(cli_args.value_of("COLOR_MID").unwrap().to_string()),
+        color_mid: colorize(cli_args.get_one::<String>("COLOR_MID").unwrap().to_string()),
-        color_high: colorize(cli_args.value_of("COLOR_HIGH").unwrap().to_string()),
+        color_high: colorize(cli_args.get_one::<String>("COLOR_HIGH").unwrap().to_string()),
-        color_track_name: colorize(cli_args.value_of("COLOR_TRACK_NAME").unwrap().to_string()),
+        color_track_name: colorize(cli_args.get_one::<String>("COLOR_TRACK_NAME").unwrap().to_string()),
-        color_track_artist: colorize(cli_args.value_of("COLOR_TRACK_ARTIST").unwrap().to_string()),
+        color_track_artist: colorize(cli_args.get_one::<String>("COLOR_TRACK_ARTIST").unwrap().to_string()),
-        color_track_time: colorize(cli_args.value_of("COLOR_TRACK_TIME").unwrap().to_string()),
+        color_track_time: colorize(cli_args.get_one::<String>("COLOR_TRACK_TIME").unwrap().to_string()),
-        color_end: colorize(cli_args.value_of("COLOR_END").unwrap().to_string()),
+        color_end: colorize(cli_args.get_one::<String>("COLOR_END").unwrap().to_string()),
     };
 
-    if cli_args.is_present("cpu") {
+    if cli_args.get_flag("cpu") {
         cfg.action = Action::Cpu;
     }
-    if cli_args.is_present("mem") {
+    if cli_args.get_flag("mem") {
         cfg.action = Action::Mem;
     }
-    if cli_args.is_present("localtime") {
+    if cli_args.contains_id("localtime") {
         cfg.action = Action::Localtime;
     }
-    if cli_args.is_present("utctime") {
+    if cli_args.contains_id("utctime") {
         cfg.action = Action::Utctime;
     }
-    if cli_args.is_present("mpris") {
+    if cli_args.get_flag("mpris") {
         cfg.action = Action::Mpris;
     }
-    if cli_args.is_present("mpd") {
+    if cli_args.get_flag("mpd") {
         cfg.action = Action::Mpd;
     }
+
     cfg
 }
+

src/main.rs

@@ -1,27 +1,18 @@
-extern crate chrono;
-extern crate dbus;
-extern crate mpd;
-
 mod config;
 mod utils;
 
 #[derive(Debug, Clone)]
-struct TrackInfo {
+pub struct TrackInfo {
-    title: String,
+    pub title: String,
-    artist: String,
+    pub artist: String,
-    position: String,
+    pub position: String,
-    duration: String,
+    pub duration: String,
-    status: String,
+    pub status: String,
 }
 
 fn main() {
     let conf = config::read();
-    // cpu          - cpu usage bar
+
-    // mem          - mem usage bar
-    // mpris        - player info using MPRIS2 interface
-    // mpd          - player info using MPD native interface
-    // utctime      - utc time
-    // localtime    - local time
     match conf.action {
         config::Action::Cpu => utils::cpu_load_bar(15, &conf),
         config::Action::Mem => utils::mem_load_bar(15, &conf),
@@ -31,3 +22,4 @@ fn main() {
         config::Action::Mpd => utils::mpd(&conf),
     }
 }
+

src/utils.rs

@@ -1,267 +1,190 @@
+use dbus::arg::RefArg;
 use crate::config;
-use crate::dbus::blocking::stdintf::org_freedesktop_dbus::Properties;
+use chrono::{Local, Utc};
-use chrono::{DateTime, Local, Utc};
 use dbus::{arg, blocking::Connection};
+use mpd::Client;
+use size_format::SizeFormatterBinary;
+use std::process;
 use std::time::Duration;
 use sys_info;
-use mpd::Client;
+use dbus::blocking::stdintf::org_freedesktop_dbus::Properties;
-use std::process;
 
 #[derive(Debug, Clone)]
 pub struct TrackInfo {
-    title: String,
+    pub title: String,
-    artist: String,
+    pub artist: String,
-    position: String,
+    pub position: String,
-    duration: String,
+    pub duration: String,
-    status: String,
+    pub status: String,
 }
 
 pub fn to_bar(value: i32, max: i32, low: f32, mid: f32, config: &config::Config) {
     let mut bar = "".to_string();
-    let bar_sym = "▮".to_string();
+    let bar_sym = "▮";
-    if (value as f32) / (max as f32) < low {
+    let ratio = (value as f32) / (max as f32);
-        bar.push_str(&config.color_low);
+    bar.push_str(if ratio < low {
-    } else if (value as f32) / (max as f32) < mid {
+        &config.color_low
-        bar.push_str(&config.color_mid);
+    } else if ratio < mid {
+        &config.color_mid
     } else {
-        bar.push_str(&config.color_high);
+        &config.color_high
-    }
+    });
     for i in 0..max {
-        if i < value as i32 {
+        bar.push_str(if i < value { bar_sym } else { " " });
-            bar.push_str(&bar_sym);
-        } else {
-            bar.push_str(" ")
-        }
     }
     bar.push_str(&config.color_end);
-    bar.push_str("|");
+    bar.push('|');
-    print!("{}", bar)
+    print!("{}", bar);
 }
 
 pub fn mem_load_bar(bar_len: i32, config: &config::Config) {
-    let memory;
+    let memory = sys_info::mem_info().expect("Failed to get mem_info");
-    match sys_info::mem_info() {
+    let used_ratio = (memory.total - memory.avail) as f32 / memory.total as f32;
-        Err(w) => panic!("{:?}", w),
+    let len = (used_ratio * bar_len as f32) as i32;
-        Ok(mem_data) => memory = mem_data,
-    }
-    let len =
-        ((memory.total - memory.avail) as f32 / (memory.total as f32) * bar_len as f32) as i32;
     to_bar(len, bar_len, 0.7, 0.9, config);
-    print!("{:.0} MiB#[default]", memory.avail / 1024);
+    print!(
+        "{}B #[default]",
+        SizeFormatterBinary::new((memory.avail * 1024) as u64)
+    );
 }
 
 pub fn cpu_load_bar(bar_len: i32, config: &config::Config) {
-    let cpu_count = match sys_info::cpu_num() {
+    let cpu_count = sys_info::cpu_num().expect("Failed to get cpu_num");
-        Ok(c) => c,
+    let la_one = sys_info::loadavg().expect("Failed to get loadavg").one;
-        Err(e) => panic!("{:?}", e),
+    let len = (la_one / cpu_count as f64 * bar_len as f64).round() as i32;
-    };
+    to_bar(len, bar_len, 0.3, 0.7, config);
-    let la_one: f32 = match sys_info::loadavg() {
-        Ok(l) => l.one as f32,
-        Err(e) => panic!("{:?}", e),
-    };
-    let len: f32 = la_one as f32 / cpu_count as f32 * bar_len as f32;
-    to_bar(len as i32, bar_len, 0.3, 0.7, config);
     print!("{:.2} LA1#[default]", la_one);
 }
 
 pub fn get_player() -> Result<Vec<String>, Box<dyn std::error::Error>> {
     let conn = Connection::new_session()?;
-    let proxy = conn.with_proxy("org.freedesktop.DBus", "/", Duration::from_millis(5000));
+    let proxy = conn.with_proxy("org.freedesktop.DBus", "/", Duration::from_secs(5));
     let (names,): (Vec<String>,) = proxy.method_call("org.freedesktop.DBus", "ListNames", ())?;
-    let mut players: Vec<String> = Vec::new();
+    Ok(names.into_iter().filter(|n| n.contains("org.mpris.MediaPlayer2")).collect())
-    for name in names {
-        if name.contains("org.mpris.MediaPlayer2") {
-            players.push(name);
-        }
-    }
-
-    Ok(players)
 }
 
 pub fn player_info(players: Vec<String>) -> Result<TrackInfo, Box<dyn std::error::Error>> {
-    let mut players_vec: Vec<TrackInfo> = Vec::new();
     for player in players {
-        let mut track_info = TrackInfo {
-            artist: "".to_string(),
-            title: "".to_string(),
-            position: "".to_string(),
-            duration: "".to_string(),
-            status: "".to_string(),
-        };
         let conn = Connection::new_session()?;
-        let proxy = conn.with_proxy(
+        let proxy = conn.with_proxy(player, "/org/mpris/MediaPlayer2", Duration::from_secs(5));
-            player,
+        let metadata: arg::PropMap = proxy.get("org.mpris.MediaPlayer2.Player", "Metadata")?;
-            "/org/mpris/MediaPlayer2",
+        
-            Duration::from_millis(5000),
+        let title = metadata.get("xesam:title").and_then(|v| v.as_str()).unwrap_or("").to_string();
-        );
+        let artist = metadata.get("xesam:artist")
-        let metadata: Box<dyn arg::RefArg> =
+            .and_then(|v| v.as_iter())
-            proxy.get("org.mpris.MediaPlayer2.Player", "Metadata")?;
+            .and_then(|mut artists| artists.next().and_then(|a| a.as_str()))
-        let mut iter = metadata.as_iter().unwrap();
+            .unwrap_or("").to_string();
-        while let Some(key) = iter.next() {
+        let duration_us = metadata.get("mpris:length").and_then(|v| v.as_i64()).unwrap_or(0);
-            if key.as_str() == Some("xesam:title") {
+        let position_us: i64 = proxy.get("org.mpris.MediaPlayer2.Player", "Position")?;
-                if let Some(title) = iter.next().unwrap().as_str() {
+        let status_text: String = proxy.get("org.mpris.MediaPlayer2.Player", "PlaybackStatus")?;
-                    track_info.title = title.to_string();
+
-                }
+        let status = match status_text.as_str() {
-            }
+            "Playing" => "▶",
-            if key.as_str() == Some("mpris:length") {
+            "Paused" => "⏸",
-                if let Some(length) = iter.next().unwrap().as_i64() {
+            _ => "⏹",
-                    track_info.duration = format_time(length / 1000000);
+        }.to_string();
-                }
+
-            }
+        let track_info = TrackInfo {
-            if key.as_str() == Some("xesam:artist") {
+            title,
-                if let Some(mut artists) = iter.next().unwrap().as_iter() {
+            artist,
-                    while let Some(artist) = artists.next() {
+            position: format_time(position_us / 1_000_000),
-                        if let Some(mut line) = artist.as_iter() {
+            duration: format_time(duration_us / 1_000_000),
-                            track_info.artist = line.next().unwrap().as_str().unwrap().to_string();
+            status,
-                        }
-                    }
-                }
-            }
-        }
-        let position: Box<dyn arg::RefArg> =
-            proxy.get("org.mpris.MediaPlayer2.Player", "Position")?;
-        track_info.position = format_time(position.as_i64().unwrap() / 1000000);
-        // ugly
-        let _status_text_box: Box<dyn arg::RefArg> =
-            proxy.get("org.mpris.MediaPlayer2.Player", "PlaybackStatus")?;
-        let _status_text = _status_text_box.as_str().unwrap();
-        match _status_text.as_ref() {
-            "Playing" => track_info.status = "▶".to_string(),
-            "Paused" => track_info.status = "⏸".to_string(),
-            _ => track_info.status = "⏹".to_string(),
         };
-        players_vec.push(track_info);
+
-    }
+        if track_info.status == "▶" {
-    for player in &players_vec {
+            return Ok(track_info);
-        if player.status == "▶".to_string() {
-            return Ok(player.clone());
         }
     }
-    Ok(players_vec[players_vec.len() - 1].clone())
+    Err("No active player".into())
 }
 
 pub fn format_time(sec: i64) -> String {
-    let minutes = sec / 60;
+    format!("{:02}:{:02}", sec / 60, sec % 60)
-    let secondes = sec % 60;
-    let result = format!("{:02}:{:02}", minutes, secondes);
-    result.to_string()
 }
 
 pub fn get_time(utc: bool, format: Option<String>) {
-    // Format reference: https://docs.rs/chrono/0.4.10/chrono/format/strftime/index.html
+    let fmt = format.unwrap_or_else(|| "%H:%M".to_string());
-    let fmt = match format {
+    let now = if utc { Utc::now().format(&fmt) } else { Local::now().format(&fmt) };
-        Some(format) => format,
+    println!("{}", now);
-        None => "%H:%M".to_string(),
-    };
-
-    if utc {
-        let local_time = Local::now();
-        let utc_time = DateTime::<Utc>::from_utc(local_time.naive_utc(), Utc);
-        println!("{}", utc_time.format(&fmt));
-    } else {
-        let local_time = Local::now();
-        println!("{}", local_time.format(&fmt));
-    }
 }
 
-fn shorten(line: String, max_len: usize, max_shift: usize) -> String {
+fn shorten(line: &str, max_len: usize) -> String {
-    let mut new_line = String::new();
+    if line.chars().count() > max_len {
-    let len = if max_len + max_shift >= line.chars().count() {
+        format!("{}..", line.chars().take(max_len).collect::<String>())
-        line.chars().count()
     } else {
-        max_len
+        line.to_string()
-    };
-    if line.len() > len {
-        let mut counter = 0;
-        for ch in line.chars() {
-            if counter == len {
-                new_line.push_str("..");
-                break;
     }
-            new_line.push(ch);
-            counter += 1;
-        }
-    }
-    else {
-        new_line = line;
-    }
-    new_line
 }
 
 fn format_player(track_info: TrackInfo, config: &config::Config) {
-    let mut separator: String = " — ".to_string();
+    let separator = if track_info.artist.is_empty() { "" } else { " — " };
-    let mut max_len = 30;
+    let max_len = if track_info.artist.is_empty() { 60 } else { 30 };
-    if track_info.artist.chars().count() == 0 {
+
-        separator = "".to_string();
+    let artist_line = shorten(&track_info.artist, max_len);
-        max_len = max_len * 2;
+    let title_line = shorten(&track_info.title, max_len);
-    }
+
-    let artist_line = shorten(track_info.artist, max_len, 6);
+    if track_info.position == "00:00" || track_info.duration.is_empty() {
-    let title_line = shorten(track_info.title, max_len, 6);
         println!(
-        "#[none]#[bold]{}{}{}#[none]{}{}{}{} {}[{}/{}] {} {}#[default]",
+            "#[bold]{}{}{}{}{}{} {}{} {}#[default]",
-        config.color_track_name,
+            config.color_track_name, title_line, config.color_end,
-        title_line,
-        config.color_end,
             separator,
-        config.color_track_artist,
+            config.color_track_artist, artist_line, config.color_end,
-        artist_line,
+            config.color_track_time, track_info.status
-        config.color_end,
-        config.color_track_time,
-        track_info.position,
-        track_info.duration,
-        track_info.status,
-        config.color_end,
         );
+    } else {
+        println!(
+            "#[bold]{}{}{}{}{}{} {}[{}/{}] {}{}{}#[default]",
+            config.color_track_name, title_line, config.color_end,
+            separator,
+            config.color_track_artist, artist_line, config.color_end,
+            config.color_track_time, track_info.position, track_info.duration,
+            track_info.status, config.color_end
+        );
+    }
 }
 
 pub fn mpris(config: &config::Config) {
-    match player_info(get_player().unwrap()) {
+    match player_info(get_player().unwrap_or_default()) {
         Ok(track_info) => format_player(track_info, config),
-        Err(_e) => println!("No music playing"),
+        Err(_) => println!("No music playing"),
     }
 }
 
 pub fn mpd(config: &config::Config) {
-    let mut conn = match Client::connect(&config.mpd_server) {
+    let mut conn = Client::connect(&config.mpd_server).unwrap_or_else(|e| {
-        Ok(conn) => conn,
+        println!("Can't connect to MPD server. {}", e);
-        Err(e) => {println!("Can't connect to MPD server. {}", e); process::exit(0x0001)}
+        process::exit(1);
+    });
+
+    let song = conn.currentsong().unwrap_or(None);
+    let status = conn.status().unwrap();
+
+    let artist = song.as_ref()
+        .and_then(|s| s.tags.iter().find(|(k, _)| k == "Artist").map(|(_, v)| v))
+        .cloned()
+        .unwrap_or_default();
+
+
+    let title = song.as_ref()
+        .and_then(|s| s.title.clone().or_else(|| s.name.clone()))
+        .unwrap_or_default();
+
+
+    let (position, duration) = status.time.unwrap_or_default();
+
+    let track_info = TrackInfo {
+        title,
+        artist,
+        position: format_time(position.as_secs() as i64),
+        duration: format_time(duration.as_secs() as i64),
+        status: match status.state {
+            mpd::State::Play => "▶",
+            mpd::State::Pause => "⏸",
+            mpd::State::Stop => "⏹",
+        }.to_string(),
     };
-    let mut track_info = TrackInfo {
+
-        title: String::new(),
+    format_player(track_info, config);
-        artist: String::new(),
-        position: String::new(),
-        duration: String::new(),
-        status: String::new(),
-    };
-//  println!("{:?}", conn.currentsong());
-    if let Some(song) = conn.currentsong().unwrap() {
-        if let Some(title) = song.title {
-            track_info.title = title
-        }
-        if let Some(artist) = song.tags.get("Artist") {
-            track_info.artist = artist.to_string()
-        }
-        // if there is no tags and title.
-        if track_info.artist == track_info.title {
-            if let Some(name) = song.name {
-                track_info.title = name
-            }
-        }
-    }
-    if let Some(time) = conn.status().unwrap().time {
-            track_info.position = format_time(time.0.num_seconds() as i64);
-            track_info.duration = format_time(time.1.num_seconds() as i64);
-    }
-    let status = match conn.status() {
-        Ok(status) => {
-            match status.state {
-                mpd::State::Play => "▶".to_string(),
-                mpd::State::Pause => "⏸".to_string(),
-                mpd::State::Stop => "⏹".to_string(),
-            }
-        }
-        Err(_) => {"⏹".to_string()},
-    };
-    track_info.status = status;
-    format_player(track_info, config)
 }
+