Je fais beaucoup de travail en terminal et j'ai aujourd'hui l'expérience de la dactylographie

rm fileInQuestion.txt

Avant de découvrir que j'avais réellement besoin de fileInQuestion.txt. Si j'avais effacé l'interface graphique, je l'aurais simplement extraite de la corbeille. J'aimerais savoir s'il est possible de surcharger "rm" dans le terminal de manière à ce qu'il envoie le ou les fichiers dans la corbeille lors de leur sortie.

Je ne conseillerais pas aliasing rmà mvque vous pourriez prendre l'habitude de rmne pas supprimer définitivement des fichiers, puis rencontrer des problèmes sur d' autres ordinateurs ou sous d' autres comptes utilisateur quand il ne supprime définitivement.

J'ai écrit un ensemble de bashscripts qui ajoutent plus de Mac OS outils de ligne de commande X-like (en plus d'un certain nombre de ceux intégrés comme open, pbcopy, pbpaste, etc.), le plus important trash. Ma version de trashva faire tout ce que le pseudonyme rmne permet pas (et, espérons-le, rien de mauvais, mais je l'utilise sur mon propre Mac depuis quelques années maintenant sans perte de données), notamment: renommer le fichier comme le fait le Finder si un fichier portant le même nom existe déjà, placez les fichiers dans le dossier Corbeille approprié sur les volumes externes; il a aussi quelques subtilités supplémentaires, comme par exemple: il essaie d'utiliser AppleScript lorsqu'il est disponible afin que vous obteniez le bon son de corbeille, etc. (mais ne l'exige pas, vous pouvez toujours l'utiliser via SSH quand aucun utilisateur n'est connecté), vous donner la taille de la corbeille à travers tous les volumes.

Vous pouvez récupérer ma suite tools-osx sur mon site ou la dernière et meilleure version du référentiel GitHub .

Il existe également une trashcommande développée par Ali Rantakari , mais je ne l’ai pas testée moi-même.

L’ outil de ligne de commande de la corbeille peut être installé via brew install trash.

Il vous permet de restaurer des fichiers supprimés via une ligne de commande ou le Finder.

J'ai un exécutable appelé remquelque part dans le mon $PATHavec le contenu suivant:

EDIT: le code ci-dessous est une version révisée et améliorée en collaboration avec 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

Il se comporte exactement de la même manière que la suppression du Finder. (Voir l'article du blog ici .)

J'ai trouvé un joli code qui peut être ajouté à la fin du profil de traitement par lot de l'utilisateur et qui permet rmde déplacer les fichiers dans la corbeille à chaque exécution.

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
}

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

Utilisez la commande de terminal osascript, l'interpréteur AppleScript.

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

Ceci dit à AppleScript de dire au Finder d’envoyer le fichier à la corbeille.

PWD est nécessaire pour les chemins de fichiers relatifs, car AppleScript ne le gère pas bien.

une approche moderne en utilisant rapide

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

Bien qu'il soit possible de rmdéplacer des fichiers vers la Corbeille au lieu de les supprimer, il est toutefois déconseillé de placer l'état d'esprit du filet de sécurité des interfaces utilisateur graphiques dans le shell UNIX. Il existe de nombreuses façons d’endommager sérieusement le terminal. Le meilleur conseil à mon humble avis est simplement de réfléchir à deux fois avant de frapper la enterclé dans une fenêtre shell.

Si vous souhaitez vous rmrappeler que vous êtes sur le point de supprimer un fichier, utilisez l’alias suivant (pour /bin/bashinsérer cette ligne .bashrcdans votre répertoire personnel):

alias rm "rm -i"

Cela fera la rmdemande confirmation avant d'essayer de supprimer chaque fichier.

Si vous avez TimeMachine en cours d'exécution (j'espère bien!), Vous pouvez toujours obtenir votre fichier à partir de la sauvegarde. De cette façon, vous pouvez perdre au plus une heure de travail. Ce qui est déjà assez grave, bien sûr. Alors réfléchis encore avant d'appuyer sur cette entertouche!

Homebrew permet d' installer deux utilitaires :

1. poubelle

   Il s'agit d'un petit programme en ligne de commande pour OS X qui déplace des fichiers ou des dossiers dans la corbeille. L'USP de cette commande permet de restaurer facilement les fichiers. Une commande pour supprimer des fichiers / dossiers est inutile si vous ne pouvez pas restaurer des fichiers / dossiers après les avoir supprimés. Sur le site de la commande:

Par défaut, la corbeille demande au Finder de déplacer les fichiers / dossiers spécifiés vers la corbeille au lieu d'appeler l'API système à cette fin, en raison de la fonctionnalité "remettre en place" qui fonctionne uniquement lors de la suppression de fichiers via le Finder.

-F

Demandez au Finder de déplacer les fichiers dans la corbeille au lieu d'utiliser l'API du système. C'est plus lent, mais il utilise l'interface utilisateur du Finder (par exemple, les sons) et garantit le fonctionnement de la fonction "remettre en place".

-l

Liste des éléments actuellement dans la corbeille. Si cet argument est utilisé, aucun fichier ne doit être spécifié.

-e

Vider la poubelle. La corbeille demande une confirmation avant d'exécuter cette action. Si cet argument est utilisé, aucun fichier ne doit être spécifié.

Pour installer, trashexécutez ce qui suit dans Terminal:

brew install trash.

2. rmtrash

   Un outil de ligne de commande qui déplace les fichiers dans la corbeille. Depuis la page de manuel de la commande:

Cette commande déplace les fichiers dans la corbeille plutôt que de les supprimer totalement du système de fichiers. Très utile si vous décidez que vous voulez ce fichier après tout ...

-u USERNAME

un argument optionnel. Cela déplacera le fichier dans la corbeille de l'utilisateur spécifié. Notez que vous avez besoin de privilèges suffisants pour accomplir cela.

Pour installer, rmtrashexécutez ce qui suit dans Terminal:

brew install rmtrash.

Voici une solution simple et triviale à ajouter à votre profil bash. Notez que cela écrasera déjà quelque chose du même nom dans la corbeille.

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

Usage:

• ~/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 $$$

Trashing correctement (afin qu'il soit définitivement récupérable) est plus délicat que simplement un mvà ~/.Trash.

osx-trash est peut-être ce que vous cherchez. ( Caveat emptor - Je ne l'ai pas essayé et je ne peux pas en garantir le degré de sécurité.)

Consultez trash-cli. Il fonctionne sur plusieurs plates-formes, ne produit aucun son de poubelle et prend en charge la récupération.

Vous pouvez l'installer avec (nécessite Node.js ) :

$ npm install --global trash-cli

Si vous ne souhaitez pas utiliser Node.js, vous pouvez également installer le binaire natif osx-trashmanuellement.

Dans votre .bashrc (ou partout où vous gardez les paramètres de votre shell), essayez d’ajouter un alias modifiant le comportement de rm pour déplacer des éléments vers ~ / .Trash, comme dans:

alias rm='move/to/.Trash'

Cet alias est loin d'être trivial à mettre en œuvre (du moins pour moi), car l'utilisation de mv (le candidat idéal à utiliser pour ce travail) est

mv file where

donc, avoir un alias qui place la partie 'où' devant le fichier à déplacer peut être assez sommaire. J'examinerai peut-être un conseil plus substantiel.

EDIT: J'ai juste essayé d'ajouter ce qui suit à mon .bashrc, et ça marche:

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

C'est beaucoup plus primitif que d'autres suggestions, mais vous évitez d'installer de nouvelles choses.

J'ai simplement mis ce 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

dans ~/bin/trash, fait le excutable chmod +x ~/bin/trash, et a ajouté la ligne suivante à~/.bash_profile

PATH=$PATH:$HOME/bin

Ensuite, on peut l'utiliser comme

$ trash broken.js olddir cleanup.*

Une simple fonction pourrait vous permettre de supprimer des fichiers en les déplaçant vers le dossier .Trash de l'utilisateur:

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