sbt in Action

Josh Suereth is a Senior Software Engineer at Typesafe and the author of Scala in Depth. He is the author of several open source Scala projects, including the Scala automated resource management library, the PGP sbt plugin.

Matthew Farwell is a Senior Software developer at Nexthink. He is the author of Scalastyle, the style checker for Scala and is a contributor to JUnit and the Eclipse Scala IDE.

preface
acknowledgments
about this book
author online
about the authors
about the cover illustration
Part 1 Why sbt?
1. Why sbt?
1.1. Why a build tool?
1.2. Apache Ant
1.3. Apache Maven
1.3.1. Build definition
1.3.2. Maven workflow-default lifecycle
1.3.3. Adding another task to a Maven build
1.3.4. Advantages of Maven
1.3.5. Limitations of Maven
1.4. Gradle
1.4.1. What is Gradle?
1.4.2. Gradle workflow
1.4.3. Adding another task to a Gradle build
1.4.4. Advantages of Gradle
1.4.5. Limitations of Gradle
1.5. Why sbt?
1.5.1. How sbt works
1.5.2. Plugin architecture vs. tasks
1.5.3. Phases versus task dependencies
1.5.4. Passing information around your build
1.5.5. Working with Scala
1.5.6. Multiproject builds
1.5.7. Dependency resolution
1.6. Interactivity/reactivity of sbt
1.6.1. Quicker compilation and testing cycle
1.6.2. Quicker compilation and testing cycle
1.6.3. sbt and the Scala REPL—the console command
1.7. Summary
2. Getting started
2.1. Setting up sbt
2.1.1. Setting the PATH in bash (for Linux/Mac)
2.1.2. Running sbt
2.2. Setting up a build
2.2.1. Tasks
2.2.2. Settings
2.3. Running code
2.4. Testing code
2.4.1. Running tasks when sources change
2.4.2. Selecting tests with interactive tasks
2.5. Summary
Part 2 UNDERSTANDING SBT’S CORE CONCEPTS
3. Core Concepts
3.1. Creating builds
3.2. Defining settings
3.2.1. Initializations
3.3. Creating and executing tasks
3.3.1. Task dependencies
3.4. Using configurations
3.5. Defining with subprojects
3.6. Putting it all together
3.7. Summary
4. The default build
4.1. Compiling your code
4.2. Finding your sources
4.2.1. Standard organization of sources
4.2.2. Testing sources
4.2.3. Custom organization of sources
4.2.4. Filtering the source you want
4.3. Depending on libraries
4.3.1. Unmanaged dependencies
4.3.2. Managed dependencies
4.3.3. Managed dependencies and configurations
4.4. Packaging your project
4.4.1. Identifying your project
4.5. Summary
Part 3 WORKING WITH SBT
5. Testing
5.1. Configuring Specs2 with sbt
5.1.1. Reports and forking tests
5.1.2. Digging deeper: other options for forking
5.2. JUnit and using custom code
5.2.1. Report generation with JUnit
5.3. ScalaCheck
5.4. Integration testing
5.4.1. ScalaTest and Selenium
5.4.2. Challenges of integration testing
5.4.3. Adding integration tests to sbt
5.5. Summary
6. The IO and Process Libraries
6.1. Packaging using processes
6.2. Packaging using the sbt.IO library
6.3. More mappings
6.4. Task dependencies
6.5. Logging using the sbt logger
6.6. Running your build using fork
6.7. Linking everything together: dependencies
6.8. Linking everything together: processes
6.9. Summary
7. Accepting user input
7.1. Accepting user input with input tasks
7.2. Defining an interface with parsers
7.3. Defining a database evolution parser
7.4. Helping the user with autocomplete
7.5. Summary
8. Using Plugins and external Libraries
8.1. Using plugins to check your code
8.2. Using the Revolver plugin to restart the application
8.3. Creating your uber jar using the assembly plugin
8.4. Including a library in your plugin build
8.5. Adding a plugin for use in all of your projects—signing your projects
8.6. Adding local credentials for deployment
8.7. Summary
9. Debugging your build
9.1. Running sbt
9.2. Making your build compile
9.3. Ensuring tasks are run
9.4. Resolving dependency conflicts
9.4.1. Fixing resolution failures
9.4.2. Fixing resolution conflicts
9.5. Summary
Part 4 EXTENDING SBT
10. Automating workflows with commands
10.1. Creating a simple command
10.2. Running tasks in parallel
10.3. Parsing input with commands
10.4. Creating useful help messages
10.5. Summary
11. Defining Plugins
11.1. Reusing code using Scala files
11.2. Introducing the AutoPlugin interface
11.2.1. Taking a closer look—the plugin definition
11.2.2. Taking a closer look—task and setting dependencies
11.3. Testing a plugin with the scripted plugin
11.4. Using configurations in your plugin
11.5. Adding incremental tasks
11.5.1. Adding incremental tasks with .previous—a sneak preview of 1.0
11.6. Making things easy for the user—more about the AutoPlugin interface
11.7. Summary
Part 5 DEPLOYING YOUR PROJECTS
12. Distributing Your Projects
12.1. Publishing a library
12.2. Publishing locally
12.3. Publishing a simple server
12.4. Generating a distribution
12.5. Creating a Linux distribution
12.6. Summary
Appendixes
Appendix A: What you need to know about Ivy
A.1. Modules
A.2. Module identification
A.3. Artifacts
A.4. Differences in Ivy and Maven
A.5. Configuration
A.6. Resolvers
A.7. Resolving dependency conflicts
Appendix B: Migrating to Autoplugins
B.1. Older sbt plugins
B.2. Migrating to autoplugins
Appendix C: Advanced setting/task API
C.1. Optional settings
C.2. Failing tasks
C.3. Dynamic tasks
C.4. Composing InputTasks

Covers core concepts using the Scala build tool. A useful read for beginners and advanced users alike. Iain Campbell, Tango Telecom

Offers a fast introduction to the basics of building software with sbt and complements it with detailed coverage of sbt’s more advanced topics. Dusan Kysel, Cyber Brain

Despite being a Java guy, I liked how the book tried to fool me into learning Scala. As I worked through the examples, I couldn’t help but start piecing some of it together. Eric Weinberg, Emprata