pub enum Error {}

pub enum Error {
    #[error("can not create socket: {0}")]
    CreateSocket(std::io::Error),
    #[error("can not connect socket: {0}")]
    ConnectSocket(std::io::Error),
    #[error("can not serialize message: {0}")]
    SerializeMessage(bincode::Error),
    #[error("can not send message to socket: {0}")]
    SendMessage(std::io::Error),
}

        let socket = UnixDatagram::unbound().unwrap();
        socket.connect(&self.socket_path).unwrap();
        socket.send(&bincode::serialize(&message).unwrap()).unwrap();

        let socket = UnixDatagram::unbound().map_err(Error::CreateSocket)?;
        socket
            .connect(&self.socket_path)
            .map_err(Error::ConnectSocket)?;
        socket
            .send(&bincode::serialize(&message).map_err(Error::SerializeMessage)?)
            .map_err(Error::SendMessage)?;

    #[error("can not convert exit status from sqlite: {0}")]
    ConvertExitStatus(std::num::TryFromIntError),
    #[error("can not get base directories")]
    GetBaseDirectories,

                format_pwd(entry.pwd),

                format_pwd(entry.pwd)?,

                chrono::NaiveDateTime::from_timestamp(start_time + entry.duration.unwrap(), 0),

                chrono::NaiveDateTime::from_timestamp(
                    start_time
                        + entry
                            .duration
                            .expect("save as we already checked if duration is some earlier"),
                    0,
                ),

            let result = entry.exit_status.unwrap().try_into().unwrap();

            let result = entry
                .exit_status
                .expect("save as we already checked if status is some earlier")
                .try_into()
                .map_err(Error::ConvertExitStatus)?;

            store.add_entry(&entry).unwrap();

            store.add_entry(&entry)?;

fn format_pwd(pwd: PathBuf) -> String {
    let home = std::env::var("HOME").unwrap();

fn format_pwd(pwd: PathBuf) -> Result<String, Error> {
    let base_dirs = directories::BaseDirs::new().ok_or(Error::GetBaseDirectories)?;
    let home = base_dirs.home_dir();

        without_home.to_string_lossy().to_string()

        Ok(without_home.to_string_lossy().to_string())

        pwd.to_string_lossy().to_string()

        Ok(pwd.to_string_lossy().to_string())

    #[error("can not open cache file: {0}")]
    OpenCacheFile(std::io::Error),
    #[error("can not deserialize cache entries: {0}")]
    DeserializeCacheEntries(serde_json::Error),
    #[error("can not bind to socket: {0}")]
    BindSocket(std::io::Error),
    #[error("can not remove socket: {0}")]
    RemoveSocket(std::io::Error),
    #[error("can not create cache file: {0}")]
    CreateCacheFile(std::io::Error),
    #[error("can not serialize cache entries: {0}")]
    SerializeCacheEntries(serde_json::Error),
    #[error("can not receive message from socket: {0}")]
    ReceiveFromSocket(std::io::Error),
    #[error("can not deserialize message: {0}")]
    DeserializeMessage(bincode::Error),

    let file = std::fs::File::open(&cache_path).unwrap();

    let file = std::fs::File::open(&cache_path).map_err(Error::OpenCacheFile)?;

    let entries = serde_json::from_reader(reader).unwrap();

    let entries = serde_json::from_reader(reader).map_err(Error::DeserializeCacheEntries)?;

        let socket = UnixDatagram::bind(&socket_path).unwrap();

        let socket = UnixDatagram::bind(&socket_path).map_err(Error::BindSocket)?;

        std::fs::remove_file(&socket_path).unwrap();

        std::fs::remove_file(&socket_path).map_err(Error::RemoveSocket)?;

        let file = std::fs::File::create(&self.cache_path).unwrap();

        let file = std::fs::File::create(&self.cache_path).map_err(Error::CreateCacheFile)?;

        serde_json::to_writer(writer, &self.entries).unwrap();

        serde_json::to_writer(writer, &self.entries).map_err(Error::SerializeCacheEntries)?;

        let (written, _) = socket.recv_from(&mut buffer).unwrap();

        let (written, _) = socket
            .recv_from(&mut buffer)
            .map_err(Error::ReceiveFromSocket)?;

        let message = bincode::deserialize(&buffer[0..written]).unwrap();

        let message =
            bincode::deserialize(&buffer[0..written]).map_err(Error::DeserializeMessage)?;