Script Nautilus (menu de contexto) para renomear rapidamente um arquivo usando $ RANDOM - mas como?

Question

Eu quero adicionar uma entrada do menu de contexto para o nautilus com um script personalizado, mas eu realmente não sei como escrever isso (eu sou muito inexperiente com essas coisas).

Basicamente, quero renomear os arquivos selecionados com $RANDOM usando mv -n , mantendo o sufixo do arquivo. Alguém sabe como isso?

Eu sei que tenho que colocar em ~/.local/share/nautilus/scripts , com certeza!

Edit: Uau, eu estou (positivamente) sobrecarregado com suas sugestões, todos eles funcionam muito bem! Obrigado Feldspar, David & amp; pa4080!

    

Answer 1

Aqui está um script que fiz:

#!/bin/bash

# FileRNG.sh by feldspar15523
# Feel free to edit this as much as you want.

IFS=$'\n'
for i in $NAUTILUS_SCRIPT_SELECTED_FILE_PATHS
do
    nameInput="$(basename -- "$i")"
    extension="${nameInput#*.}"
    filePath="$i"

    case "$(basename -- "$nameInput")" in
    *.* )
        mv -nT -- "$filePath" "$PWD/$RANDOM.$extension"
        ;;
    * )
        mv -nT -- "$filePath" "$PWD/$RANDOM"
        ;;
    esac
done

Este é um script totalmente funcional que você pode usar. Ele respeita extensões, mesmo que não tenha uma. Funciona com vários arquivos. Certifique-se de permitir que seja executado com chmod +x FileRNG.sh

    

Answer 2

O Nautilus fornece caminhos selecionados para scripts como argumentos do programa. O script a seguir renomeará os caminhos fornecidos como argumentos do programa para arquivos aleatórios (preservando a extensão do arquivo) e informará o usuário sobre o resultado via Zenity (ou na linha de comando sem o X):

#!/bin/sh
set -eu

for source; do
    case "$source" in
        */*) dir="${source%/*}";;
        *) dir=.;;
    esac

    basename="${source##*/}"
    case "$basename" in
        ?*.*) extension=".${basename##*.}"; basename="${basename%.*}";;
        *) extension=;;
    esac

    message_type=info
    destination="$(exec mktemp --tmpdir="$dir" --suffix="$extension" XXXXXXXXXX 2>&1)" ||
        { rv=$?; message="$destination"; false; } &&
    message="$(exec mv -vT -- "$source" "$destination" 2>&1)" ||
        { rv="${rv-$?}"; message_type=error; }

    if [ -n "${DISPLAY-}" ]; then
        zenity "--$message_type" --no-markup --title="${0##*/}" --text="$message"
    else
        printf '%s: %s: %s\n' "${0##*/}" "$message_type" "$message" >&2
    fi

    [ -z "${rv-}" ] || exit "$rv"
done

Ele usa mktemp em vez de $RANDOM para selecionar o caminho de destino porque

1. mktemp garante que o arquivo de destino não existe e
2. porque funciona com shells Bourne compatíveis com POSIX que não suportam as extensões especiais $RANDOM e sem problemas de Bash.

Assim, os nomes aleatórios não são numéricos, mas consistem em uma sequência de 8 caracteres alfanuméricos aleatórios. Se você realmente quiser usar $RANDOM , posso criar uma variante com base nele.

    

Answer 3

Esta é minha sugestão, cuja versão atual usa os 10 primeiros caracteres aplicáveis do suprimento infinito de caracteres pseudo-aleatórios em /dev/urandom . Esse comportamento pode ser modificado pela edição da linha 21 e 22.

• A versão anterior, que usa apenas $RANDOM , está disponível no histórico .

• O script pode manipular arquivos e diretórios únicos e múltiplos selecionados.

• Quando o item é um arquivo, há três opções:

  • file.ext → $RANDOM
  • file.ext → $RANDOM.ext
  • file.ext → file-$RANDOM.ext

• Quando o item é um diretório, as opções acima são reduzidas para 2:

  • dir → $RANDOM
  • dir → dir-$RANDOM

• O script usa zenity para solicitar as preferências do usuário, de acordo com as opções acima. Além disso, se o item for um diretório, haverá uma pergunta adicional com tempo limite de 5 segundos.

#!/bin/bash -e

IFS_BAK=$IFS
IFS=$'\t\n'
FILE_LIST=($NAUTILUS_SCRIPT_SELECTED_FILE_PATHS)
IFS=$IFS_BAK

opt1="file.ext → $RANDOM | dir → $RANDOM"
opt2="file.ext → $RANDOM.ext | dir → $RANDOM"
opt3="file.ext → file-$RANDOM.ext | dir → dir-$RANDOM"

OPT=$(zenity --list  --width=400 --height=170 \
             --text "Random file and directory renamer: ${#FILE_LIST[@]} item(s) are selected." \
             --radiolist --column "Pick" \
             --column "File opinions | Dir opinions" FANSE "$opt1" TRUE "$opt2" FALSE "$opt3")

if [ "$OPT" == "0" ]; then exit 1; fi

for item in "${FILE_LIST[@]}"; do

        URANDOM=$(cat /dev/urandom | tr -dc '0-9a-zA-Z!@$%_+-' | head -c 10)
        #URANDOM=$RANDOM

        if [ -f "$item" ]; then

                DIR="$(dirname "${item}")"
                FILE_NAME="$(basename "${item}")"
                EXT="${FILE_NAME##*.}"
                NAME="${FILE_NAME%.*}"

                if [ "$EXT" == "$NAME" ]; then EXT=""; else EXT=".$EXT"; fi

                if   [ "$OPT" == "$opt1" ]; then mv "$item" "$DIR/$URANDOM"
                elif [ "$OPT" == "$opt2" ]; then mv "$item" "$DIR/$URANDOM$EXT"
                elif [ "$OPT" == "$opt3" ]; then mv "$item" "$DIR/$NAME-$URANDOM$EXT"
                else zenity --info --text "Something went wrong!"
                fi

        elif [ -d "$item" ]; then

                DIR=$(dirname "${item}")
                DIR_NAME=$(basename "${item}")

                Q='$(zenity --question --timeout 5 \
                            --text "The selected item \{ $DIR_NAME \} is a directory. \nHow to proceed\?" \
                            --cancel-label="Don't rename" --ok-label="Rename") && echo "Rename" || echo "Leave"' #zenity --info --text "$Q"

                if [ "$Q" == "Rename" ]; then
                        if   [ "$OPT" == "$opt1" ]; then mv "$item" "$DIR/$URANDOM"
                        elif [ "$OPT" == "$opt2" ]; then mv "$item" "$DIR/$URANDOM"
                        elif [ "$OPT" == "$opt3" ]; then mv "$item" "$DIR/$DIR_NAME-$URANDOM"
                        else zenity --info --text "Something went wrong!"
                        fi
                fi
        else
                zenity --info --text "Something went wrong!"
        fi
done

Aqui está a demonstração:

Referências:

• Bash: Gerando uma sequência de LETRAS aleatória
• Bash: gerar uma sequência alfanumérica aleatória