root/cobra/trunk/Samples/FindWords.cobra

"""
FindWords
  by Caligari
  with mods by Chuck

This tool can be used to find which files in a directory tree contain any
of a list of words.

The list of words to search for is provided by default in a file called
"wordlist.txt" (located in the same directory as the executable) with one
regular expression per line.

A list of filename extensions to ignore can also be provided, if needed.
That list has one extension per line (not including the "."), and is
not a regular expression.

A description of further options is available using the "-help" command-line argument.

Comments in the code explain the use of regular expressions.
"""

use System.Text.RegularExpressions


class FindWords

    var wordsFilename = ''
    var ignoreFilename = ''
    var searchDirectory = ''
    var onlyNames as bool
    var showLines as bool
    var words = SortedDictionary<of String, Regex>()
    var ignoreExtensions = List<of String>()
    var startDir as DirectoryInfo?
    var listFile as FileInfo?

    
    def main
        .wordsFilename = Path.combine(Path.getDirectoryName(CobraCore.exePath), "wordlist.txt")
        .ignoreFilename = ""
        .searchDirectory = Path.getFullPath(".")
        .onlyNames = false
        .showLines = true

        .processCommandLine
        .readRegExList
        .readExtToIgnore
        
        .listFile = FileInfo(.wordsFilename)
        .startDir = DirectoryInfo(.searchDirectory)
        
        .checkDirectory(.startDir to !)
        
        print "\nDone."


    def showSyntax
        appName = CobraCore.commandLineArgs[0]
        if appName.lastIndexOf(Path.directorySeparatorChar) > 0
            appName = appName[appName.lastIndexOf(Path.directorySeparatorChar)+1:]
        if appName.lastIndexOf(".") > 0
            appName = appName[:appName.lastIndexOf(".")]
        print "Syntax:\n[appName] \[searchDirectory\] \[-l|list listFilename\] \[-i|ignore ingorelistFilename\] \[-n|-names] \[-s|-summary] \[-h|-help]"
        print "  -l|list file    filename of the list of words to search for"
        print "  -i|ignore file  filename of an optional list of extensions for files to ignore"
        print "  -n|names        only check file and directory names"
        print "  -s|summary      only show files, not lines within files"
        print "  -h|help         show this help text"       
        CobraCore.exit(0)


    def processCommandLine
        args = CobraCore.commandLineArgs

        listArgs    = ["-l", "-list"]
        ignoreArgs  = ["-i", "-ignore"]
        nameArgs    = ["-n", "-name", "-names"]
        summaryArgs = ["-s", "-summary"]
        helpArgs    = ["-h", "-help"]
        allArgs     = listArgs.concated(ignoreArgs).concated(nameArgs).concated(summaryArgs).concated(helpArgs)
        
        lookingForIgnore = false
        lookingForList = false
        foundDir = false
        argError = false
        
        if args.count > 1
            for arg in args[1:]
                if arg in allArgs and lookingForList
                    print "unable to determine filename for list of words, expected '-l filename'"
                    lookingForList = false
                    argError = true
                if arg in allArgs and lookingForIgnore
                    print "unable to determine filename for list of ignore extensions, expected '-i filename'"
                    lookingForIgnore = false
                    argError = true
                
                if arg in helpArgs
                    .showSyntax
                else if arg in nameArgs
                    .onlyNames = true
                else if arg in summaryArgs
                    .showLines = false
                else if arg in ignoreArgs
                    lookingForIgnore = true
                else if arg in listArgs
                    lookingForList = true
                else if arg[0] == "-"
                    print "unrecognized argument [arg]"
                    argError = true
                else
                    if lookingForIgnore
                        .ignoreFilename = arg.toString
                        lookingForIgnore = false
                    else if lookingForList
                        .wordsFilename = arg.toString
                        lookingForList = false                      
                    else if not foundDir  # must be the directory to look in
                        .searchDirectory = arg.toString
                        foundDir = true
                    else  # already found directory
                        print "more than one directory provied on commandline, expected 'directory'"
                        argError = true

        if argError
            print
            .showSyntax


    def readRegExList       
        try
            using wordsFile = StreamReader(.wordsFilename)

                wordLine = wordsFile.readLine
                
                while wordLine
                    # We can tell if there is a word on a line using an
                    # inline regular expression:
                    #   Regex.match(textToSearch, regularExpression)
                    # The textToSearch can be a hard-coded string,
                    # but most often it will be a String.
                    # The regularExpression is a string (hard-coded
                    # or not) that follows the regular expression
                    # syntax.
                    wordMatch = Regex.match(wordLine, r".+")
                    
                    # The return from a match() call is a Match class
                    # object. The success property tells us whether the
                    # search located what we were looking for.
                    # The toString method gives us the resulting subString.
                    if wordMatch.success
                        # We can create a Regex object which can later be
                        # used to execute a search with a given regular
                        # expression. In this case we are setting two
                        # options (ignoring case in the search we are
                        # creating, and pre-compiling the search, as we
                        # may be using it many times).
                        # Note that here we are saving the resulting
                        # Regex object to a Dictionary for later use.
                        # We could just as easily save the string itself,
                        # but this way we only pay the Regex creation cost
                        # once, rather than every time we carry out the
                        # search.
                        .words[wordMatch.toString] = Regex(wordMatch.toString, RegexOptions(Compiled, IgnoreCase))
                        
                    wordLine = wordsFile.readLine
        catch ioe as IOException
            .reportError(.wordsFilename, ioe)
            return
        print "\nFound [.words.count] search words.\n"


    def readExtToIgnore
        # optionally find extensions to ignore
        if .ignoreFilename.length > 0
            try
                using ignoreFile = StreamReader(.ignoreFilename)
                    ignoreLine = ignoreFile.readLine                    
                    while ignoreLine
                        if ignoreLine.length > 0
                            .ignoreExtensions.add("." + ignoreLine.trim)
                        ignoreLine = ignoreFile.readLine
            catch ioe as IOException
                .reportError(.ignoreFilename, ioe)
                return
            print "\nFound [.ignoreExtensions.count] ignored extenstions.\n"


    def checkDirectory(curDir as DirectoryInfo)
        if not curDir.exists
            print "Unable to find search directory [curDir.fullName]"
            return
        
        # print "Checking [curDir.fullName]..."
        
        foundWords = List<of String>()

        for word, wordMatch in .words
            # check directory name
            # Here we use a regular expression match
            # to determine whether the directory names have
            # any of the words we are looking for.
            # Each directory name is passed to the match
            # method call made on each of the Regex objects
            # in the dictionary we created earlier.
            dirNameCheck = wordMatch.match(curDir.name) 

            if dirNameCheck.success
                foundWords.add(word) 
                
        if foundWords.count
            print "[curDir.fullName]: directory name may have [foundWords]"
                        
        # check files
            
        for subFile in curDir.getFiles
            # Note that here we check if the file we are about
            # to look at has a name which matches our list of words
            # or an extension we are ignoring. Neither of these
            # tests use regular expressions, although we could
            # use the same scheme for the ignore extensions, if
            # we wanted to support regular expressions there as well.
            if subFile.fullName == .listFile.fullName or subFile.extension in .ignoreExtensions
                continue
            .checkFile(subFile, curDir)

        for subDir in curDir.getDirectories
            .checkDirectory(subDir)


    def checkFile(curFile as FileInfo, curDir as DirectoryInfo)
        if not curFile.exists
            print "Unable to find file [curFile.fullName]"
            return
            
        # check filename
        foundWords = List<of String>()

        for word, wordMatch in .words
            # Here we use a regular expression match
            # to determine whether the filename has
            # any of the words we are looking for.
            # The name is passed to the match method
            # call made on each of the Regex objects
            # in the dictionary we created earlier.
            fileNameCheck = wordMatch.match(curFile.name) 

            if fileNameCheck.success
                foundWords.add(word) 
                
        if foundWords.count
            print "[curFile.fullName]: file name may have [foundWords]"
            
        if .onlyNames
            return
            
        # check contents
        try
            openFile = StreamReader(curFile.fullName)
        catch ioe as IOException
            .reportError(curFile.fullName, ioe)
            return
        
        if .showLines
            try
                lineNum, curLine = 1, openFile.readLine
                while curLine
                    foundWords = List<of String>()
    
                    for word, wordMatch in .words
                        # Finally, we use a regular expression match
                        # on the contents of each file for each
                        # of the words we want to find. We do this
                        # check for each line in the file, so that
                        # we can report the findings by line, if we
                        # want to do so.
                        curLineCheck = wordMatch.match(curLine)
    
                        if curLineCheck.success
                            foundWords.add(word) 
    
                    if foundWords.count
                        print "[curFile.fullName]([lineNum]) has [foundWords]"
    
                    curLine = openFile.readLine
                    lineNum += 1
            catch ioe as IOException
                .reportError(curFile.fullName, ioe)
                return
        else  # not show lines
            # When we don't need to report each line in a file
            # we read the entire contents into a "line" and
            # run the same regular expression match on it.
            try
                curLine = openFile.readToEnd
            catch ioe as IOException
                .reportError(curFile.fullName, ioe)
                return
            foundWords = List<of String>()
            for word, wordMatch in .words
                curLineCheck = wordMatch.match(curLine)
                if curLineCheck.success
                    foundWords.add(word) 
            if foundWords.count
                print "[curFile.fullName] has [foundWords]"

        openFile.close


    def reportError(fileName, exc as Exception)
        print 'Error reading "[fileName]":'
        print exc.message
        print 'Run with -h for options.'