Add experiments

.gitignore

@@ -24,6 +24,10 @@
 
 # Directory
 Lushu/src/main/kotlin/lushu/ContextGrammar/out
+example/html/html_files
+example/C/C_files
+test/context_tests/compare_to_beautifulsoup/emails
+test/context_tests/compare_to_beautifulsoup/results
 
 # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
 hs_err_pid*
@@ -32,6 +36,9 @@ hs_err_pid*
 *#*
 **~
 
+# VSCode
+.vscode
+
 .gradle
 .idea
 

Lushu/build.gradle.kts

@@ -8,11 +8,10 @@ repositories {
 plugins {
     kotlin("jvm") version "1.8.22"
 
-    // Apply the application plugin to add support for building a CLI
-    // application.
+    // The application plugin enables building a CLI application.
     application
 
-    // This pluging allows greater flexibility in customizing test builds.
+    // This plugin allows greater flexibility in customizing test builds.
     id("org.unbroken-dome.test-sets") version "4.0.0"
 }
 
@@ -30,98 +29,20 @@ dependencies {
     testImplementation("org.junit.jupiter:junit-jupiter-api")
 }
 
-val fatJar = task("fatJar", type = Jar::class) {
-    description = "Creates a self-contained fat JAR of the application."
-    manifest {
-        attributes(
-            mapOf(
-                "Implementation-Title" to "Lushu",
-                "Implementation-Version" to "0.1",
-                "Main-Class" to "lushu.AppKt"
-            )
-        )
-    }
-    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-    val dependencies = configurations
-        .runtimeClasspath
-        .get()
-        .map(::zipTree)
-    from(dependencies)
-    with(tasks.jar.get())
-}
-
-val grammarJar = task("grammarJar", type = Jar::class) {
-    archiveBaseName.set("Grammar")
-    manifest {
-        attributes(
-            mapOf(
-                "Implementation-Title" to "Grammar",
-                "Implementation-Version" to "0.1",
-                "Main-Class" to "lushu.Grammar.AppKt"
-            )
-        )
-    }
-    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-    val dependencies = configurations
-        .runtimeClasspath
-        .get()
-        .map(::zipTree)
-    from(dependencies)
-    with(tasks.jar.get())
-}
-
-val mergerJar = task("mergerJar", type = Jar::class) {
-    archiveBaseName.set("Merger")
-    manifest {
-        attributes(
-            mapOf(
-                "Implementation-Title" to "Merger",
-                "Implementation-Version" to "0.1",
-                "Main-Class" to "lushu.Merger.AppKt"
-            )
-        )
-    }
-    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-    val dependencies = configurations
-        .runtimeClasspath
-        .get()
-        .map(::zipTree)
-    from(dependencies)
-    with(tasks.jar.get())
-}
-
-val stressTestWithLushuJar =
-    task("stressTestWithLushuJar", type = Jar::class) {
-        archiveBaseName.set("StressTestWithLushu")
-        manifest {
-            attributes(
-                mapOf(
-                    "Implementation-Title" to "StressTestWithLushu",
-                    "Implementation-Version" to "0.1",
-                    "Main-Class" to "lushu.TestApps.StressTest.WithLushu.AppKt"
-                )
-            )
-        }
-        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-        val dependencies = configurations
-            .runtimeClasspath
-            .get()
-            .map(::zipTree)
-        from(dependencies)
-        with(tasks.jar.get())
-    }
-
-val stressTestWoutLushuJar =
-    task("stressTestWoutLushuJar", type = Jar::class) {
-        archiveBaseName.set("StressTestWoutLushu")
+fun newJarTask(
+    name: String,
+    desc: String,
+    packagePath: String,
+    manifestAttributes: Map<String, String> = mapOf(
+        "Implementation-Title" to "Lushu",
+        "Implementation-Version" to "0.1",
+        "Main-Class" to packagePath
+    )
+): Task {
+    return task(name, type = Jar::class) {
+        description = desc
         manifest {
-            attributes(
-                mapOf(
-                    "Implementation-Title" to "StressTestWoutLushu",
-                    "Implementation-Version" to "0.1",
-                    "Main-Class" to "lushu.TestApps.StressTest.WoutLushu.AppKt"
-                )
-            )
+            attributes(manifestAttributes)
         }
         duplicatesStrategy = DuplicatesStrategy.EXCLUDE
         val dependencies = configurations
@@ -131,27 +52,55 @@ val stressTestWoutLushuJar =
         from(dependencies)
         with(tasks.jar.get())
     }
+}
 
-val stressTestGrammarStatisticsJar =
-    task("stressTestGrammarStatisticsJar", type = Jar::class) {
-        archiveBaseName.set("StressTestGrammarStatistics")
-        manifest {
-            attributes(
-                mapOf(
-                    "Implementation-Title" to "StressTestGrammarStatistics",
-                    "Implementation-Version" to "0.1",
-                    "Main-Class" to "lushu.TestApps.StressTest.GrammarStatistics.AppKt"
-                )
-            )
-        }
-        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-        val dependencies = configurations
-            .runtimeClasspath
-            .get()
-            .map(::zipTree)
-        from(dependencies)
-        with(tasks.jar.get())
-    }
+val fatJar = newJarTask(
+    "fatJar",
+    "Creates a self-contained fat JAR of the application.",
+    "lushu.Appkt"
+)
+
+newJarTask(
+    "grammarJar",
+    "Application to play with Lushu Grammar.",
+    "lushu.Grammar.AppKt"
+)
+
+newJarTask(
+    "mergerJar",
+    "Application to play with Lushu Merger.",
+    "lushu.Merger.AppKt"
+)
+
+newJarTask(
+    "generatorJar",
+    "Application to generate test files",
+    "lushu.ContextGrammar.GeneratorAppKt"
+)
+
+newJarTask(
+    "stressTestMapWithLushuJar",
+    "Application to test Lushu Map Grammar implementation.",
+    "lushu.TestApps.StressTest.Context.WithLushu.AppKt"
+)
+
+newJarTask(
+    "stressTestWithLushuJar",
+    "Application to test stable Lushu implementation.",
+    "lushu.TestApps.StressTest.WithLushu.AppKt"
+)
+
+newJarTask(
+    "stressTestWoutLushuJar",
+    "Application to test base case (program running without Lushu interception) against Lushu.",
+    "lushu.TestApps.StressTest.WoutLushu.AppKt"
+)
+
+newJarTask(
+    "stressTestGrammarStatisticsJar",
+    "Application to get some statistics about the Lushu Grammar after running against some benchmark.",
+    "lushu.TestApps.StressTest.GrammarStatistics.AppKt"
+)
 
 tasks {
     "build" {
@@ -212,9 +161,9 @@ tasks.test {
                 logger.lifecycle("Test result: ${result.resultType}")
                 logger.lifecycle(
                     "Test summary: ${result.testCount} tests, " +
-                            "${result.successfulTestCount} succeeded, " +
-                            "${result.failedTestCount} failed, " +
-                            "${result.skippedTestCount} skipped"
+                        "${result.successfulTestCount} succeeded, " +
+                        "${result.failedTestCount} failed, " +
+                        "${result.skippedTestCount} skipped"
                 )
                 failedTests.takeIf { it.isNotEmpty() }?.prefixedSummary("\tFailed Tests")
                 skippedTests.takeIf { it.isNotEmpty() }?.prefixedSummary("\tSkipped Tests:")

Lushu/src/main/kotlin/lushu/ContextGrammar/GeneratorApp.kt

@@ -0,0 +1,29 @@
+package lushu.ContextGrammar
+
+import lushu.ContextGrammar.Grammar.CGenerator
+import lushu.ContextGrammar.Grammar.HTMLGenerator
+
+val HTML_OPT = 0
+val C_OPT = 1
+fun main(args: Array<String>) {
+    if (args.size < 3) {
+        println(
+            "Usage: <this-program> <generator-type> <output-file> <number-of-tokens>"
+        )
+        return
+    }
+
+    val option: Int = args[0].toInt()
+    val file: String = args[1]
+    val numTokens: Int = args[2].toInt()
+    if (option == HTML_OPT) {
+        HTMLGenerator().startGenerator(numTokens, file)
+    } else if (option == C_OPT) {
+        CGenerator().startGenerator(numTokens, file)
+    } else {
+        println(
+            "options:\nHTML = 0\nC = 1\n"
+        )
+        return
+    }
+}