Step is a tiny Scala web framework inspired by Sinatra and originally based on some code I found on an awesome blog post.
Comments, issues, and pull requests are welcome. Please also see the new step-user mailing list, or drop in on IRC at #stepframework on irc.freenode.org
package com.thinkminimo.step
class StepExample extends Step {
// send a text/html content type back each time
before {
contentType = "text/html"
}
// parse matching requests, saving things prefixed with ':' as params
get("/date/:year/:month/:day") {
<ul>
<li>Year: {params(":year")}</li>
<li>Month: {params(":month")}</li>
<li>Day: {params(":day")}</li>
</ul>
}
// produce a simple HTML form
get("/form") {
<form action='/post' method='POST'>
Post something: <input name='submission' type='text'/>
<input type='submit'/>
</form>
}
// handle POSTs from the form generated above
post("/post") {
<h1>You posted: {params("submission")}</h1>
}
// respond to '/' with a greeting
get("/") {
<h1>Hello world!</h1>
}
// send redirect headers
get("/see_ya") {
redirect("http://google.com")
}
// set a session var
get("/set/:session_val") {
session("val") = params("session_val")
<h1>Session var set</h1>
}
// see session var
get("/see") {
session("val") match {
case Some(v:String) => v
case _ => "No session var set"
}
}
// Actions that return byte arrays render a binary response
get("/report.pdf") {
contentType = "application/pdf"
val pdf = generatePdf()
pdf.toBytes
}
notFound {
response.setStatus(404)
"Not found"
}
}
- Install Java
You'll need Java installed; I have it running with 1.5
- Install simple-build-tool
Step uses sbt (0.7 or above), a fantastic tool for building Scala programs. For instructions, see [the sbt site](http://code.google.com/p/simple-build-tool/wiki/Setup)
- Run sbt
In the directory you downloaded step to, run `sbt`.
sbt will download core dependencies, and Scala itself if it needs to.
- Download dependencies
At the sbt prompt, type `update`. This will download required dependencies.
- Try it out
At the sbt prompt, type `jetty-run`. This will run step with the example servlet on port 8080.
- Navigate to http://localhost:8080
You should see "Hello world." You can poke around the example code in example/src/main/scala/TemplateExample.scala to see what's going on.
-
before
Run some block before a request is returned.
-
get(
path
)Respond to a GET request.
Specify the route to match, with parameters to store prefixed with : like Sinatra. "/match/this/path/and/save/:this" would match that GET request, and provide you with a params(":this") in your block.
-
post(
path
)Respond to a POST request.
Posted variables are available in the
params
hash. -
delete(
path
)Respond to a DELETE request.
-
put(
path
)Respond to a PUT request.
-
error
Run some block when an error is caught. The error is available in the variable
caughtThrowable
. -
after
Run some block after the matching get/post/delete/put block is run.
Session support has recently been added. To see how to use sessions in your Step apps, check out the test servlet, at core/src/test/scala/StepTest.scala
Step includes StepTests - a framework for writing the unit tests for your Step application. It's a trait with some utility functions to send requests to your app and examine the response. It can be mixed into the test framework of your choosing. StepTests supports HTTP GET/POST tests with or without request parameters and sessions. For more examples, please refer to src/test/scala.
class TheStepAppTests extends FunSuite with ShouldMatchers with StepTests {
// `TheStepApp` is your app which extends Step
route(classOf[TheStepApp], "/*")
test("simple get") {
get("/path/to/something") {
status should equal (200)
body should include ("hi!")
}
}
}
object TheStepAppTests extends Specification with StepTests {
route(classOf[TheStepApp], "/*")
"TheStepApp when using GET" should {
"/path/to/something should return 'hi!'" in {
get("/") {
status mustEqual(200)
body mustEqual("hi!")
}
}
}
}
A test suite can be found in src/test/scala
. Inside StepTest.scala is a small testing servlet along with some assertions. If you've made changes to Step itself and you'd like to make sure that this testing servlet still works, you can type test
at the sbt prompt.
While Step can be run standalone for testing and meddling, you can also package it up in a .jar for use in other projects. At the sbt prompt, type package
. Step's only dependency is a recent version of the servlet API. For more information, see the sbt site
I'd like to thank Gabriele Renzi for the inspirational blog post and continual help, and Mark Harrah for help on the sbt mailing list and for creating sbt. Ant+Ivy by itself was a total bitch.
I'd also like to thank Yusuke Kuoka for adding sessions and header support, and Miso Korkiakoski for various patches.