Hago mucho trabajo terminal, y hoy tuve la experiencia de escribir

rm fileInQuestion.txt

Antes de descubrir que realmente necesitaba fileInQuestion.txt. Si hubiera eliminado en la GUI, lo habría sacado de la Papelera. Me gustaría saber si es posible sobrecargar 'rm' en la Terminal de tal manera que envíe el archivo / archivos a la Papelera al salir.

No aconsejaría aliasing rma mvcomo se podría conseguir en el hábito de rmarchivos no borrar de forma permanente y que tenga problemas en otros equipos o bajo otras cuentas de usuario cuando no desaparezca permanentemente.

Escribí un conjunto de bashsecuencias de comandos que añadir más herramientas de línea de comandos X-como Mac OS (además de un número de los que ya vienen implementadas como open, pbcopy, pbpaste, etc.), lo más importante trash. Mi versión de trashhará todas las cosas correctas que el aliasing rmno hará (y espero que nada malo, pero lo he estado usando en mis propias Mac durante algunos años sin ninguna pérdida de datos), incluyendo: cambiar el nombre del archivo como lo hace Finder si ya existe un archivo con el mismo nombre, colocar los archivos en la carpeta Papelera correcta en volúmenes externos; también tiene algunas ventajas adicionales, como: intenta usar AppleScript cuando está disponible para que obtenga el agradable sonido de la basura y demás (pero no lo requiere, por lo que aún puede usarlo a través de SSH cuando ningún usuario ha iniciado sesión), puede darle el tamaño de la basura en todos los volúmenes.

Puede obtener mi suite de herramientas-osx de mi sitio o la última y mejor versión del repositorio de GitHub .

También hay un trashcomando desarrollado por Ali Rantakari , pero no lo he probado yo mismo.

La herramienta de línea de comandos de la papelera se puede instalar a través de brew install trash.

Le permite restaurar archivos basura a través de la línea de comandos o el Finder.

Tengo un ejecutable llamado remen algún lugar de mi $PATHcon los siguientes contenidos:

EDITAR: el código a continuación es una versión revisada y mejorada en colaboración con 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

Se comporta exactamente de la misma manera que eliminar del Finder. (Vea la publicación del blog aquí ).

Encontré un código bastante bueno que se puede agregar al final del perfil de lote del usuario y hace rmque mueva los archivos a la papelera cada vez que se ejecuta.

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
}

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

Use el comando de terminal osascript, el intérprete de AppleScript.

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

Esto le dice a AppleScript que le diga a Finder que envíe el archivo a la papelera.

Se necesita PWD para rutas de archivos relativas, ya que AppleScript no se maneja tan bien.

Un enfoque moderno con Swift

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)
}

Si bien es posible rmmover los archivos a la Papelera en lugar de eliminarlos, aconsejaría no llevar la mentalidad de la red de seguridad de las interfaces gráficas de usuario al shell de UNIX. Hay muchas formas de causar daños graves con el terminal. El mejor consejo en mi humilde opinión es pensarlo dos veces antes de enterpresionar la tecla en una ventana de shell.

Si desea rmrecordarle que está a punto de eliminar un archivo, considere usar el siguiente alias (para /bin/bashponer esta línea .bashrcen su directorio de inicio):

alias rm "rm -i"

Esto rmconfirmará la solicitud antes de intentar eliminar cada archivo.

Si tiene TimeMachine ejecutándose (¡espero que sí!) Siempre puede obtener su archivo de la copia de seguridad. De esta manera, puede perder como máximo una hora de trabajo. Lo cual es bastante malo, por supuesto. ¡Así que piense de nuevo antes de presionar esa entertecla!

Hay dos utilidades instalables a través de Homebrew que pueden lograr esto:

1. basura

   Este es un pequeño programa de línea de comandos para OS X que mueve archivos o carpetas a la papelera. El USP de este comando es el que permite restaurar fácilmente los archivos. Un comando para eliminar archivos / carpetas no sirve de nada si no puede restaurar archivos / carpetas después de eliminarlos. Desde el sitio web del comando:

De manera predeterminada, la papelera le pide al Finder que mueva los archivos / carpetas especificados a la papelera en lugar de llamar a la API del sistema para hacer esto debido a la función "volver a colocar" que solo funciona al mover los archivos a través del Finder.

-F

Solicite al Finder que mueva los archivos a la papelera, en lugar de utilizar la API del sistema. Esto es más lento, pero utiliza la interfaz de usuario de Finder (p. Ej., Sonidos) y garantiza que la función "volver a colocar" funcione.

-l

Lista de elementos actualmente en la basura. Si se utiliza este argumento, no es necesario especificar archivos.

-mi

Vaciar la basura. Trash solicita confirmación antes de ejecutar esta acción. Si se utiliza este argumento, no es necesario especificar archivos.

Para instalar, trashejecute lo siguiente en la Terminal:

brew install trash.

2. rmtrash

   Una herramienta de línea de comando que mueve archivos a la papelera. Desde la página del comando man:

Este comando mueve los archivos a la papelera en lugar de eliminarlos totalmente del sistema de archivos. Muy útil si decides que quieres ese archivo después de todo ...

-u NOMBRE DE USUARIO

Un argumento opcional. Esto moverá el archivo a la papelera del usuario especificado. Tenga en cuenta que necesita privilegios suficientes para lograr esto.

Para instalar, rmtrashejecute lo siguiente en la Terminal:

brew install rmtrash.

Aquí hay una solución de una línea bastante trivial para agregar a su perfil de bash. Tenga en cuenta que ya sobrescribirá algo con el mismo nombre en la papelera.

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 $$$

Destrozar cosas adecuadamente (para que sea definitivamente recuperable) es más complicado que simplemente un mvto to ~/.Trash.

osx-trash puede ser lo que estás buscando. ( Advertencia : no lo he probado y no puedo garantizar lo seguro que es).

Echa un vistazo trash-cli. Funciona multiplataforma, sin sonido de basura y admite Put Back.

Puede instalarlo con (requiere Node.js ) :

$ npm install --global trash-cli

Alternativamente, si no desea utilizar Node.js, puede instalar el binario nativo osx-trashmanualmente.

En su .bashrc (o donde sea que guarde los parámetros para su shell), intente agregar un alias que cambie el comportamiento de rm para mover cosas a ~ / .Trash, como en:

alias rm='move/to/.Trash'

Sin embargo, este alias está lejos de ser trivial para implementar (al menos para mí), porque el uso de mv (el principal candidato para usar para este trabajo) es

mv file where

Por lo tanto, tener un alias que ponga la parte 'dónde' delante del archivo a mover podría ser bastante incompleto. Lo investigaré y podría obtener consejos más sustanciales.

EDITAR: acabo de intentar agregar lo siguiente a mi .bashrc, y funciona:

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

Es mucho más primitivo que otras sugerencias, pero evita instalar cosas nuevas.

Simplemente he puesto este 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

en ~/bin/trash, lo hizo ejecutable chmod +x ~/bin/trashy agregó la siguiente línea a~/.bash_profile

PATH=$PATH:$HOME/bin

Entonces uno puede usarlo como

$ trash broken.js olddir cleanup.*

Una función simple podría permitirle tirar basura a los archivos moviéndolos a la carpeta .Trash del usuario:

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