File Pattern Matching

/**
 * Find files according to a base directory and includes/excludes patterns.
 * Patterns conform to Ant's fileset pattern conventions.
 */
public class FileNameFinder implements IFileNameFinder {
    /** Find files using base directory and include pattern */
    public List<String> getFileNames(String basedir, String pattern);
    
    /** Find files using base directory, include pattern, and exclude pattern */
    public List<String> getFileNames(String basedir, String pattern, String excludesPattern);
    
    /** Find files using configuration map with named parameters */
    public List<String> getFileNames(Map args);
}

/**
 * Interface for file name finding functionality.
 */
public interface IFileNameFinder {
    /** Core file finding method with base directory and pattern */
    List<String> getFileNames(String basedir, String pattern);
    
    /** Extended file finding with exclude patterns */
    List<String> getFileNames(String basedir, String pattern, String excludesPattern);
    
    /** Flexible file finding with named parameters */
    List<String> getFileNames(Map args);
}

/**
 * Ant-integrated file scanner for pattern-based file discovery.
 * Provides iterator-style access to matched files.
 */
public class FileScanner {
    /** Set the base directory for scanning */
    public void setDir(File dir);
    
    /** Get the base directory */
    public File getDir();
    
    /** Set include patterns (comma or space separated) */
    public void setIncludes(String includes);
    
    /** Get include patterns */
    public String getIncludes();
    
    /** Set exclude patterns (comma or space separated) */
    public void setExcludes(String excludes);
    
    /** Get exclude patterns */
    public String getExcludes();
    
    /** Set whether to follow symbolic links */
    public void setFollowSymlinks(boolean followSymlinks);
    
    /** Check if following symbolic links */
    public boolean isFollowSymlinks();
    
    /** Set whether to use default excludes (like .svn, .git) */
    public void setDefaultexcludes(boolean useDefaultExcludes);
    
    /** Check if using default excludes */
    public boolean getDefaultexcludes();
    
    /** Add include pattern */
    public void addInclude(String pattern);
    
    /** Add exclude pattern */
    public void addExclude(String pattern);
    
    /** Get array of included files */
    public String[] getIncludedFiles();
    
    /** Get array of included directories */
    public String[] getIncludedDirectories();
    
    /** Scan directory and populate results */
    public void scan();
}

/**
 * Iterator for traversing files matched by scanning patterns.
 * Integrates with Java's Iterator pattern for easy file processing.
 */
public class FileIterator implements java.util.Iterator<File> {
    /** Check if more files are available */
    public boolean hasNext();
    
    /** Get the next file in the iteration */
    public File next();
    
    /** Remove current file (operation not supported) */
    public void remove() throws UnsupportedOperationException;
}

/**
 * Pattern matching syntax for file selection.
 */
public interface PatternSyntax {
    /** Single character wildcard - matches any single character except path separators */
    String SINGLE_CHAR = "?";
    
    /** Multi-character wildcard - matches zero or more characters except path separators */
    String MULTI_CHAR = "*";
    
    /** Directory wildcard - matches zero or more directories */
    String DIR_WILDCARD = "**/";
    
    /** Path separator - platform independent */  
    String PATH_SEP = "/";
}

import groovy.util.FileNameFinder

def finder = new FileNameFinder()

// Find all Groovy files
def groovyFiles = finder.getFileNames("src", "**/*.groovy")
groovyFiles.each { file ->
    println "Found: $file"
}

// Find Java files, excluding test files
def javaFiles = finder.getFileNames("src", "**/*.java", "**/*Test.java")
println "Found ${javaFiles.size()} non-test Java files"

def finder = new FileNameFinder()

// Using named parameters
def configFiles = finder.getFileNames(
    dir: "config",
    includes: "**/*.properties,**/*.xml",
    excludes: "**/test/**"
)

// Process configuration files
configFiles.each { configFile ->
    println "Processing config: $configFile"
    // Load and validate configuration
}

import groovy.util.AntBuilder
import groovy.util.FileNameFinder

def ant = new AntBuilder()
def finder = new FileNameFinder()

// Find source files to compile
def sourceFiles = finder.getFileNames(
    dir: "src/main/groovy",
    includes: "**/*.groovy",
    excludes: "**/internal/**"
)

if (sourceFiles) {
    println "Compiling ${sourceFiles.size()} source files"
    
    ant.groovyc(destdir: "build/classes") {
        sourceFiles.each { sourceFile ->
            src(file: sourceFile)
        }
    }
}

def finder = new FileNameFinder()

// Find and process different file types
def processFiles = { pattern, processor ->
    def files = finder.getFileNames(".", pattern)
    files.each { file ->
        processor(new File(file))
    }
}

// Process properties files
processFiles("**/*.properties") { file ->
    def props = new Properties()
    file.withInputStream { props.load(it) }
    println "$file.name has ${props.size()} properties"
}

// Process XML files
processFiles("**/*.xml") { file ->
    def xml = new XmlSlurper().parse(file)
    println "$file.name root element: ${xml.name()}"
}

import org.codehaus.groovy.ant.FileScanner
import groovy.util.AntBuilder

def ant = new AntBuilder()

// Create scanner through AntBuilder
def scanner = ant.fileScanner {
    fileset(dir: "src") {
        include(name: "**/*.groovy")
        include(name: "**/*.java")
        exclude(name: "**/test/**")
        exclude(name: "**/*Test.*")
    }
}

// Iterate through matched files
scanner.each { file ->
    println "Processing: ${file.absolutePath}"
    
    // Analyze file properties
    def lines = file.readLines()
    def size = file.length()
    println "  Lines: ${lines.size()}, Size: ${size} bytes"
}

def finder = new FileNameFinder()

// Find outdated files that need recompilation
def sourceFiles = finder.getFileNames("src", "**/*.groovy")
def classFiles = finder.getFileNames("build/classes", "**/*.class")

def outdatedSources = sourceFiles.findAll { srcPath ->
    def srcFile = new File(srcPath)
    def classPath = srcPath.replace("src/", "build/classes/")
                          .replace(".groovy", ".class")
    def classFile = new File(classPath)
    
    !classFile.exists() || srcFile.lastModified() > classFile.lastModified()
}

if (outdatedSources) {
    println "Recompiling ${outdatedSources.size()} outdated files"
    // Trigger compilation
} else {
    println "All files are up to date"
}

import java.util.zip.ZipFile

def finder = new FileNameFinder()

// Find all JAR files in dependencies
def jarFiles = finder.getFileNames("lib", "**/*.jar")

jarFiles.each { jarPath ->
    def jarFile = new ZipFile(jarPath)
    def entries = jarFile.entries().toList()
    
    println "Analyzing $jarPath:"
    println "  Total entries: ${entries.size()}"
    
    // Count different file types
    def classCount = entries.count { it.name.endsWith('.class') }
    def resourceCount = entries.count { !it.name.endsWith('.class') && !it.directory }
    
    println "  Classes: $classCount"
    println "  Resources: $resourceCount"
    
    jarFile.close()
}

def finder = new FileNameFinder()

// Clean up old build artifacts
def cleanupOldArtifacts = {
    def artifactPatterns = [
        "build/**/*.class",
        "build/**/*.jar", 
        "dist/**/*.zip",
        "**/*.tmp"
    ]
    
    artifactPatterns.each { pattern ->
        def files = finder.getFileNames(".", pattern)
        files.each { filePath ->
            def file = new File(filePath)
            if (file.exists()) {
                println "Removing: $filePath"
                file.delete()
            }
        }
    }
}

// Find test reports for archiving
def archiveTestReports = {
    def reports = finder.getFileNames(
        dir: "build",
        includes: "**/TEST-*.xml,**/test-results/**/*.html",
        excludes: "**/tmp/**"
    )
    
    if (reports) {
        println "Archiving ${reports.size()} test reports"
        // Create archive with reports
    }
}

cleanupOldArtifacts()
archiveTestReports()

def finder = new FileNameFinder()

// Find all build files across subprojects
def findProjectFiles = { rootDir ->
    def buildFiles = [:]
    
    // Find Gradle build files
    buildFiles.gradle = finder.getFileNames(rootDir, "**/build.gradle")
    
    // Find Maven POM files
    buildFiles.maven = finder.getFileNames(rootDir, "**/pom.xml")
    
    // Find Ant build files
    buildFiles.ant = finder.getFileNames(rootDir, "**/build.xml")
    
    return buildFiles
}

def projectFiles = findProjectFiles(".")

projectFiles.each { buildSystem, files ->
    if (files) {
        println "$buildSystem projects found:"
        files.each { file ->
            println "  $file"
        }
    }
}

def finder = new FileNameFinder()

// Complex pattern matching for code analysis
def analyzeCodebase = {
    def codeFiles = finder.getFileNames(
        dir: "src",
        includes: "**/*.java,**/*.groovy,**/*.scala",
        excludes: [
            "**/test/**",           // No test files
            "**/generated/**",      // No generated code
            "**/*\$*.java",        // No inner class files
            "**/package-info.java"  // No package info files
        ].join(",")
    )
    
    // Categorize by language
    def byLanguage = codeFiles.groupBy { file ->
        def ext = file.substring(file.lastIndexOf('.') + 1)
        return ext
    }
    
    byLanguage.each { lang, files ->
        println "$lang files: ${files.size()}"
    }
    
    return codeFiles
}

def codeFiles = analyzeCodebase()