#!/usr/bin/env python
import sys,os,getopt,glob,string,re,operator,fnmatch,time

################################## FUNCTIONS #################################################
def usage(name):    
    print """
    %s
    Mini File Renamer and Deleter v1.0.2 - Copyright 2008
    Author:	ghostdog74 
    
    %s
    usage: %s [-h] [-D dir] [-t f|d ][-[s|p] oldpat] [-e newpat ] [ -i pattern ][ -b patten ] [-d depth] [-Z|-v|-n|-r|-I] [-l] [files] 
    -D      Directory to start rename/delete. Use quotes for directories with spaces 
            If no directory is specified, current working directory is assumed
            Eg: Use -D c:\\test\\  (for Windows, end with trailing back slash)
    -h      Prints help page                
    -t      Type of files. Either files(f) or directories(d). Default is files, so can omit -t f
    -s      Sequence substitution. Specify pattern to be substituted. Must be specified with -e.
    -p      Pattern substitution. Must be specified with -e (pattern to change to)
            eg. 
                1) To change whole jpeg file name to upper case ==> -p ".*" -e "A-Z" "*.jpeg"
                2) To change the word "TEST" to lower case in jpeg file ==> -p "TEST" -e "a-z" "*.jpeg"
                3) To remove all numbers from directory name ==> -p "[0-9]+" -e '' -t d  -l "*" 
                4) To remove first character from file/directory ==>  -p "^." -e ''  -l "*.jpeg"  
                5) To remove special characters ==>   -p "[\"^']" -e "back" "*"       
                
    -e     * When used with -s, indicates ending sequence pattern. Can include alphanumberic. Must use ":" to specify range             
            Eg  
                1) -s "test" -e "01:10" will replace 'test' in files from '01' to '10'. If more than 1 files with 'test',
                    will go by sequence, ie '02' , '03' etc.
                2) -s "test" -e "###01:11@@@" will replace 'test' from '###01@@@' , followed by '###02@@@' and so on to ###11@@@            
           * When used with -p, indicates pattern to change to. 
           * When used with -c, specify -e "[A-Z]" to change to uppercase, -e "[a-z]" to change to lower case.
           
    -i	    Insert pattern to infront of file name.
    -b      Insert pattern to back of file name.
    -c      Remove characters in file name by position, position index start from 0. Always use -l to verify files to be changed.
            eg 
            1) -c 1 ==> remove 2nd character
            2) -c -1 ===> remove last character.
            3) -c -2: ===> remove from last 2nd character onwards.
            4) -c 3: ==> remove from 4th character onwards
            5) -c 4:10 ==> remove from 5th to 10th character
            6) -c :3 ==> remove from start to 3rd character.
            7) -c 1:3 -e "[A-Z]" ==> change positions specified to uppercase
                                    
    -l      List all files with pattern only. No renaming. Useful for verifying what will be changed.  
    -r      Used alone. Enable restoration of previous commands. eg %s -r            
    -n      Simple Numerical sort. Specify -n to turn numerical sorting on. Only works on files of the same structure.
    -d      # of directories down to do rename (default = 0). ie: Directory depth level
    -I      Case insensitive pattern search. eg  -p "rot" -e "" -I  -l "*.txt". Find rot,ROT,roT,RoT ..
    -v      Wildcard pattern reversal. eg -v "*.bat" : Files that doesn't end with .bat.
    -Z      Do deletion of files. 
            eg -d 4 -Z ".*01*"  -l -v  "*.txt" ==> delete all files that doesn't end with .txt and with the pattern "01" in the
                                                   file name, 4 levels deep into current directory
   [files]  List of files to be renamed/deleted. Can have wildcards. eg test*.txt
            To specify all files ==> "*". Will not work if not specified.
    """ % ("=" *100 , "=" * 100 ,name,name )
     

def pathChecker(path):
    ''' Function to determine correct path or file exists
        and then returns the number of count of the path separator
        as an indicator of the depth of the path.
    '''    
    if os.path.exists(path):
        pathcount=path.count(os.sep) 
        if pathcount > 1:           
            return int(pathcount) , path  , 0
        else:return 1,1,1
    else:
        return 0,0,-1

def combocheck(s,k):
    '''Function to check the options user keyed in against a set of bad options
        Input : s => bad options
                k => list of user supplied keys...eg -S -s -N..etc
    '''
    v = len(s); t = 0 ##store lenght of predefined bad options, t=0 to count matched bad ops
    for x in s:        
        if x in k:
            t = t + 1            
    ## if all bad options found            
    if v == t : return True
    else: return False


def doWalk(DIR=None,maxdepth=1,TYPE="f",ACTION="sub",patold=None,patnew=None,DEBUG=1,INVERSE=0,CASE=1,SORT=0,FileNamesArgs=None):
    ''' Traverse the directory specified until depth level,
        looking for files with the correct patterns and rename them
        accordingly
    '''
    GlobbedTypeList=[]
    AllFilesGlobbed=[]
  
    
    # convert into reg expression syntax in order to search. eg "*.txt" to ".*txt$"
    
    regex = fnmatch.translate(FileNamesArgs)
    reobj = re.compile(regex) 
    for ROOT,DIRECTORY,FILES in os.walk(DIR,True): 
        #do for files less or equal to maxdepth
        if ROOT.count(os.sep)  <= int(maxdepth):                        
            if FileNamesArgs is not None:     
                if INVERSE:            
                    for FI in os.listdir( ROOT ):
                        if not reobj.search(FI):
                            AllFilesGlobbed.append( os.path.join(ROOT,FI ))
                else:
                    try:
                        allfiles = glob.glob(os.path.join(ROOT,FileNamesArgs))
                    except Exception,e:
                        pass
                    else:
                        if allfiles:
                            for found in allfiles:    
                                if found not in AllFilesGlobbed:
                                    AllFilesGlobbed.append(found)
                            
    if TYPE=="d":                                         
        for dirname in AllFilesGlobbed:
            if os.path.isdir(dirname):
                if not dirname in GlobbedTypeList: 
                    GlobbedTypeList.append([dirname,dirname.count(os.sep)])
    else:
        for filenames in AllFilesGlobbed:
            if os.path.isfile(filenames):
                if not filenames in GlobbedTypeList:                    
                    GlobbedTypeList.append(filenames) 
        if SORT==1:
            GlobbedTypeList = sorted_copy(GlobbedTypeList)
        else:
            GlobbedTypeList=sorted(GlobbedTypeList, key=(operator.itemgetter(0)))
    # do various actions     
    doAction(GlobbedTypeList,TYPE,ACTION,patold,patnew,CASE,SORT,DEBUG)
                
        
       
def brake():
    raw_input("Enter")
     
def  clearscreen(rows):
    for i in range(rows): print 
        
def rename(FROM,TO="",DEBUG=1):       
    if FROM == TO:return
    if DEBUG==0  :        
        if TO :            
            try:
                os.rename(FROM,TO)
            except Exception,e:
                print "Error : ",e
            else:
                print FROM , " is renamed to ", TO
                # store to restore file. simple mechanism. Use pickle/shelve ??
                open(restorefile,"a").write("""%s,%s\n""" %( TO,FROM ))
        elif not TO :
            print "Deleting " ,FROM
            if os.path.isdir(FROM):
                try:
                    os.removedirs(FROM) #or use os.rmdir
                except Exception,e:
                    print "Error: ",e
            elif os.path.isfile(FROM):
                try :
                    os.remove(FROM)
                except Exception,e:
                    print "Error: ",e
              
    else:
        
        print "==>>>> ", "[" ,FROM ,"]==>[",TO,"]"

def changecase(patnew,thefile):
    # if -c and -e option and -e [A-Z] or -e [a-z]
    try:
        foundlowercase = re.findall( "\[a-z\]|a-z" , patnew)[0]                    
    except:
        try:
            founduppercase = re.findall( "\[A-Z\]|A-Z" , patnew)[0]
        except: notfound=1
        else:
            newname = thefile.replace(thefile,thefile.upper())
    else:
        newname = thefile.replace(thefile,thefile.lower())
    
        
def doAction(FILES,TYPE="d", ACTION="sub", patold="" ,patnew="", CASE=1, SORT=0,DEBUG=1):
    '''Function to do sequence substitution
        Input:  FILES => A list of globbed files to be processed.
                TYPE => f = files, d = directories
                patold => The pattern in the file to be substituted
                patnew => The new pattern to replace the old
                DEBUG => 1 : Do a listing only
                            0 : Do substitution, and renaming of files
    '''      
    
    notfound=0 #flag for doing case change.
    if TYPE=="d":
        # if renaming directories, rename from the last(highest) level. So have to sort according to maxdepth
        FILES=sorted(FILES, key=(operator.itemgetter(1)),reverse=True)

    if CASE == 0:
        patold_re = re.compile(patold,re.IGNORECASE)
    elif CASE:
        patold_re = re.compile(patold)
        
    if ACTION=="seq":         
        # see if in format 001:020 ...this indicates sequence
        patnew_re =re.compile("(\w*\d*\D*)(\d+)[:](\d+)(\D*\w*\d*)")
        seq = patnew_re.findall(patnew)[0]
        startseq=seq[1]; endseq=seq[-2]
        patendseqfront = seq[0]
        patendseqback = seq[-1]
        if endseq and int(endseq) < int(startseq) :
            startseq,endseq = endseq,startseq
        elif endseq and int(startseq) == int(endseq):
            endseq=startseq
        elif endseq =="": endseq=len(FILES)
        length_startseq = len(str(startseq))

    for fn in FILES:
        if TYPE=="d": FN=fn[0]
        elif TYPE=="f": FN=fn
        thepath , thefile = os.path.split(FN)            
        if ACTION=="insert":
            if patnew == "front":
                newname = patold+thefile
            elif patnew == "back":
                newname = thefile+patold
            rename(FN, os.path.join(thepath,newname),DEBUG )     
        elif ACTION=="char":
            # find <digit>:<digit>
            patdigit=re.compile("(-)*(\d*):(-)*(\d*)")
            b= list(thefile)
            if patnew and re.search( "\[a-z\]|a-z" , patnew) :
                caseflag=1
            elif patnew and re.search( "\[A-Z\]|A-Z" , patnew):
                caseflag=2
            else:caseflag=0
            
            # if single digit                
            if ":" not in patold and ( int(patold) < 0 or patold.isdigit() ) :
                if caseflag==1 :
                    b[int(patold)] = b[int(patold)].lower()
                elif caseflag==2:
                    b[int(patold)] = b[int(patold)].upper()
                else:
                    b.pop( int(patold) )
                newname = ''.join(b)               
            else:
                foundit = patdigit.findall(patold)[0]
                if foundit:
                    first = "".join(foundit[0:2])
                    second =  "".join(foundit[2:])
                    if first and not second:    
                    # if range is  eg 1:
                        if caseflag==1:                            
                            newname = thefile[0:int(first)]+thefile[int(first):].lower()
                        elif caseflag==2:
                            newname = thefile[0:int(first)]+thefile[int(first):].upper()
                        else:                      
                            newname = thefile[ : int(first) ]        
                    elif second and not first:  
                    # if range is eg :10
                        if caseflag==1:
                            newname = thefile[:int(second)].lower()+thefile[int(second):]
                        elif caseflag==2:
                            newname = thefile[:int(second)].upper()+thefile[ int(second) :]
                        else:
                            newname = thefile[ int(second) :]                        
                    elif first and second:    
                    # full range eg 4:10
                        if caseflag==1:
                            newname = thefile[0:int(first)]+thefile[int(first):int(second)].lower()+thefile[int(second):]
                        elif caseflag==2:
                            newname = thefile[0:int(first)]+thefile[int(first):int(second)].upper()+thefile[int(second):]
                        else:                          
                            for it in range(int(first),int(second)): b[it]="" # delete items to null
                            newname = ''.join(b)                        
            rename(FN, os.path.join(thepath,newname) ,DEBUG )
  
  
        elif patold_re.search(thefile)  : 
            if ACTION=="seq":    
                #string to replace.             
                repl= patendseqfront+str(startseq).zfill(length_startseq)+patendseqback
                newname = re.sub(patold,repl,thefile)    
                rename(FN, os.path.join(thepath,newname),DEBUG )      
                if int(startseq) == int(endseq):
                    print "\n==>Number of files less than ending sequence number...Exiting.."
                    break          
                #increment sequence
                startseq = int(startseq) + 1     
            elif ACTION=="sub":
                
                #changing case.  changing all filename to upper/lower case.
                try:
                    foundlowercase = re.findall( "\[a-z\]|a-z" , patnew)[0]                    
                except:
                    try:
                        founduppercase = re.findall( "\[A-Z\]|A-Z" , patnew)[0]
                    except: notfound=1
                    else:
                        newname = thefile.replace(thefile,thefile.upper())
                else:
                    newname = thefile.replace(thefile,thefile.lower())
                    
                if notfound:
                    newname = patold_re.sub(patnew,thefile) 
                rename(FN, os.path.join(thepath,newname),DEBUG ) 
            elif ACTION=="delete":
                rename(FN, None ,DEBUG )
                
# Taken from Python recipe                
def sorted_copy(alist):
    # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52234
    indices = map(_generate_index, alist)
    decorated = zip(indices, alist)
    decorated.sort()
    return [ item for index, item in decorated ]
    
def _generate_index(str):
    """
    Splits a string into alpha and numeric elements, which
    is used as an index for sorting"
    """
    #
    # the index is built progressively
    # using the _append function
    #
    index = []
    def _append(fragment, alist=index):
        if fragment.isdigit(): fragment = int(fragment)
        alist.append(fragment)

    # initialize loop
    prev_isdigit = str[0].isdigit()
    current_fragment = ''
    # group a string into digit and non-digit parts
    for char in str:
        curr_isdigit = char.isdigit()
        if curr_isdigit == prev_isdigit:
            current_fragment += char
        else:
            _append(current_fragment)
            current_fragment = char
            prev_isdigit = curr_isdigit
    _append(current_fragment)    
    return tuple(index)                

#--------------------------------------END Functions -------------------------#

## these are options not allowed
bad_options = [ ['-s','-p'],
                ['-Z','-p'],['-Z','-s'],['-Z','-c'],
                ['-c','-b'],['-c','-i'],['-c','-p'],['-c','-s'],
                #can add somemore...
              ]
                
################################## END FUNCTIONS ##################################################
    
if __name__ == '__main__':

    basename = os.path.basename(sys.argv[0])
    
    # create restore directory if doesn't exists
    restorepath = ".restore"
    if not os.path.exists(restorepath): os.mkdir(restorepath,777)    
    # design the restoration filename
    TIME=list(time.localtime())
    # get month and day into double digits string
    if len( str(TIME[1]) ) < 2: 
        TIME[1] = "0"+str(TIME[1])
    if len( str(TIME[2]) ) < 2:
        TIME[2] = "0"+str(TIME[2])
    TIME='-'.join(map(str,TIME))
    
    #name of the restore file
    restorefile  = os.path.join( restorepath , TIME+"-"+basename.split(".")[0])

    DEBUG=1
    INVERSE=0
    TYPE="f" #by default search files, not directories
    ACTION="sub"
    CASE=1 #case sensitive
    SORT=0 # alphabetical sort.
    
    try:
        opts, args = getopt.gnu_getopt (sys.argv[1:], "D:s:e:p:P:d:t:i:b:c:Z:lInvr")
        if args is None or len(args) <= 0: args = None
        else: 
            function =args[0]
            FileNames=args[-1]
    except Exception:
        
        usage(basename)
        sys.exit(1)
    if opts == []:
        usage(basename)
        sys.exit(1)

    options = dict(opts) ### convert to dict, easier to manipulate..i guess    
    keys = options.keys() ##get keys from options dictionary for checking

    if options.has_key('-h'):
        usage(basename)
        sys.exit()
           
    #restoration key       
    if options.has_key('-r'):            
        h={};rh={}
        print "These are a list of restore files: "
        for num,rfile in enumerate(os.listdir(restorepath)):
            num=num+1
            h[str(num)] = rfile
        h[str(num+1)]="Exit" #give the last choice
        while 1:       
            for k in sorted(h.keys()):
                print "%s) %s" % ( k,h[k])         
            choice = raw_input("Enter your choice( eg 0,1 ) to view: ")
            try :
                int (choice)
            except:
                print "Choose again"
            else:
                ofilename = h[choice]
                if ofilename == "Exit": sys.exit()
                print "0o0o0o0 ... opening %s ..... 0o0o0o0o "% ofilename
                for n,olines in enumerate(open( os.path.join(restorepath,ofilename))):
                    From,To=olines.strip().split(",")
                    n=n+1
                    rh[n] = [From,To]
                rh[n+1]=["All","Original"] 
                while 1:
                    for k in sorted(rh.keys()):
                        print "%s) Restore %s to-->>> %s" %( k,rh[k][0],rh[k][1])                         
                    restoreyesno = raw_input( "Continue to restore [y|n]?: ")
                    if restoreyesno in ["n","N"]: break
                    elif restoreyesno in ["y","Y"]: 
                        rchoice = raw_input("Enter choice to restore: ")
                        for n, olines in enumerate(open( os.path.join(restorepath,ofilename))):
                            From,To = olines.strip().split(",")
                            n=n+1
                            if "All" in rh[int(rchoice)] or "Original" in rh[int(rchoice)] :  
                                try:
                                    os.rename(From,To)
                                except Exception,e:
                                    print "Error restoring: ",e
                            
                            elif n==int(rchoice):
                                try:
                                    os.rename(From,To)
                                except Exception,e:
                                    print "Error restoring: ",e
        
    # directory key    
    if options.has_key('-D') and options['-D'] != []:
        depthcnt ,newpath, ret = pathChecker(options['-D'])    #check the root, whether exists   
        if ret == -1:
            print "%s does not exists. " % (options['-D'] )
            sys.exit(2)
        options['-D'] = newpath
    else :        
        # if not -D specified, take current directory
        depthcnt ,newpath, ret = pathChecker(os.getcwd())        
        options['-D'] = os.getcwd()      

    DIR=options['-D']
    

            
    # check bad options...
    for bad_ops in bad_options :        
        if combocheck( bad_ops, keys) :
            usage(basename)
            sys.exit(0)      
    
    # Check for maxdepth
    if options.has_key('-d'): 
        maxdepth = int(options['-d']) + depthcnt
    else: 
        maxdepth = depthcnt
    
    # check for list flag - debug mode , 0 for commit.
    if not options.has_key('-l'): DEBUG = 0 
    
    # check for inverse pattern search,similar to grep's -v
    if options.has_key('-v'): INVERSE = 1
    
    # check numerical sorting
    if options.has_key('-n'): SORT = 1
    
    #check file type, whether search file or directory    
    if options.has_key('-t'): 
        TYPE=options['-t']

    if options.has_key('-i')  :
        patold=options['-i']
        patnew="front"
        ACTION="insert"
        
    #insert at back of file name
    if options.has_key('-b')  :
        patold=options['-b']
        patnew="back"
        ACTION="insert"
                    
    if options.has_key('-c') and options.has_key('-e') :                    
        patold=options['-c']        
        patnew=options['-e']
        ACTION="char"
    elif options.has_key('-c') and not options.has_key('-e'):
        patold=options['-c']        
        patnew=""
        ACTION="char"        
                    
    if options.has_key('-s') and options.has_key('-e') : 
        patold=options['-s']
        patnew=options['-e']        
        if patnew == "" : usage(basename); sys.exit(1)
        ACTION="seq"
    elif options.has_key('-s') and not options.has_key('-e'):usage(basename) ;sys.exit()
        
    
    if options.has_key('-p') and options.has_key('-e') : 
        patold=options['-p'];patnew=options['-e']
    elif options.has_key('-p') and not options.has_key('-e'): usage(basename) ;sys.exit()
    
    if options.has_key('-v'):
        INVERSE=1
    
    # ignore case sensitivity
    if options.has_key('-I'): CASE=0
        
    if options.has_key('-Z'):          
        patold=options['-Z']
        if not patold : usage(basename);sys.exit(1)
        patnew=""
        ACTION="delete"
        
    # do the walking.
    try:
        doWalk(DIR,maxdepth,TYPE,ACTION,patold,patnew,DEBUG,INVERSE,CASE,SORT,FileNames)
    except:
        usage(basename)
        sys.exit()

#!/bin/bash

awk  'BEGIN{
    dictfile="english"
    l="abcdefghijklmnopqrstuvwxyz"
    while (1) {
        srand()
        lm=split(l,letters,"")
        if ( ( getline < dictfile) <= 0 ) {
            print "Dictionary file does not exists"
        }else {
            tries=10
            count=getlinecount(dictfile)
            num=int(rand() * count) +  1
            WORD=randomword(dictfile,num)
            gsub(/[[:blank:]]$|[[:space:]]|[0-9]+$/,"",WORD)
            WORD=tolower(WORD)
            m=split(WORD,word,"")
            for(i=1;i<=m;i++){ THEWORD[i] ="_" }
            for(j=1;j<=m;j++){ printf "%s",THEWORD[j] }
            print ""
            while(tries>0){
                flag=0
                printf "Choose a letter (Enter full word to complete): "
                printf "You have "tries" tries\n"
                for(o=1;o<=lm;o++){ printf letters[o] }
                print ""
                getline LETTER < "-"
                if ( LETTER==WORD || join(THEWORD,1,m,SUBSEP) == WORD ) {
                    print "congratulations! "
                    exit
                }
                system("clear")
                for( o=1;o<=m;o++) {
                    if ( word[o] == LETTER ) {
                        flag=1
                        THEWORD[o]=LETTER
                        for(i in letters){
                            if ( letters[i]==LETTER) { delete letters[i] }
                        }
                    }
                }
                if (flag==0){ tries-- }
                for(i=1;i<=m;i++){
                    printf THEWORD[i]
                }
                print ""
            }

            print "You hanged yourself!"
            print "The answer is "WORD
        }
    }
}
function getlinecount(file){
    count=0
    while ( ( getline < file ) > 0 ) count++
    close(file)
    return count
}
function randomword(file,linenumber){
    count=0
    while ( ( getline dictline< file) > 0 ) {
        count++
        if (  count == linenumber) {
            gsub(/[[:punct:]]/,"",dictline)
            gsub(/ +$/,"",dictline)
            m=split(dictline,toguess," ")
            if (m>1){
                num = int(rand() * m) +  1
                return toguess[num]
            }else {
                return dictline
            }
        }
    }
    close(file)
}
function join(array, start, end, sep,    result, i)
{
        if (sep == "")
                sep = " "
        else if (sep == SUBSEP) # magic value
                sep = ""
        result = array[start]
        for (i = start + 1; i <= end; i++)
                result = result sep array[i]
        return result

}
'

#!/bin/bash
## Change file names into uppper/lower case, or by position.
NO_ARGS=0 
E_OPTERROR=65
DEBUG=0
UPPER=0
FNAME="f"
maxdepth=1
directory=`pwd`
set -o noglob
#---- Functions ------------#

usage() {
 printf "Usage: `basename $0` [-D directory] [-M depth] [-U ] [-p pattern] [-c position ][-d] [-X] [filename(s)]\n"
 cat << EOF
        -D : starting directory. Default=current directory
        -M : max depth to recurse subdirectories (default=1), eg 1,2
        -U : Change all letters to upper case. Default: change to all lower case
        -c position : Change character at position to upper or lower (-U or -L)
        -p pattern: Change the word matched by pattern to upper/lower case
        -d : Debugging mode. Used to list all files to be changed, without changes taking effect
        -X : Only check directory names, not file names
        filename(s) : file names eg "*.txt". If omitted, default to all files. Use quotes.
        Example: 
        1) -U -p file "*.txt" ===> change all name of text files with pattern "file" to upper case.
        2) -U -c 10 "*.txt" ===> change the 10th character to upper case
        3) -c 2 "*FILE*" ===> change the 2nd character to lower case for all files with pattern "FILE" in file name.
EOF

}
#----------------------------#

if [ $# -eq "$NO_ARGS" ]  # Script invoked with no command-line args?
then
   usage
   exit $E_OPTERROR        # Exit and explain usage, if no argument(s) given.
fi  


while getopts ":D:s:e:M:p:c:dUX" Option
do
  case $Option in
    D     ) directory=$OPTARG
            ;;
    d     ) DEBUG=1 ;;
    U     ) UPPER=1;;
    c     ) position=$OPTARG
            case ${position} in
               0 | *[a-z]*) position=1;;      
            esac
            ;;
    p     ) pattern=$OPTARG
            [ -z "${pattern}" ] && pattern=".*"
            ;;
    M     ) maxdepth=$OPTARG
            case ${maxdepth} in
                0 | *[a-z]*|"") maxdepth=1;;   
            esac
            ;;
    X     ) FNAME="d";;
    *     ) echo "Unimplemented option chosen."
            exit;;
  esac
done
shift $(($OPTIND - 1))

# get last argument

argument=$#
if [ $argument -eq 0 ];then
    ext="*"
else    
    ext=$(eval echo \"\${${argument}}\")
fi


find "${directory}" -maxdepth "${maxdepth}" -type "${FNAME}" -name "$ext" -printf "%f:%h:%p\n" | \
awk -F":" -v pattern="${pattern}" -v debug="$DEBUG" -v upper=${UPPER} -v position="${position}" 'BEGIN{
    q="\042"
}
$1 ~ pattern{  
    if ( upper ) {
        
        if ( position>0 ) {
            #change only positional characters to upper
            newname = substr($1,1,position-1) toupper(substr($1,position,1)) substr($1,position+1)        
        }else if ( int(position)<0 ) {
            #change to upper from the back
            newname = substr($1,1,length($1)+position) toupper(substr($1,length($1)+position+1))            
        }else if ( !position  )  {
            # change all characters to upper            
            if (  pattern == ".*" ) {
                newname = toupper($1)
            }else {
                newname=$1
                gsub(pattern,toupper(pattern),newname)            
            }
        }
    }else if (!upper) { 
        if ( position>0 )  {
            # change only positional characters to lower
            newname = substr($1,1,position-1) tolower(substr($1,position,1)) substr($1,position+1)                
        }else if ( int(position)<0  ){
            #change to lower from the back
            newname = substr($1,1,length($1)+position) tolower(substr($1,length($1)+position+1))
        }else if (!position) {
            # change all characters to lower
            if (  pattern == ".*" ) {
                newname = tolower($1)
            }else {
                newname=$1
                gsub(pattern,tolower(pattern),newname)            
            }                
        }
    }
    if ( newname == $1 ) {next}    
    if ( debug) {
        print "mv -u " q $3 q " "q $2 "/" newname q        
    }else {
        cmd = "mv -u " q $3 q " "q $2 "/" newname q        
        system(cmd)
    }
    
}'

#!/bin/bash
## Change file names with a pattern substitution.
NO_ARGS=0 
E_OPTERROR=65
DEBUG=0
FNAME="f"
maxdepth=1
directory=`pwd`
set -o noglob

#---- Functions ------------#

usage() {
 printf "Usage: `basename $0` [-D directory] [-M depth] [-s pattern_from ] [-e pattern_to ] [-d] [-X] [filename(s)]\n"
 cat << 'EOF'
        -D : starting directory. Default=current directory
        -M : max depth to recurse subdirectories (default=1), eg 1,2
        -s : pattern to change from. Can be simple shell patterns. eg [0-9], [a-z], "pattern1|pattern2".
             To input special characters, eg "[\`&*]",'[`&*]'
        -e : pattern to change to. To rename to null, use "". eg -e ""
        -d : Debugging mode. Used to list all files to be changed, without changes taking effect
        -X : Only check directory names, not file names
        filename(s) : file names eg *.txt. If omitted, default to all files        
        Example: -s file -e test -d *.txt ===> change all name of text files 
                 with pattern "file" to "test". eg file_copy.txt will be changed to test_copy.txt
        
EOF

}
#----------------------------#

if [ $# -eq "$NO_ARGS" ]  # Script invoked with no command-line args?
then
   usage
   exit $E_OPTERROR        # Exit and explain usage, if no argument(s) given.
fi  


while getopts "D:s:e:M:Xd" Option
do
  case $Option in
    D     ) directory=$OPTARG
            ;;
    s     ) startseq=$OPTARG            
            [ -z "${startseq}" ] && echo "Pattern not specified. Use -s <pattern_from> and -e <pattern_to>" && exit    
            ;;
    e     ) endseq=$OPTARG
            [ -z "${endseq}" ] && endseq=""
            ;;    
    d     ) DEBUG=1 ;;
    X     ) FNAME="d";;
    M     ) maxdepth=$OPTARG
            case ${maxdepth} in
                0 | *[a-z]* |"") maxdepth=1;;   
            esac
            ;;
    *     ) echo "Unimplemented option chosen."
            exit;;
  esac
done
shift $(($OPTIND - 1))


# get last argument

argument=$#
if [ $argument -eq 0 ];then
    ext="*"
else    
    ext=$(eval echo \"\${${argument}}\")
fi



find "${directory}" -maxdepth ${maxdepth} -type "${FNAME}" -name "$ext" -printf "%f:%h:%p\n" | \
awk -F":" -v startseq="${startseq}" -v endseq="${endseq}" -v debug="$DEBUG" 'BEGIN{}
$1 ~ startseq{       
    original=$1
    sq="\047"
    q="\042"
    flag=0
    s = gsub (startseq, endseq,$1 )
    if ( startseg ~ /'"\'"'/) { sq="\042" }    
    if ( startseq ~ /[[:punct:]]/ ) { flag=1} #if found special characters/punctuation
    if ( debug) {
        if(flag) { print "mv -u " q $2"/" q sq original sq " "q $2 "/" $1 q  }
        else{   print "mv -u " q $3 q " "q $2 "/" $1 q        }
    }
    else {
         if(flag) { cmd= "mv -u " q $2"/" q sq original sq " "q $2 "/" $1 q }
         else{  cmd = "mv -u " q $3 q " "q $2 "/" $1 q }
         system(cmd)
    }
    
}'

#!/bin/bash
## Change file names into a sequence of numbers.
NO_ARGS=0 
E_OPTERROR=65
DEBUG=0
FNAME="f"
maxdepth=1
directory=`pwd`
set -o noglob

#---- Functions ------------#

usage() {
 printf "Usage: `basename $0` [-D directory] [-M depth]  [-s startseq] [-e endseq] [-p pattern] [-d] [-X] [filename(s)]\n"
 cat << EOF
        -D : starting directory. Default=current directory.
        -M : max depth to recurse subdirectories (default=1), eg 1,2
        -s : starting sequence, eg 1,01,001,0001
        -e : ending sequence, eg 7, 12,1001. No effect with leading zeroes. Can be used with a tag
             Eg -s 001 -e image20 -p "file" ==>  files will be named image001 to image020, replacing the word "file" in the filename
        -p : pattern to be substituted with the sequence. Can be simple shell patterns. eg [0-9], [a-z]
             Use ".*" to specify ALL files to be changed.
        -d : Debugging mode. Used to list all files to be changed, without changes taking effect
        -X : Only check directory names, not file names
        filename(s) : file names eg *.txt. If omitted, default to all files
        Example: 
            1) -s 1 -e 12 -p "file" -d *.txt ===> change all name of text files 
                 with pattern "file" with sequence starting from 1 till 12
            2) -s 001 -e 12 -p ".*"  ==> change ALL files to sequence 001 to 012
            3) -s 00001 -e "file.30" -p "file" "*.txt" =====> change all text files with word "file" to file.00001 to file.00030
            4) -s 01 -e "40.images" -p "file" "*.jpg" ====> change all jpg files with word "file" to "01.images" till "40.images"
        
EOF

}
#----------------------------#

if [ $# -eq "$NO_ARGS" ]  # Script invoked with no command-line args?
then
   usage
   exit $E_OPTERROR        # Exit and explain usage, if no argument(s) given.
fi  


while getopts ":D:s:e:p:M:Xd" Option
do
  case $Option in
    D     ) directory=$OPTARG
            ;;
    s     ) startseq=$OPTARG;;
    e     ) endseq=$OPTARG;;
    p     ) 
            pattern=$OPTARG
            [ -z "${pattern}" ] && pattern=".*"    
            ;;
    M     ) 
            maxdepth=$OPTARG            
            case ${maxdepth} in
                0 | *[a-z]*| "") maxdepth=1;; 
            esac    
            ;;
    d     ) DEBUG=1 ;;
    X     ) FNAME="d";;
    *     ) echo "Unimplemented option chosen."
            exit;;
  esac
done
shift $(($OPTIND - 1))

# get last argument

argument=$#
if [ $argument -eq 0 ];then
    ext="*"
else    
    ext=$(eval echo \"\${${argument}}\")
fi

find "${directory}" -maxdepth "${maxdepth}" -type "${FNAME}" -name "$ext" -printf "%f:%h:%p\n" | \
awk -F":" -v startseq="$startseq" -v endseq="$endseq" -v pattern="$pattern" -v debug="$DEBUG" 'BEGIN{
    q="\042"    
    match(endseq,"[0-9]") # get starting index of number 
    index_num=RSTART
    match(endseq,"[^0-9]") #get starting index of not number
    index_alpha=RSTART
    numendseq=endseq
    strendseq = endseq
    gsub(/[^0-9]+/,"",numendseq) #get number
    gsub(/[0-9]+/,"",strendseq) #get besides number
    endseq=numendseq
    lenseq = length(endseq)
    lenstseq = length(startseq)    
    # generate sequence
    for ( i = startseq+0 ; i<=endseq+0 ; i++ ){
        _="0"lenstseq 
        num[++d]=sprintf("%0*d" , _ ,i)
    }
}

$1 ~ pattern{    
    ++e 
    if ( index_alpha > index_num ) {        
        s = gsub (pattern, num[e] strendseq , $1 )    
    }else {
        s = gsub (pattern, strendseq num[e] , $1 )
    }
    if ( debug) {
        print "mv -u " q $3 q " "q $2 "/" $1 q        
    }else {
        cmd = "mv -u " q $3 q " "q $2 "/" $1 q
        system(cmd)
    }
    if ( d==e ) { exit }
    
}'