Eu faço muito trabalho terminal e hoje tive a experiência de digitar

rm fileInQuestion.txt

Antes de descobrir que eu realmente precisava do fileInQuestion.txt. Se eu tivesse excluído a GUI, teria tirado do lixo. Gostaria de saber se é possível sobrecarregar 'rm' no Terminal de forma que ele envie os arquivos para a Lixeira na saída.

Eu não aconselharia aliasing rmpara mvque você pode adquirir o hábito de rmarquivos não apagar de forma permanente e, em seguida, executar em problemas em outros computadores ou sob outras contas de usuário quando ele não excluir permanentemente.

Eu escrevi um conjunto de bashscripts que adicionar mais ferramentas X-like linha de comando do Mac OS (para além de uma série dos internos como open, pbcopy, pbpaste, etc.), o mais importante trash. Minha versão trashfará todas as coisas corretas que o aliasing rmnão fará (e espero que nada de ruim, mas eu as uso em meus próprios Macs há alguns anos sem dados perdidos), incluindo: renomear o arquivo como o Finder faz se um arquivo com o mesmo nome já existir, coloque os arquivos na pasta Lixeira correta em volumes externos; ele também possui algumas características adicionais, como: tenta usar o AppleScript quando disponível, para que você tenha um som agradável do lixo e tal (mas não o exige, para que você ainda possa usá-lo via SSH quando nenhum usuário estiver logado); dê a você o tamanho da lixeira em todos os volumes.

Você pode pegar meu pacote tools-osx do meu site ou a versão mais recente e melhor do repositório GitHub .

Há também um trashcomando desenvolvido por Ali Rantakari , mas eu mesmo não testei.

A ferramenta de linha de comando da lixeira pode ser instalada via brew install trash.

Ele permite restaurar arquivos lixeira através da linha de comando ou do Finder.

Eu tenho um executável chamado remem algum lugar no meu $PATHcom o seguinte conteúdo:

EDIT: o código abaixo é uma versão revisada e aprimorada em colaboração com Dave Abrahams :

#!/usr/bin/env python
import os
import sys
import subprocess

if len(sys.argv) > 1:
    files = []
    for arg in sys.argv[1:]:
        if os.path.exists(arg):
            p = os.path.abspath(arg).replace('\\', '\\\\').replace('"', '\\"')
            files.append('the POSIX file "' + p + '"')
        else:
            sys.stderr.write(
                "%s: %s: No such file or directory\n" % (sys.argv[0], arg))
    if len(files) > 0:
        cmd = ['osascript', '-e',
               'tell app "Finder" to move {' + ', '.join(files) + '} to trash']
        r = subprocess.call(cmd, stdout=open(os.devnull, 'w'))
        sys.exit(r if len(files) == len(sys.argv[1:]) else 1)
else:
    sys.stderr.write(
        'usage: %s file(s)\n'
        '       move file(s) to Trash\n' % os.path.basename(sys.argv[0]))
    sys.exit(64) # matches what rm does on my system

Ele se comporta exatamente da mesma maneira que a exclusão do Finder. (Veja a postagem do blog aqui .)

Eu encontrei um código bastante agradável que pode ser adicionado ao final do perfil lote do usuário e faz rmmover os arquivos para o lixo cada vez que é executado.

nano ~ / .bash_profile

#... append at the end
function rm () {
  local path
  for path in "$@"; do
    # ignore any arguments
    if [[ "$path" = -* ]]; then :
    else
      # remove trailing slash
      local mindtrailingslash=${path%/}
      # remove preceding directory path
      local dst=${mindtrailingslash##*/}
      # append the time if necessary
      while [ -e ~/.Trash/"$dst" ]; do
        dst="`expr "$dst" : '\(.*\)\.[^.]*'` `date +%H-%M-%S`.`expr "$dst" : '.*\.\([^.]*\)'`"
      done
      mv "$path" ~/.Trash/"$dst"
    fi
  done
}

fonte: http://hints.macworld.com/article.php?story=20080224175659423

Use o comando terminal osascript, o intérprete AppleScript.

osascript -e "tell application \"Finder\" to delete POSIX file \"${PWD}/${InputFile}\""

Isso informa ao AppleScript para solicitar ao Finder que envie o arquivo para a lixeira.

O PWD é necessário para caminhos de arquivo relativos, pois o AppleScript não lida bem com isso.

uma abordagem moderna usando rápida

https://github.com/reklis/recycle

//
// main.swift
// recycle
//
// usage: recycle <files or directories to throw out>
//

import Foundation
import AppKit

var args = NSProcessInfo.processInfo().arguments
args.removeAtIndex(0) // first item in list is the program itself

var w = NSWorkspace.sharedWorkspace()
var fm = NSFileManager.defaultManager()

for arg in args {
    let path = arg.stringByStandardizingPath;
    let file = path.lastPathComponent
    let source = path.stringByDeletingLastPathComponent

    w.performFileOperation(NSWorkspaceRecycleOperation,
        source:source,
        destination: "",
        files: [file],
        tag: nil)
}

Embora seja possível fazer rmmover arquivos para o Lixo em vez de removê-los, eu recomendaria não trazer a mentalidade da rede de segurança das interfaces gráficas do usuário para o shell UNIX. Existem várias maneiras de causar danos graves usando o terminal. O melhor conselho ao IMHO é simplesmente pensar duas vezes antes de pressionar a entertecla em uma janela do shell.

Se você quiser rmlembrá-lo de que está prestes a excluir um arquivo, considere usar o seguinte alias (para /bin/bashcolocar esta linha no .bashrcdiretório inicial):

alias rm "rm -i"

Isso fará a rmconfirmação da solicitação antes de tentar remover cada arquivo.

Se você tiver o TimeMachine em execução (espero que sim!), Você sempre poderá obter seu arquivo de backup. Dessa forma, você pode perder no máximo uma hora de trabalho. O que já é ruim o suficiente, é claro. Então pense novamente antes de pressionar essa entertecla!

Existem dois utilitários instaláveis ​​via Homebrew que podem fazer isso:

1. Lixo

   Este é um pequeno programa de linha de comando para o OS X que move arquivos ou pastas para a lixeira. A USP desse comando é que permite restaurar facilmente os arquivos. Um comando para lixeira de arquivos / pastas não será útil se você não puder restaurar arquivos / pastas após a lixeira. No site do comando:

Por padrão, a lixeira pede ao Finder que mova os arquivos / pastas especificados para a lixeira, em vez de chamar a API do sistema para fazer isso por causa do recurso "colocar de volta", que só funciona ao lixeira por meio do Finder.

-F

Peça ao Finder para mover os arquivos para a lixeira, em vez de usar a API do sistema. Isso é mais lento, mas utiliza a interface do usuário do Finder (por exemplo, sons) e garante que o recurso "adiar" funcione.

-eu

Listar itens atualmente no lixo. Se esse argumento for usado, nenhum arquivo precisará ser especificado.

-e

Esvazie a lixeira. lixo pede confirmação antes de executar esta ação. Se esse argumento for usado, nenhum arquivo precisará ser especificado.

Para instalar, trashexecute o seguinte no Terminal:

brew install trash.

2. rmtrash

   Uma ferramenta de linha de comando que move arquivos para a lixeira. Na página do manual do comando:

Este comando move os arquivos para a lixeira em vez de removê-los totalmente do sistema de arquivos. Muito útil se você decidir que deseja esse arquivo, afinal ...

-u USERNAME

um argumento opcional. Isso moverá o arquivo para a lixeira do usuário especificado. Observe que você precisa de privilégios suficientes para fazer isso.

Para instalar, rmtrashexecute o seguinte no Terminal:

brew install rmtrash.

Aqui está uma solução de uma linha bastante trivial para adicionar ao seu perfil do bash. Observe que ele já substituirá algo com o mesmo nome na lixeira.

trash() { mv -fv "$@" ~/.Trash/ ; }

Uso:

• ~/Desktop $$$ touch a b c
• ~/Desktop $$$ ls
a b c
• ~/Desktop $$$ trash a b c
a -> /Users/ryan.tuck/.Trash/a
b -> /Users/ryan.tuck/.Trash/b
c -> /Users/ryan.tuck/.Trash/c
• ~/Desktop $$$ ls
• ~/Desktop $$$

Corretamente destruindo coisas (de modo que é definitivamente recuperável) é mais complicado do que simplesmente um mvpara ~/.Trash.

osx-lixo pode ser o que você está procurando. ( Advertência - não tentei e não posso garantir a segurança.)

Confira trash-cli. Ele funciona em várias plataformas, sem som de lixo e suporta Put Back.

Você pode instalá-lo com (requer Node.js ) :

$ npm install --global trash-cli

Como alternativa, se você não quiser usar o Node.js, poderá instalar o binário nativo osx-trashmanualmente.

No seu .bashrc (ou onde quer que você mantenha os parâmetros do seu shell), tente adicionar um alias que mude o comportamento do rm para mover coisas para ~ / .Trash, como em:

alias rm='move/to/.Trash'

Esse alias se está longe de ser trivial de implementar (pelo menos para mim), porque o uso do mv (o principal candidato a ser usado para este trabalho) é

mv file where

portanto, ter um alias que coloca a parte 'where' na frente do arquivo a ser movido pode ser bastante superficial. Vou investigar e obter conselhos mais substanciais.

Edição: Eu apenas tentei adicionar o seguinte ao meu .bashrc, e ele funciona:

function trash { mv "$@" ~/.Trash ; }

É muito mais primitivo do que outras sugestões, mas você evita instalar coisas novas.

Eu simplesmente coloquei esse script

#!/bin/bash
application=$(basename "$0")
if [ "$#" == 0 ]; then
    echo "Usage: $application path [paths...]"
    exit 1
fi
trashdir="/Users/${USER}/.Trash"
while (( "$#" )); do
    if [ -e "$1" ]; then
        src=$(basename "$1")
        dst=$src
        while [ -e "$trashdir/$dst" ]; do
            dst=$src+`date +%H-%M-%S`
        done
        mv -f "$1" "$trashdir/$dst"
    else
        echo "$1" does not exist.
    fi
    shift
done

in ~/bin/trash, tornado permutável chmod +x ~/bin/trashe adicionou a seguinte linha ao~/.bash_profile

PATH=$PATH:$HOME/bin

Então pode-se usá-lo como

$ trash broken.js olddir cleanup.*

Uma função simples pode permitir que você lixeira arquivos, movendo-os para a pasta .Trash do usuário:

trash() {
   mv $1 ~/.Trash
}