LFCS Phase 1 Part 26: Removing Files and Directories with rm and rmdir

# Create test directory
mkdir ~/rm-practice
cd ~/rm-practice

# Create files
touch file1.txt file2.txt file3.txt file4.txt file5.txt

# Verify creation
ls -l

# Delete first file
rm file1.txt

# Verify deletion
ls -l    # Should show only 4 files

# Delete another
rm file2.txt

# Verify
ls -l    # Should show only 3 files

# Delete remaining files
rm file3.txt file4.txt file5.txt

# Verify all gone
ls -l    # Should be empty

cd ~/rm-practice

# Create files
touch file{1..10}.txt

# Verify
ls

# Use interactive mode
rm -i file*.txt

# When prompted:
# file1.txt? n
# file2.txt? y
# file3.txt? n
# file4.txt? y
# file5.txt? n
# file6.txt? y
# file7.txt? n
# file8.txt? y
# file9.txt? n
# file10.txt? y

# Verify only odd-numbered files remain
ls
# Should show: file1.txt file3.txt file5.txt file7.txt file9.txt

cd ~/rm-practice

# Create 100 files
touch file{1..100}.txt

# Count them
ls | wc -l    # Should show 100

# Delete first 10
rm file{1..10}.txt

# Verify
ls | wc -l    # Should show 90

# Delete 11-50
rm file{11..50}.txt

# Verify
ls | wc -l    # Should show 50

# Delete remaining
rm file{51..100}.txt

# Verify all gone
ls | wc -l    # Should show 0

cd ~/rm-practice

# Create mixed files
touch report.txt data.txt notes.txt
touch image.jpg photo.jpg
touch script.sh backup.sh

# TEST pattern first - what would *.txt match?
ls *.txt
# Output: data.txt  notes.txt  report.txt

# Looks good - now delete
rm *.txt

# Verify only .txt files were deleted
ls
# Should show: backup.sh  image.jpg  photo.jpg  script.sh

# TEST next pattern
ls *.jpg
# Output: image.jpg  photo.jpg

# Delete images
rm *.jpg

# Verify
ls
# Should show: backup.sh  script.sh

# Clean up remaining
rm *.sh

cd ~/rm-practice

# Create files
touch log{1..5}.log

# Delete with verbose output
rm -v log*.log

# Expected output:
# removed 'log1.log'
# removed 'log2.log'
# removed 'log3.log'
# removed 'log4.log'
# removed 'log5.log'

# Verify
ls *.log 2>/dev/null || echo "All log files deleted"

# Create more files
touch error.log access.log debug.log

# Combine verbose with pattern
rm -v *.log

# See each deletion confirmed

cd ~/rm-practice

# Create directory with files
mkdir testdir
touch testdir/file{1..3}.txt

# Try to delete with basic rm
rm testdir
# Error: rm: cannot remove 'testdir': Is a directory

# Why? rm without -r cannot delete directories

# Verify directory still exists
ls -ld testdir

# Also fails on empty directory
mkdir emptydir
rm emptydir
# Error: rm: cannot remove 'emptydir': Is a directory

# rmdir works for empty directories
rmdir emptydir

# Verify
ls -ld emptydir 2>/dev/null || echo "Empty directory removed"

# For directories with content, need -r
rm -r testdir

# Verify
ls -ld testdir 2>/dev/null || echo "Directory and contents removed"

cd ~/rm-practice

# Create nested structure
mkdir -p project/src/main
mkdir -p project/src/test
mkdir -p project/docs
touch project/README.md
touch project/src/main/app.py
touch project/src/test/test_app.py
touch project/docs/guide.md

# Verify structure
tree project/    # or: ls -R project/

# Delete entire tree
rm -r project/

# Verify deletion
ls -ld project 2>/dev/null || echo "Entire project directory deleted"

# Alternative: verbose recursive deletion
mkdir -p data/{logs,cache,temp}
touch data/logs/app.log
touch data/cache/data.cache
touch data/temp/session.tmp

rm -rv data/
# Shows each file and directory being removed

# Verify
ls -ld data 2>/dev/null || echo "Data directory tree deleted"

cd ~/rm-practice

# Create empty directory
mkdir empty1

# Remove with rmdir (works)
rmdir empty1

# Verify
ls -ld empty1 2>/dev/null || echo "Empty directory removed"

# Create directory with content
mkdir notempty
touch notempty/file.txt

# Try rmdir (fails safely)
rmdir notempty
# Error: rmdir: failed to remove 'notempty': Directory not empty

# This failure is GOOD - prevents accidental data loss!

# To remove, must delete contents first
rm notempty/file.txt
rmdir notempty

# Verify
ls -ld notempty 2>/dev/null || echo "Now successfully removed"

# Test with nested empty directories
mkdir -p level1/level2/level3

# Remove with -p flag
rmdir -p level1/level2/level3

# Verify all levels removed
ls -ld level1 2>/dev/null || echo "All empty levels removed"

cd ~/rm-practice

# Create file
touch protected.txt
echo "important data" > protected.txt

# Make it write-protected
chmod 444 protected.txt

# Verify permissions
ls -l protected.txt
# -r--r--r--. 1 user user ... protected.txt

# Try normal rm (prompts because write-protected)
rm protected.txt
# rm: remove write-protected regular file 'protected.txt'? n

# File still exists
ls protected.txt

# Use force mode
rm -f protected.txt

# Verify deletion
ls protected.txt 2>/dev/null || echo "Write-protected file deleted with -f"

# Create multiple write-protected files
touch readonly{1..5}.txt
chmod 444 readonly*.txt

# Force delete all without prompts
rm -f readonly*.txt

# Verify
ls readonly*.txt 2>/dev/null || echo "All write-protected files deleted"

cd ~/rm-practice

# Create test structure
mkdir -p oldproject/{src,docs,tests}
touch oldproject/README.md
touch oldproject/src/main.py
touch oldproject/docs/guide.md
touch oldproject/tests/test.py

# Delete with interactive + recursive + verbose
rm -riv oldproject/

# You'll see each prompt:
# rm: descend into directory 'oldproject/'? y
# rm: descend into directory 'oldproject/src'? y
# rm: remove regular file 'oldproject/src/main.py'? y
# ... (confirms each file)
# removed 'oldproject/src/main.py'
# removed directory 'oldproject/src'
# ...

# This combination provides:
# -r: Can delete directories
# -i: Prompts for safety
# -v: Shows what's deleted

cd ~/rm-practice

# Create mixed files
touch report-2024-01.txt report-2024-02.txt report-2024-03.txt
touch data-2024-01.csv data-2024-02.csv
touch summary-2024.pdf

# Test pattern - delete only January files
ls *-2024-01.*
# report-2024-01.txt  data-2024-01.csv

# Delete January files
rm -v *-2024-01.*
# removed 'report-2024-01.txt'
# removed 'data-2024-01.csv'

# Verify February files still exist
ls *-2024-02.*
# report-2024-02.txt  data-2024-02.csv

# Delete all .txt files
rm -v *.txt

# Verify only .csv and .pdf remain
ls
# data-2024-02.csv  summary-2024.pdf

cd ~/rm-practice

# Create test files
touch file1.txt file2.txt file3.log

# DANGER: Space before extension
# Don't run this: rm * .txt
# This would delete ALL files (*), then look for a file named ".txt"

# CORRECT: No space
rm *.txt    # Only deletes .txt files

# Verify .log still exists
ls
# file3.log

# DANGER: Accidental deletion of parent directory contents
# Don't run: rm -rf .*
# This matches . and .. and could delete parent directory!

# SAFER: Be specific about dotfiles
touch .hidden1 .hidden2

# Instead of: rm .*
# Use: rm .hidden*
rm .hidden*

# Or list first to verify
ls -a .hidden* 2>/dev/null || echo "Hidden files deleted safely"

# Clean up
rm *.log

cd ~/rm-practice

# Create files with different timestamps
touch old1.log old2.log
sleep 2
touch recent1.log recent2.log

# Mark old files as 10 days old
touch -d "10 days ago" old1.log old2.log

# Verify ages
ls -lt *.log

# Find files older than 7 days
find . -name "*.log" -mtime +7

# Delete files older than 7 days
find . -name "*.log" -mtime +7 -delete

# Verify only recent files remain
ls *.log
# recent1.log  recent2.log

# Alternative: use exec with rm
touch old{1..5}.txt
touch -d "30 days ago" old*.txt
find . -name "old*.txt" -mtime +7 -exec rm -v {} \;

# Verify
ls old*.txt 2>/dev/null || echo "Old files deleted"

cd ~/rm-practice

# Create files
touch backup{1..20}.bak

# Generate list of files to delete
ls *.bak > to_delete.txt

# Review the list
cat to_delete.txt

# Confirm this is what you want to delete
wc -l to_delete.txt    # Count how many

# Delete files from list
cat to_delete.txt | xargs rm -v

# Verify
ls *.bak 2>/dev/null || echo "All backup files deleted"

# Alternative: preview before deletion
touch temp{1..10}.tmp
find . -name "*.tmp" > delete_list.txt
cat delete_list.txt   # Review
cat delete_list.txt | xargs rm -v

# Clean up list file
rm delete_list.txt to_delete.txt

cd ~/rm-practice

# Create important file
echo "Critical data" > important.txt

# Make it immutable (requires sudo)
sudo chattr +i important.txt

# Try to delete
rm -f important.txt
# Error: rm: cannot remove 'important.txt': Operation not permitted

# Even with force!
sudo rm -f important.txt
# Error: rm: cannot remove 'important.txt': Operation not permitted

# Check attributes
lsattr important.txt
# ----i--------e----- important.txt

# To delete, must remove immutable flag first
sudo chattr -i important.txt

# Now can delete
rm important.txt

# Verify
ls important.txt 2>/dev/null || echo "File deleted after removing immutable flag"

cd ~/rm-practice

# Create trash directory
mkdir -p ~/.local/trash

# Create files to "delete"
touch delete_me.txt also_delete.txt

# Instead of rm, move to trash
mv delete_me.txt ~/.local/trash/

# File is "deleted" but recoverable
ls delete_me.txt 2>/dev/null && echo "Still here" || echo "Moved to trash"
ls ~/.local/trash/
# delete_me.txt

# Recover if needed
mv ~/.local/trash/delete_me.txt .
ls delete_me.txt
# delete_me.txt

# Create a trash function for reuse
trash() {
    mkdir -p ~/.local/trash
    mv "$@" ~/.local/trash/
    echo "Moved to trash: $@"
}

# Use the function
trash also_delete.txt

# Empty trash when ready
rm -rf ~/.local/trash/*

# Verify trash is empty
ls ~/.local/trash/

cd ~/rm-practice

# Create log directory
mkdir -p ~/deletion_logs

# Create function that logs deletions
logged_rm() {
    local logfile=~/deletion_logs/rm-$(date +%F).log
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Deleting: $@" >> "$logfile"
    ls -l "$@" >> "$logfile" 2>&1
    rm -v "$@" 2>&1 | tee -a "$logfile"
}

# Create test files
touch file{1..5}.txt

# Delete with logging
logged_rm file*.txt

# Check log
cat ~/deletion_logs/rm-$(date +%F).log

# Verify files deleted
ls file*.txt 2>/dev/null || echo "Files deleted and logged"

# Create more files
touch data{1..3}.csv
logged_rm data*.csv

# Review all deletion logs
cat ~/deletion_logs/rm-$(date +%F).log

cd ~/rm-practice

# Simulate project structure
mkdir -p project/{src,build,dist}
touch project/src/main.c project/src/util.c
touch project/build/main.o project/build/util.o
touch project/dist/app

# Show what would be cleaned
ls -R project/

# Clean build artifacts (compiled files)
rm -rv project/build/*.o

# Clean distribution
rm -rv project/dist/*

# Verify source files untouched
ls project/src/
# main.c  util.c

# Complete cleanup of build and dist
rm -rf project/build/ project/dist/

# Recreate empty dirs
mkdir -p project/{build,dist}

# Verify
ls -R project/
# Should show empty build and dist dirs

cd ~/rm-practice

# Create files of different sizes
echo "small" > small.txt
dd if=/dev/zero of=large.txt bs=1M count=10 2>/dev/null

# Check sizes
ls -lh *.txt

# Delete files larger than 1MB
find . -name "*.txt" -size +1M -exec rm -v {} \;

# Verify small.txt remains
ls *.txt
# small.txt

# Create more test files
touch empty.log
echo "data" > nonempty.log

# Delete only empty files
find . -name "*.log" -size 0 -delete

# Verify
ls *.log
# nonempty.log

# Clean up
rm *.txt *.log

cd ~/rm-practice

# Create important file
echo "IMPORTANT DATA" > critical.txt

# Set up trash directory
mkdir -p ~/.trash

# "Safe delete" by moving to trash
mv critical.txt ~/.trash/critical-$(date +%F-%H%M%S).txt

# Simulate accidental deletion
ls critical.txt 2>/dev/null && echo "Still here" || echo "Gone from current dir"

# Oh no! Need to recover
ls ~/.trash/

# Recover from trash
mv ~/.trash/critical-* ./recovered.txt

# Verify recovery
cat recovered.txt
# IMPORTANT DATA

# Now simulate REAL deletion (no recovery)
echo "This will be lost forever" > doomed.txt
rm doomed.txt

# Try to recover... impossible!
ls doomed.txt 2>/dev/null || echo "File permanently deleted - NO RECOVERY"

# Lesson learned: Only trash method provides recovery
# rm provides NO RECOVERY

# Clean up
rm recovered.txt
rm -rf ~/.trash/*