From 5ab652f02d9882f5eefb59929b0c564d612627d7 Mon Sep 17 00:00:00 2001 From: Mark Harrah Date: Mon, 27 Sep 2010 18:49:50 -0400 Subject: [PATCH] comment subprojects in project definition --- project/build/XSbt.scala | 44 +++++++++++++++++++++++++++++++++++----- 1 file changed, 39 insertions(+), 5 deletions(-) diff --git a/project/build/XSbt.scala b/project/build/XSbt.scala index 5843c97ae..b3400a1c3 100644 --- a/project/build/XSbt.scala +++ b/project/build/XSbt.scala @@ -4,44 +4,77 @@ import java.io.File class XSbt(info: ProjectInfo) extends ParentProject(info) with NoCrossPaths { - /* Subproject declarations*/ + /*** Subproject declarations ***/ + // defines the Java interfaces through which the launcher and the launched application communicate val launchInterfaceSub = project(launchPath / "interface", "Launcher Interface", new LaunchInterfaceProject(_)) + + // the launcher. Retrieves, loads, and runs applications based on a configuration file. val launchSub = project(launchPath, "Launcher", new LaunchProject(_), launchInterfaceSub) + // defines Java structures used across Scala versions, such as the API structures and relationships extracted by + // the analysis compiler phases and passed back to sbt. The API structures are defined in a simple + // format from which Java sources are generated by the datatype generator subproject val interfaceSub = project("interface", "Interface", new InterfaceProject(_)) + + // defines operations on the API of a source, including determining whether it has changed and converting it to a string val apiSub = baseProject(compilePath / "api", "API", interfaceSub) - // util + /***** Utilities *****/ + val controlSub = baseProject(utilPath / "control", "Control") val collectionSub = testedBase(utilPath / "collection", "Collections") + // The API for forking, combining, and doing I/O with system processes val processSub = project(utilPath / "process", "Process", new Base(_) with TestWithIO) - + // Path, IO (formerly FileUtilities), NameFilter and other I/O utility classes val ioSub = testedBase(utilPath / "io", "IO", controlSub) + // Utilities related to reflection, managing Scala versions, and custom class loaders val classpathSub = baseProject(utilPath / "classpath", "Classpath", launchInterfaceSub, ioSub) + // Command line-related utilities. Currently, history. val completeSub = project(utilPath / "complete", "Completion", new InputProject(_), controlSub, ioSub) + // logging val logSub = project(utilPath / "log", "Logging", new LogProject(_), interfaceSub, processSub) + // class file reader and analyzer val classfileSub = testedBase(utilPath / "classfile", "Classfile", ioSub, interfaceSub, logSub) + // generates immutable or mutable Java data types according to a simple input format val datatypeSub = baseProject(utilPath /"datatype", "Datatype Generator", ioSub) + // persisted, hierarchical properties val envSub= baseProject(utilPath / "env", "Properties", ioSub, logSub, classpathSub) - // intermediate-level modules + /***** Intermediate-level Modules *****/ + + // Apache Ivy integration val ivySub = project("ivy", "Ivy", new IvyProject(_), interfaceSub, launchInterfaceSub, logSub, ioSub) + // Runner for uniform test interface val testingSub = project("testing", "Testing", new TestingProject(_), ioSub, classpathSub, logSub) + // Basic task engine val taskSub = testedBase(tasksPath, "Tasks", controlSub, collectionSub) + // Persisted caching based on SBinary val cacheSub = project(cachePath, "Cache", new CacheProject(_), ioSub, collectionSub) + // Builds on cache to provide caching for filesystem-related operations val trackingSub = baseProject(cachePath / "tracking", "Tracking", cacheSub, ioSub) + // Interface to Jetty val webappSub = project("web", "Web App", new WebAppProject(_), ioSub, logSub, classpathSub, controlSub) + // Embedded Scala code runner val runSub = baseProject("run", "Run", ioSub, logSub, classpathSub, processSub) - // compilation/discovery related modules + /***** compilation/discovery related modules *****/ + + // Compiler-side interface to compiler that is compiled against the compiler being used either in advance or on the fly. + // Includes API and Analyzer phases that extract source API and relationships. val compileInterfaceSub = project(compilePath / "interface", "Compiler Interface", new CompilerInterfaceProject(_), interfaceSub) + // Implements the core functionality of detecting and propagating changes incrementally. + // Defines the data structures for representing file fingerprints and relationships and the overall source analysis val compileIncrementalSub = testedBase(compilePath / "inc", "Incremental Compiler", collectionSub, apiSub, ioSub) + // Searches the source API data structures, currently looks for subclasses and annotations val discoverySub = testedBase(compilePath / "discover", "Discovery", compileIncrementalSub, apiSub) + // Persists the incremental data structures using SBinary val compilePersistSub = project(compilePath / "persist", "Persist", new PersistProject(_), compileIncrementalSub, apiSub) + // sbt-side interface to compiler. Calls compiler-side interface reflectively val compilerSub = project(compilePath, "Compile", new CompileProject(_), launchInterfaceSub, interfaceSub, ivySub, ioSub, classpathSub, compileInterfaceSub, logSub) + // mostly for implementing 'load' command, could perhaps be trimmed and merged into 'main' val buildSub = baseProject("main" / "build", "Project Builder", classfileSub, classpathSub, compilePersistSub, compilerSub, compileIncrementalSub, interfaceSub, ivySub, launchInterfaceSub, logSub, discoverySub, processSub) @@ -51,6 +84,7 @@ class XSbt(info: ProjectInfo) extends ParentProject(info) with NoCrossPaths // Standard task system. This provides map, flatMap, join, and more on top of the basic task model. val stdTaskSub = testedBase(tasksPath / "standard", "Task System", taskSub, collectionSub, logSub, ioSub, processSub) + // The main integration project for sbt. It brings all of the subsystems together, configures them, and provides for overriding conventions. val mainSub = baseProject("main", "Main", buildSub, compileIncrementalSub, compilerSub, completeSub, discoverySub, ioSub, logSub, processSub, taskSub, stdTaskSub, runSub, trackingSub) // Strictly for bringing implicits and aliases from subsystems into the top-level sbt namespace through a single package object