Scala w/ fragment support

Author: frison

scala/Dockerfile

@@ -10,3 +10,10 @@ COPY --chown=human:human ./artifacts /artifacts
 RUN cd /artifacts && make install
 
 COPY --chown=human:human ./files /hello-world
+COPY --chown=human:human ./fraglet /
+
+ENV CI_DISABLE_PROGRESS_BAR=1 \
+    COURSIER_PROGRESS=0 \
+    COURSIER_NO_TERM=1
+
+ENTRYPOINT [ "/fraglet-entrypoint" ]

scala/artifacts/Makefile

@@ -2,6 +2,10 @@ install:
 	curl -fL https://github.com/coursier/coursier/releases/download/v2.1.8/cs-x86_64-pc-linux.gz | gzip -d > cs && chmod +x cs
 	# Coursier doesn't work with musl libc, so we need to use gcompat in alpine
 	./cs setup --install-dir /usr/local/bin
-	# This is to prefetch + cache dependencies
+	# Pre-download coursier index and cache dependencies
+	export CI_DISABLE_PROGRESS_BAR=1
+	export COURSIER_PROGRESS=0
+	# Pre-warm coursier cache by fetching the index
+	curl -s -o /dev/null https://github.com/coursier/jvm-index/raw/master/index.json || true
 	echo 'object Test { def main(args: Array[String]) = println("Hello") }' > Test.scala
-	scala run Test.scala
+	scala run --quiet Test.scala

scala/files/hello-world.sh

@@ -1,3 +1,4 @@
 #!/usr/bin/env sh
 
-scala run HelloWorld.scala
+cd /hello-world
+scala run --quiet HelloWorld.scala

scala/fraglet/fraglet.yml

@@ -0,0 +1,11 @@
+fragletTempPath: /FRAGLET
+
+injection:
+  codePath: /hello-world/HelloWorld.scala
+  match: "Hello World!"
+
+guide: /guide.md
+
+execution:
+  path: /hello-world/hello-world.sh
+  makeExecutable: true

scala/fraglet/guide.md

@@ -0,0 +1,143 @@
+# Scala Fraglet Guide
+
+## Language Version
+Scala (installed via Coursier)
+
+## Execution Model
+- Compiled, then executed
+- Uses `scala run` to compile and execute in one step
+- Requires an object with a `main` method
+- Code executes when `main()` is called
+- Can define functions, classes, traits, and objects outside `main()`
+
+## Key Characteristics
+- JVM-based language (runs on Java)
+- Statically typed with type inference
+- Case-sensitive
+- Semicolons optional
+- Supports both object-oriented and functional programming
+- Immutable by default (val vs var)
+- Pattern matching
+
+## Fragment Authoring
+Write valid Scala statements or expressions. Code executes inside `main()`, so you can write statements directly. You can also define functions, classes, traits, and objects outside `main()` and call them from within.
+
+## Available Libraries
+- Standard Scala library
+- Java standard library (via JVM)
+- No additional dependencies pre-installed
+
+## Common Patterns
+- Print: `println("message")`
+- String interpolation: `s"Total: $count"` or `s"Total: ${expression}"`
+- Lists: `List(1, 2, 3).sum`
+- Functions: `def methodName(): Unit = { }`
+- Classes: `class MyClass { }`
+- Objects: `object MyObject { }`
+- Traits: `trait MyTrait { }`
+- Pattern matching: `x match { case 1 => ... }`
+- Immutable variables: `val x = 5`
+- Mutable variables: `var x = 5`
+- Higher-order functions: `list.map(x => x * 2)`
+- For comprehensions: `for (i <- 1 to 10) println(i)`
+
+## Examples
+
+```scala
+// Simple output
+println("Hello, World!")
+```
+
+```scala
+// Function definition
+def greet(name: String): String = {
+    s"Hello, $name!"
+}
+
+println(greet("Alice"))
+```
+
+```scala
+// List processing
+val numbers = List(1, 2, 3, 4, 5)
+val squared = numbers.map(x => x * x)
+println(s"Sum of squares: ${squared.sum}")
+```
+
+```scala
+// Higher-order function
+val multiply = (a: Int, b: Int) => a * b
+println(s"5 * 3 = ${multiply(5, 3)}")
+```
+
+```scala
+// Class definition
+class Calculator {
+    def add(a: Int, b: Int): Int = {
+        a + b
+    }
+}
+
+val calc = new Calculator()
+println(s"10 + 20 = ${calc.add(10, 20)}")
+```
+
+```scala
+// String interpolation
+val name = "Scala"
+val version = 3
+println(s"Welcome to $name $version!")
+```
+
+```scala
+// Case class
+case class Person(name: String, age: Int)
+
+val person = Person("Bob", 30)
+println(s"${person.name} is ${person.age} years old")
+```
+
+```scala
+// Pattern matching
+val x = 5
+val result = x match {
+    case n if n < 0 => "negative"
+    case 0 => "zero"
+    case _ => "positive"
+}
+println(s"x is $result")
+```
+
+```scala
+// For comprehension
+val numbers = List(1, 2, 3, 4, 5)
+val doubled = for (n <- numbers) yield n * 2
+println(s"Doubled: ${doubled.mkString(", ")}")
+```
+
+```scala
+// Option handling
+val name: Option[String] = Some("Scala")
+name.foreach(n => println(s"Name: $n"))
+
+val empty: Option[String] = None
+println(empty.getOrElse("Default value"))
+```
+
+```scala
+// Extension methods (Scala 3) or implicit classes (Scala 2)
+implicit class StringOps(s: String) {
+    def double(): String = s + s
+}
+
+val text = "Hello"
+println(text.double())
+```
+
+## Notes
+- Use `val` for immutable variables, `var` for mutable
+- Type inference works well, but explicit types can improve clarity
+- Pattern matching is powerful for control flow
+- Case classes provide convenient data structures
+- For comprehensions are syntactic sugar for map/flatMap/filter
+- Scala 2 and Scala 3 syntax may differ slightly

scala/fraglet/verify.sh

@@ -0,0 +1,102 @@
+#!/bin/bash
+set -euo pipefail
+
+IMAGE="${1:-100hellos/scala:local}"
+
+echo "Testing default execution..."
+docker run --rm "$IMAGE" | grep -Fq "Hello World!"
+
+echo "Testing fraglet examples from guide.md..."
+
+# Example 1: Simple output
+fragletc --image "$IMAGE" - <<'EOF' 2>&1 | grep -Fq "Hello, World!"
+println("Hello, World!")
+EOF
+
+# Example 2: Function definition
+fragletc --image "$IMAGE" - <<'EOF' 2>&1 | grep -Fq "Hello, Alice!"
+def greet(name: String): String = {
+    s"Hello, $name!"
+}
+
+println(greet("Alice"))
+EOF
+
+# Example 3: List processing
+fragletc --image "$IMAGE" - <<'EOF' 2>&1 | grep -Fq "Sum of squares:"
+val numbers = List(1, 2, 3, 4, 5)
+val squared = numbers.map(x => x * x)
+println(s"Sum of squares: ${squared.sum}")
+EOF
+
+# Example 4: Higher-order function
+fragletc --image "$IMAGE" - <<'EOF' 2>&1 | grep -Fq "5 * 3 = 15"
+val multiply = (a: Int, b: Int) => a * b
+println(s"5 * 3 = ${multiply(5, 3)}")
+EOF
+
+# Example 5: Class definition
+fragletc --image "$IMAGE" - <<'EOF' 2>&1 | grep -Fq "10 + 20 = 30"
+class Calculator {
+    def add(a: Int, b: Int): Int = {
+        a + b
+    }
+}
+
+val calc = new Calculator()
+println(s"10 + 20 = ${calc.add(10, 20)}")
+EOF
+
+# Example 6: String interpolation
+fragletc --image "$IMAGE" - <<'EOF' 2>&1 | grep -Fq "Welcome to Scala"
+val name = "Scala"
+val version = 3
+println(s"Welcome to $name $version!")
+EOF
+
+# Example 7: Case class
+fragletc --image "$IMAGE" - <<'EOF' 2>&1 | grep -Fq "Bob is 30 years old"
+case class Person(name: String, age: Int)
+
+val person = Person("Bob", 30)
+println(s"${person.name} is ${person.age} years old")
+EOF
+
+# Example 8: Pattern matching
+fragletc --image "$IMAGE" - <<'EOF' 2>&1 | grep -Fq "x is positive"
+val x = 5
+val result = x match {
+    case n if n < 0 => "negative"
+    case 0 => "zero"
+    case _ => "positive"
+}
+println(s"x is $result")
+EOF
+
+# Example 9: For comprehension
+fragletc --image "$IMAGE" - <<'EOF' 2>&1 | grep -Fq "Doubled:"
+val numbers = List(1, 2, 3, 4, 5)
+val doubled = for (n <- numbers) yield n * 2
+println(s"Doubled: ${doubled.mkString(", ")}")
+EOF
+
+# Example 10: Option handling
+fragletc --image "$IMAGE" - <<'EOF' 2>&1 | grep -Fq "Name: Scala"
+val name: Option[String] = Some("Scala")
+name.foreach(n => println(s"Name: $n"))
+
+val empty: Option[String] = None
+println(empty.getOrElse("Default value"))
+EOF
+
+# Example 11: Extension methods (implicit class)
+fragletc --image "$IMAGE" - <<'EOF' 2>&1 | grep -Fq "HelloHello"
+implicit class StringOps(s: String) {
+    def double(): String = s + s
+}
+
+val text = "Hello"
+println(text.double())
+EOF
+
+echo "✓ All tests passed"