Git repos have lots of write protected files in the .git
directory, sometimes hundreds, and the default rm my_project_managed_by_git
will prompt before deleting each write protected file. So, to actually delete my project I have to do rm -rf my_project_managed_by_git
.
Using rm -rf
scares me. Is there a reasonable way to delete git repos without it?
Using rm -rf scares me. Is there a reasonable way to delete git repos without it?
I don’t know what to tell you, that’s the command you need to use.
If you’re that worried you’re going to nuke important stuff, make backups, and don’t use
sudo
for user files.So… you’re afraid of the command that does the thing you’re trying to do?
More like, I’m afraid of the command doing more than I’m trying to do.
What I want to do is ignore prompts about write-protected files in the
.git
directory, what it does is ignore all prompts for all files.You just need to do this then
cd git-project rm -rf .git cd .. rm -r git-project
With
rm
-r is for ®ecursion and -f is for F(force) disabled the prompting. So, use -f on the .git directory which has the files you want to obliterate, and leave it off for the safety prompts.so why not
rm -rf folder/.git/*
thenrm -r folder/*
Maybe they’re afraid of accidentally writing
rm -rf folder/.git /*
or somethingThat’s a good example. If I’m regularly running a command that is a single whitespace character away from disaster, that’s a problem.
Imagine a fighter aircraft that had an eject button on the side of the flight stick. The pilot complains “I’m afraid I might accidentally hit the eject button when I don’t need to”, but everyone responds “why would you push the eject button if you don’t want to eject?”, or “so your concern is that the eject button will cause you to eject…?” – That’s how I feel right now.
I understand the mindset you have, but trust me, you’ll learn (sooner or later) a habit to pause and check your command before hitting enter. For some it takes a bit longer and it’ll bite you in the butt for few times (so have backups), but everyone has gone down that path and everyone has fixed their mistakes now and then. If you want hard (and fast) way to learn to confirm your commands, use dd a lot ;)
One way to make it a bit less scary is to ‘mv <thing you want removed> /tmp’ and when you confirmed that nothing extra got removed you can ‘cd /tmp; rm -rf <thing>’, but that still includes the ‘rm -rf’ part.
What about adding the flags last?
rm deletethisrepo -rf
chmod -R
the directory first?This, lol just remove write protection if -f is too spooky
Maybe use a graphical file manager?
Or move the folder to /tmp or so.
Or a tui file manager like
ncdu
That’s a good suggestion for some, but I’m quite comfortable with the command line.
It’s not that I’m irrationally scared of
rm -rf
. I know what that command will do. If I slow down an pay attention it’s not as though I’m worried “I hope this doesn’t break my system”.What I really mean is I see myself becoming quite comfortable typing
rm -rf
and running it with little thought, I use it often to delete git repos, and my frequent use and level of comfort with this command doesn’t match the level of danger it brings.Just moving them to
/tmp
is a nice suggestion that can work on anywhere without special programs or scripts.You don’t sound like you’re comfortable with the command line.
Just checked my command history and I’ve run 60,000 commands on this computer without problem (and I have other computers). I guess people have different ideas of what “comfortable” means, but I think I consider myself comfortable with the command line.
I have shot myself in the foot with
rm -rf
in the past though, and screwed up my computer so bad the easiest solution was to reinstall the OS from scratch. My important files are backed up, including most of my dotfiles, but being a bit too quick to type and run arm -rf
command has caused me needless hours of work in the past.I realized the main reason I have to use
rm -rf
is to remove git repos and so I thought I’d ask if anyone has a tip to avoid it. And I’ve found some good suggestions among the least upvoted comments.
If you’re making backups of things you care about and not running
sudo rm -rf
the command isn’t really dangerous.But +1 for having it in /tmp I have a bash function I call tempd that is basically
cd $(mktemp -d)
I use it so much for stuff I dont really care to keep.Never heard of mktemp before, that’s need. Come to think of it I never thought about how /tmp is really used by the system in the first place, time to do do studying I guess
A tip I saw some time ago is to do:
rm folder -rf
Additionally you could move the git folder to the trash folder. I think it’s usually located at $HOME/.local/share/trash/files/
Then you can delete it from the trash once you’re certain you got the right folder
Additionally you could move the git folder to the trash folder. I think it’s usually located at $HOME/.local/share/trash/files/
Moving something to the trash files folder isn’t the correct way to trash it, since the Trash specification requires storing some metadata for each trash item.
You should use eg.
trash-cli
instead.xdg-trash
Cd into the directory first, then run rm -rf, then cd back out and rm -r just the directory.
E:fb
The problem is that
rm -rf
shouldn’t scare you?What are the chances something like
~/projects/some-project $ cd .. ~/projects $ rm -fr some-project
may delete unexpected stuff? (especially if you get into the habit of tab-completing the directory argument)
https://github.com/nivekuil/rip This is what you’re looking for
If you’re scared to do
rm -rf
, do something else that lets you inspect the entire batch of deletions first. Such as:find .git ! -type d -print0 | xargs -0 -n1 echo rm -fv
This will print out all the
rm -fv
commands that would be run. It’s basicallyrm -rf --dry-run
, butrm
doesn’t have that common option. Once you’ve verified that that’s what you want to do, run it again withoutecho
to do the actual deletion. If you’re scared of having that in your history, either use a full path for .git, or prepend a space to the non-echo version of the command to make it avoid showing up in your shell history (assuming you have ignorespace in your HISTCONTROL env var)I use this
xargs echo
pattern a lot when I’m crafting commands that are potentially destructive or change lots of things.If you’re that worried, why not run chmod -R u+w .git inside the project dir to “un write-protect” the files, then just ascend to the directory containing the project dir (cd …) and use rm -r without -f?
The force flag (-f) is the scary one, I presume?
OSX - mv my_project ~/.Trash
chmod -R 777 my_project_managed_by_git && rm -r my_project_managed_by_git
git rebase doesn’t work?