☰

Faça `rm` mover para a lixeira

tag-icon • tag-icon shell rm
Faça `rm` mover para a lixeira

Existe um script/aplicativo Linux que, em vez de excluir arquivos, os move para um local especial de “lixeira”? Eu gostaria que isso substituísse rm(talvez até mesmo um apelido para o último; há prós e contras nisso).

Por “lixo” quero dizer uma pasta especial. Um único mv "$@" ~/.trashé o primeiro passo, mas idealmente isso também deve lidar com a lixeira de vários arquivos com o mesmo nome sem substituir arquivos antigos da lixeira e permitirrestaurararquivos para seu local original com um simples comando (uma espécie de “desfazer”). Além disso, seria bom se a lixeira fosse esvaziada automaticamente na reinicialização (ou um mecanismo semelhante para evitar o crescimento infinito).

Existem soluções parciais para isso, mas a ação de “restauração” em particular não é trivial. Existe alguma solução para isso que não dependa de um sistema de lixo de um shell gráfico?

(Além disso, tem havido inúmeras discussões sobre se essa abordagem é justificada, em vez de usar backups frequentes e VCS. Embora essas discussões tenham razão, acredito que ainda há um nicho para minha solicitação.)

Responder1

Existe umespecificação (rascunho) para Lixoem freedesktop.org. Aparentemente, é o que geralmente é implementado em ambientes de desktop.

Uma implementação de linha de comando serialixo-cli. Sem olhar mais de perto, parece oferecer a funcionalidade que você deseja. Caso contrário, diga-nos até que ponto esta é apenas uma solução parcial.

No que diz rmrespeito ao uso de qualquer programa como substituto/alias, há boas razões para não fazer isso. O mais importante para mim são:

  • O programa precisaria entender/lidar com todas rmas opções do e agir de acordo
  • Corre o risco de se acostumar com a semântica do seu “novo rm” e executar comandos com consequências fatais ao trabalhar em sistemas de outras pessoas

Responder2

As respostas anteriores mencionam comandos trash-clie rmtrash. Nenhum deles é encontrado por padrão no Ubuntu 18.04, mas o comandogioé. Saídas de comando gio help trash:

Usage:
  gio trash [OPTION…] [LOCATION...]

Move files or directories to the trash.

Options:
  -f, --force     Ignore nonexistent files, never prompt
  --empty         Empty the trash

Eu testei usandogio trash FILENAMEna linha de comando e funciona exatamente como eu selecionei o arquivo no navegador de arquivos e cliquei no botão DEL: o arquivo é movido para a pasta Lixeira da área de trabalho. (O comando não solicita confirmação, embora eu não tenha usado a -fopção.)

Excluir arquivos dessa forma é reversível, embora seja mais conveniente do que redefinir rmpara rm -isegurança e ter que confirmar cada exclusão, o que ainda deixa você sem sorte se você acidentalmente confirmar uma exclusão que não deveria.

Adicionei alias tt='gio trash'ao meu arquivo de definições de alias; tté um mnemônico para "lixar".

Adicionado na edição em 27/06/2018:Em máquinas servidoras, não existe equivalente a um diretório de lixo. Eu escrevi o seguinte script Bash que faz o trabalho; em máquinas desktop, ele usa gio trash, e em outras máquinas, move o(s) arquivo(s) fornecido(s) como parâmetro(s) para um diretório de lixo que ele cria. O script é testado para funcionar; Eu mesmo uso isso o tempo todo.Script atualizado em 12/04/2024.

#!/bin/bash

# move_to_trash
#
# Teemu Leisti 2024-04-12
#
# USAGE:
#
#   Move the file(s) given as argument(s) to the trash directory, if they are
#   not already there.
#
# RATIONALE:
#
#   The script is intended as a command-line equivalent of deleting a file or
#   directory from a graphical file manager. On hosts that implement the
#   FreeDesktop.org specification on trash directories (hereon called "the trash
#   specification"; see
#   https://specifications.freedesktop.org/trash-spec/trashspec-latest.html),
#   that action moves the target file(s) to a built-in trash directory, and that
#   is exactly what this script does.
#
#   On other hosts, this script uses a custom trash directory (~/.Trash/). The
#   analogy of moving a file to trash is not perfect, as the script does not
#   offer the functionalities of restoring a trashed file to its original
#   location or emptying the trash directory. Rather, it offers an alternative
#   to the 'rm' command, thereby giving the user the peace of mind that they can
#   still undo an unintended deletion before emptying the custom trash
#   directory.
#
# IMPLEMENTATION:
#
#   To determine whether it's running on a host that implements the trash
#   specification, the script tests for the existence of (a) the gio command and
#   (b) either directory $XDG_DATA_HOME/Trash/, or, if that environment variable
#   hasn't bee set, of directory ~/.local/share/Trash/. If the test yields true,
#   the script relies on calling 'gio trash'.
#
#   On other hosts:
#     - There is no built-in trash directory, so the script creates a custom
#       directory ~/.Trash/, unless it already exists. (The script aborts if
#       there is an existing non-directory ~/.Trash.)
#     - The script appends a millisecond-resolution timestamp to all the files
#       it moves to the custom trash directory, to both inform the user of the
#       time of the trashing, and to avoid overwrites.
#     - The user will have to perform an undo by commanding 'mv' on a file or
#       directory moved to ~/.Trash/.
#     - The user will have to empty the custom trash directory by commanding:
#           rm -rf ~/.Trash/* ~/.Trash/.*
#
#   The script will not choke on a nonexistent file. It outputs the final
#   disposition of each filename argument: does not exist, was already in trash,
#   or was moved to trash.
#
# COPYRIGHT WAIVER:
#
#   The author dedicates this Bash script to the public domain by waiving all of
#   their rights to the work worldwide under copyright law, including all
#   related and neighboring rights, to the extent allowed by law. You can copy,
#   modify, distribute, and perform the script, even for commercial purposes,
#   all without asking for permission.

if [ -z "$XDG_DATA_HOME" ] ; then
    xdg_trash_directory=$(realpath ~/.local/share/Trash/)
else
    xdg_trash_directory=$(realpath $XDG_DATA_HOME/Trash/)
fi

gio_command_exists=0
if $(command -v gio > /dev/null 2>&1) ; then
    gio_command_exists=1
fi

host_implements_trash_specification=0
if [[ -d "${xdg_trash_directory}" ]] && (( gio_command_exists == 1 )) ; then
    # Executing on a host that implements the trash specification.
    host_implements_trash_specification=1
    trash_directory="${xdg_trash_directory}"
else
    # Executing on other host, so attempt to use a custom trash directory.
    trash_directory=$(realpath ~/.Trash)
    if [[ -e "${trash_directory}" ]] ; then
        # It exists.
        if [[ ! -d "${trash_directory}" ]] ; then
            # But is not a directory, so abort.
            echo "Error: ${trash_directory} exists, but is not a directory."
            exit 1
        fi
    else
        # It does not exists, so create it.
        mkdir "${trash_directory}"
        echo "Created directory ${trash_directory}"
    fi
fi

# Deal with all filenames (a concept that covers names of both files and
# directories) given as arguments.
for file in "$@" ; do
    file_to_be_trashed=$(realpath -- "${file}")
    file_basename=$(basename -- "${file_to_be_trashed}")
    if [[ ! -e ${file_to_be_trashed} ]] ; then
        echo "does not exist:   ${file_to_be_trashed}"
    elif [[ "${file_to_be_trashed}" == "${trash_directory}"* ]] ; then
        echo "already in trash: ${file_to_be_trashed}"
    else
        # ${file_to_be_trashed} exists and is not yet in the trash directory,
        # so move it there.
        if (( host_implements_trash_specification == 1 )) ; then
            gio trash "${file_to_be_trashed}"
        else
            # Move the file to the custom trash directory, with a new name that
            # appends a millisecond-resolution timestamp to the original.
            head="${trash_directory}/${file_basename}"_TRASHED_ON_
            move_file_to="${head}$(date '+%Y-%m-%d_AT_%H-%M-%S.%3N')"
            while [[ -e "${move_file_to}" ]] ; do
                # Generate a new name with a new timestamp, as the previously
                # generated one denoted an existing file or directory. It's very
                # unlikely that this loop needs to be executed even once.
                move_file_to="${head}$(date '+%Y-%m-%d_AT_%H-%M-%S.%3N')"
            done
            # There is no file or directory named ${move_file_to}, so
            # we can use it as the move target.
            /bin/mv "${file_to_be_trashed}" "${move_file_to}"
        fi
        echo "moved to trash:   ${file_to_be_trashed}"
    fi
done

Responder3

Lixo-clié um aplicativo Linux que pode ser instalado usando apt-get no Ubuntu ou yum no Fedora. Usar o comando trash listOfFilesmoverá o especificado para a lixeira.

Responder4

Comece definindo uma move_to_trashfunção:

move_to_trash () {
    mv "$@" ~/.trash
}

Então alias rmpara isso:

alias rm='move_to_trash'

Você sempre pode chamar old rmescapando com uma barra invertida, assim: \rm.

Não sei como esvaziar o diretório da lixeira na reinicialização (dependendo do seu sistema, pode ser necessário examinar os rc*scripts), mas também pode valer a pena criar uma crontarefa que esvazie o diretório periodicamente.

informação relacionada