No recomendaría crear un alias rm, mvya que podría tener el hábito de rmno eliminar archivos de forma permanente y luego tener problemas en otras computadoras o en otras cuentas de usuario cuando se elimine de forma permanente.

Escribí un conjunto de secuencias de bashcomandos que agregan más herramientas de línea de comandos similares a Mac OS X (además de varias de las integradas como open, pbcopy, pbpaste, etc.), lo más importante trash. Mi versión de trashhará todas las cosas correctas que el alias rmno hará (y espero que nada malo, pero lo he estado usando en mis propias Mac durante algunos años sin perder datos), incluido: 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 sutilezas añadidas, como: intenta usar AppleScript cuando está disponible para obtener el agradable sonido de 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 le dará el tamaño de la papelera en todos los volúmenes.

Puede obtener mi suite tools-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 basura se puede instalar a través brew install trashde o port install trash.

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

Tengo un ejecutable llamado remen algún lugar de mi $PATHcon el siguiente contenido:

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 desde el Finder. (Ver entrada de blog aquí .)

Utilice 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 archivo relativas, ya que AppleScript no lo maneja bien.

un enfoque moderno usando 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)
}

Encontré un código bastante bueno que se puede agregar al final del perfil de lote del usuario y hace rmque los archivos se muevan 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

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. La USP de este comando es 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 forma predeterminada, la papelera le pide a Finder que mueva los archivos/carpetas especificados a la papelera en lugar de llamar a la API del sistema para hacerlo debido a la función "devolver" que solo funciona cuando se envían archivos a la papelera a través de Finder.

-F

Pídale a Finder que mueva los archivos a la papelera, en lugar de usar la API del sistema. Esto es más lento, pero utiliza la interfaz de usuario de Finder (por ejemplo, sonidos) y garantiza que la función "retroceder" funcione.

-l

Enumere los elementos que se encuentran actualmente en la papelera. Si se utiliza este argumento, no es necesario especificar ningún archivo.

-mi

Vacíe la basura. trash pide confirmación antes de ejecutar esta acción. Si se utiliza este argumento, no es necesario especificar ningún archivo.

Para instalar trash, ejecute lo siguiente en la Terminal:

brew install trash.

2. basura

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

Este comando mueve los archivos a la papelera en lugar de eliminarlos por completo 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 suficientes privilegios para lograr esto.

Para instalar rmtrash, ejecute lo siguiente en la Terminal:

brew install rmtrash.

Aquí hay una solución de una línea bastante trivial para agregar a su perfil bash. Tenga en cuenta que 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 $$$

Esta es una mejora de las respuestas dadas por Antony Smith y cde .

El problema de incrustar un nombre de archivo en una cadena que se pasa a osascripttravés -ees que, en los sistemas modernos similares a Unix, los nombres de archivo pueden contener comillas, en el sentido de que partes del nombre de archivo podrían ejecutarse como AppleScript.

Una forma más segura de hacer esto es leer el nombre del archivo desde una variable de entorno:

trash() (
    : "${1:?}"
    case $1 in
        (/*) FNAME="$1" ;;
        (*)  FNAME="$(pwd)/$1"
    esac
    export FNAME
    exec osascript <<-EOF >/dev/null
        set fName to system attribute "FNAME"
        tell application "Finder" to delete my (POSIX file fName)
    EOF
)

Si agrega esta función a su .bashrco .zshrc, puede llamar trashdesde la línea de comando. EDITAR: aunque convertir esto en una función que sea realmente útil requiere más trabajo, por supuesto.

Si bien es posible rmmover archivos a la Papelera en lugar de eliminarlos, desaconsejaría 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 utilizando el terminal. El mejor consejo en mi humilde opinión es simplemente pensar dos veces antes de presionar la entertecla en una ventana de shell.

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

alias rm "rm -i"

Esto hará que se rmconfirme la solicitud antes de intentar eliminar cada archivo.

Si tiene TimeMachine ejecutándose (¡eso espero!), 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 piénsalo de nuevo antes de presionar esa entertecla!

Desechar correctamente las cosas (para que sea definitivamente recuperable) es más complicado que simplemente un mvarchivo ~/.Trash.

osx-trash podría ser lo que estás buscando. ( Advertencia emptor : no lo he probado y no puedo garantizar qué tan seguro es).

Echa un trash-clivistazo Funciona multiplataforma, sin sonido basura y es compatible con Put Back.

Puede instalarlo con (requiere Node.js ) :

$ npm install --global trash-cli

Como alternativa, 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 de implementar (al menos para mí), porque el uso de mv (el principal candidato para usar en este trabajo) es

mv file where

por lo tanto, tener un alias que coloque la parte "dónde" delante del archivo que se va a mover puede 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

in ~/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 eliminar archivos moviéndolos a la carpeta .Trash del usuario:

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