Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/sbt/sbt-boilerplate
sbt plugin for generating scala.Tuple/Function related boilerplate code
https://github.com/sbt/sbt-boilerplate
code-generator sbt sbt-plugin scala
Last synced: 4 days ago
JSON representation
sbt plugin for generating scala.Tuple/Function related boilerplate code
- Host: GitHub
- URL: https://github.com/sbt/sbt-boilerplate
- Owner: sbt
- License: bsd-2-clause
- Created: 2012-10-10T10:46:23.000Z (about 12 years ago)
- Default Branch: main
- Last Pushed: 2024-10-16T09:42:49.000Z (29 days ago)
- Last Synced: 2024-10-18T05:52:38.214Z (27 days ago)
- Topics: code-generator, sbt, sbt-plugin, scala
- Language: Scala
- Size: 99.6 KB
- Stars: 109
- Watchers: 16
- Forks: 20
- Open Issues: 10
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# sbt-boilerplate
Boilerplate is an sbt-plugin that generates stubs for code which has to be expanded
for all numbers of arguments from 1 to 22. This is sometimes necessary to support
all of the `TupleX` or `FunctionX` generically.
The plugin defines a simple template language for this purpose.
## The template language
The template file contains mostly literal code with some control characters guiding the
expansion. Expansion follows these rules:
- The current number of arguments `i` is initialized to 22.
- Code embraced in `[#` and `#]` is copied `i` times and the expansion is applied
recursively with `i` being set accordingly.
- It is possible to define a custom separator
between the copied instances by putting the separator text between the `#` and the `]` of the closing
bracket. If no separator is supplied `", "` is assumed.
- You can specify a custom range `i` should iterate through by placing a term of the form `..` between
the starting `[` and `#` of an expansion. Either `start` or `end` can be omitted in which case the defaults are assumed.
- Everywhere digit `1` is replaced by `i`, digit `0` is replaced by `i - 1`, and digit `2` is replaced by `i + 1`
unless the digit is prefixed with `##`.
- To encode the sharp `'#'` character precede it with a backslash e.g. `"\#"`.
## Examples
### Apply function to tuple
Consider the task is to provide overloads for a function which can apply a function to
a tuple for all numbers of arguments from 1 to 22.
Start by writing out the function for only one argument:
def applyFunc[P1, R](input: Tuple1[P1], func: (P1) => R): R =
func(input._1)
For the function to be copied for each possible number of arguments, enclose it in `[#`
and `#]` (the newline between the closing `#` and `]` defines that instances should be
separated by newline and not by the default `", "`):
[#def applyFunc[P1, R](input: Tuple1[P1], func: (P1) => R): R =
func(input._1)#
]
This will already expand to:
def applyFunc[P1, R](input: Tuple1[P1], func: (P1) => R): R =
func(input._1)
def applyFunc[P2, R](input: Tuple2[P2], func: (P2) => R): R =
func(input._2)
def applyFunc[P3, R](input: Tuple3[P3], func: (P3) => R): R =
func(input._3)
def applyFunc[P4, R](input: Tuple4[P4], func: (P4) => R): R =
func(input._4)
// ...
This is not yet what we want, because we `P1` to expand to
`P1, P2, ..., Pi` and `input._1` to `input._1, input._2, ..., input._i`. So we embrace the
parts to expand another time:
[#def applyFunc[[#P1#], R](input: Tuple1[[#P1#]], func: ([#P1#]) => R): R =
func([#input._1#])#
]
This now expands correctly to
def applyFunc[P1, R](input: Tuple1[P1], func: (P1) => R): R =
func(input._1)
def applyFunc[P1, P2, R](input: Tuple2[P1, P2], func: (P1, P2) => R): R =
func(input._1, input._2)
def applyFunc[P1, P2, P3, R](input: Tuple3[P1, P2, P3], func: (P1, P2, P3) => R): R =
func(input._1, input._2, input._3)
def applyFunc[P1, P2, P3, P4, R](input: Tuple4[P1, P2, P3, P4], func: (P1, P2, P3, P4) => R): R =
func(input._1, input._2, input._3, input._4)
## Usage
sbt-boilerplate currently supports sbt 1.x.
Put
addSbtPlugin("com.github.sbt" % "sbt-boilerplate" % "0.7.0")
into your `plugins.sbt`. sbt-boilerplate is an `AutoPlugin` which needs to be enabled using
```scala
enablePlugins(spray.boilerplate.BoilerplatePlugin)
```
The templates have to be put into the `src/main/boilerplate` directory and the file name
must end with `.template`. The generated files will be put into the same hierarchy as they
appear in `src/main/boilerplate` with the `.template` extension stripped off. If the stripped
filename has no extension ".scala" is added automatically.
## Known issues
* Instances for zero arguments have to be supplied manually.
## Projects using sbt-boilerplate
* [akka](https://github.com/akka/akka) uses sbt-boilerplate for akka-actor, akka-stream, and akka-http
* [spray-routing](https://github.com/spray/spray) uses sbt-boilerplate to provide conversions to/from HLists
* [product-collections](https://github.com/marklister/product-collections)
## License
Copyright (c) 2012-2016 Johannes Rudolph
Published under the [BSD 2-Clause License](http://www.opensource.org/licenses/BSD-2-Clause).