Rapid Java Web Application Development with Ratpack

$ ./gradlew :example-01-hello-world:run -t

$ curl -s localhost:5050 | cat
Привіт Світ

# modify HelloWorld.java

Change detected, executing build...

:example-01-hello-world:compileJava
:example-01-hello-world:processResources UP-TO-DATE
:example-01-hello-world:classes
:example-01-hello-world:configureRun
:example-01-hello-world:run
Ratpack started (development) for http://localhost:5050

$ curl -s localhost:5050 | cat
Привіт JEEConf 2016

import ratpack.http.MutableHeaders;
import ratpack.server.RatpackServer;

public class App {
  public static void main(String[] args) throws Exception {
    RatpackServer.start(serverSpec -> serverSpec
      .handlers(chain -> chain
        .get(ctx -> {
          MutableHeaders headers = ctx.getResponse().getHeaders(); (1)
          headers.set("Access-Control-Allow-Origin", "*"); (2)
          headers.set("Access-Control-Allow-Headers", "x-requested-with, origin, content-type, accept"); (2)
          ctx.getResponse().send(); (3)
        })
      )
    );
  }
}

$ ./gradlew :example-02-cors-handler:demo -Papp=App (1)

$ curl -v localhost:5050/
* timeout on name lookup is not supported
*   Trying ::1...
* Connected to localhost (::1) port 5050 (#0)
> GET / HTTP/1.1
> Host: localhost:5050
> User-Agent: curl/7.45.0
> Accept: */*
>
< HTTP/1.1 200 OK
< Access-Control-Allow-Origin: * (2)
< Access-Control-Allow-Headers: x-requested-with, origin, content-type, accept (2)
< content-length: 0
< connection: keep-alive
<
* Connection #0 to host localhost left intact

import ratpack.http.MutableHeaders;
import ratpack.server.RatpackServer;

public class App2 {
  public static void main(String[] args) throws Exception {
    RatpackServer.start(serverSpec -> serverSpec
      .handlers(chain -> chain
        .all(ctx -> { (1)
          MutableHeaders headers = ctx.getResponse().getHeaders();
          headers.set("Access-Control-Allow-Origin", "*");
          headers.set("Access-Control-Allow-Headers", "x-requested-with, origin, content-type, accept");
          ctx.next(); (2)
        })
        .get(ctx -> ctx.render("JEEConf 2016"))
        .get("foo", ctx -> ctx.render("foo"))
      )
    );
  }
}

$ ./gradlew :example-02-cors-handler:demo -Papp=App2 (1)

$ curl -v localhost:5050/
* timeout on name lookup is not supported
*   Trying ::1...
* Connected to localhost (::1) port 5050 (#0)
> GET / HTTP/1.1
> Host: localhost:5050
> User-Agent: curl/7.45.0
> Accept: */*
>
< HTTP/1.1 200 OK
< Access-Control-Allow-Origin: * (2)
< Access-Control-Allow-Headers: x-requested-with, origin, content-type, accept (2)
< content-type: text/plain;charset=UTF-8
< content-length: 12
< connection: keep-alive
<
JEEConf 2016* Connection #0 to host localhost left intact

~
$ curl -v localhost:5050/foo
* timeout on name lookup is not supported
*   Trying ::1...
* Connected to localhost (::1) port 5050 (#0)
> GET /foo HTTP/1.1
> Host: localhost:5050
> User-Agent: curl/7.45.0
> Accept: */*
>
< HTTP/1.1 200 OK
< Access-Control-Allow-Origin: * (3)
< Access-Control-Allow-Headers: x-requested-with, origin, content-type, accept (3)
< content-type: text/plain;charset=UTF-8
< content-length: 3
< connection: keep-alive
<
foo* Connection #0 to host localhost left intact

$ curl -v localhost:5050/error
* timeout on name lookup is not supported
*   Trying ::1...
* Connected to localhost (::1) port 5050 (#0)
> GET /error HTTP/1.1
> Host: localhost:5050
> User-Agent: curl/7.45.0
> Accept: */*
>
< HTTP/1.1 404 Not Found
< Access-Control-Allow-Origin: * (4)
< Access-Control-Allow-Headers: x-requested-with, origin, content-type, accept (4)
< content-length: 0
< connection: keep-alive

import ratpack.handling.Context;
import ratpack.handling.Handler;
import ratpack.http.MutableHeaders;

public class CORSHandler implements Handler {
  @Override
  public void handle(Context ctx) throws Exception {
    MutableHeaders headers = ctx.getResponse().getHeaders();
    headers.set("Access-Control-Allow-Origin", "*");
    headers.set("Access-Control-Allow-Headers", "x-requested-with, origin, content-type, accept");

    ctx.next();
  }
}

import ratpack.server.RatpackServer;

public class App3 {
  public static void main(String[] args) throws Exception {
    RatpackServer.start(serverSpec -> serverSpec
      .handlers(chain -> chain
        .all(new CORSHandler()) (1)
        .get(ctx -> ctx.render("JEEConf 2016"))
      )
    );
  }
}

buildscript {
  repositories {
    jcenter()
  }
  dependencies {
    classpath 'com.h2database:h2:1.4.186'   (1)
    classpath 'org.jooq:jooq-codegen:3.8.1' (2)
  }
}

plugins {
  id 'io.ratpack.ratpack-java' version '1.3.3'
}

repositories {
  jcenter()
}

dependencies {
  compile ratpack.dependency('hikari') (3)
  compile 'com.h2database:h2:1.4.186' (4)
  compile 'org.jooq:jooq:3.8.1' (5)
}

DROP TABLE IF EXISTS todo;
CREATE TABLE todo (
  `id` bigint auto_increment primary key,
  `title` varchar(256),
  `completed` bool default false,
  `order` int default null
)

task jooqCodegen {
  doLast {
    String init = "$projectDir/src/main/resources/init.sql".replaceAll('\\\\', '/') (1)
    Configuration configuration = new Configuration()
      .withJdbc(new Jdbc()
      .withDriver("org.h2.Driver") (2)
      .withUrl("jdbc:h2:mem:todo;INIT=RUNSCRIPT FROM '$init'") (3)
    )
      .withGenerator(new Generator()
        .withDatabase(new Database()
          .withName("org.jooq.util.h2.H2Database")
          .withIncludes(".*")
          .withExcludes("")
          .withInputSchema("PUBLIC")
        )
      .withTarget(new Target()
        .withDirectory("$projectDir/src/main/java") (4)
        .withPackageName("jooq"))) (5)
    GenerationTool.generate(configuration)
  }
}

$ ./gradlew :example-03-database:jooqCodegen
:example-03-database:jooqCodegen

BUILD SUCCESSFUL

Total time: 0.985 secs

├───java
│   │   App.java
│   │
│   └───jooq
│       │   DefaultCatalog.java
│       │   Keys.java
│       │   Public.java
│       │   Sequences.java
│       │   Tables.java
│       │
│       └───tables
│           │   Todo.java (1)
│           │
│           └───records
│                   TodoRecord.java
│
└───resources
        init.sql (2)

import ratpack.guice.Guice;
import ratpack.hikari.HikariModule;
import ratpack.server.RatpackServer;

public class App {
  public static void main(String[] args) throws Exception {
    RatpackServer.start(serverSpec -> serverSpec
      .registry(Guice.registry(bindings -> bindings (1)
        .module(HikariModule.class, config -> { (2)
          config.setDataSourceClassName("org.h2.jdbcx.JdbcDataSource"); (3)
          config.addDataSourceProperty("URL", "jdbc:h2:mem:todo;INIT=RUNSCRIPT FROM 'classpath:/init.sql'"); (3)
        })
      ))
      .handlers(chain -> chain
        .get(ctx -> ctx.render("JEEConf 2016"))
      )
    );
  }
}

.get(ctx -> {
  DataSource ds = ctx.get(DataSource.class); (1)
  DSLContext create = DSL.using(ds, SQLDialect.H2); (2)
  List<Map<String, Object>> maps = create.select().from(Todo.TODO).fetch().intoMaps(); (3)
  ctx.render(Jackson.json(maps)); (4)
})

.get(ctx -> {
  DataSource ds = ctx.get(DataSource.class);
  DSLContext create = DSL.using(ds, SQLDialect.H2);
  SelectJoinStep<Record> from = create.select().from(Todo.TODO);
  Promise<List<Map<String, Object>>> promise = Blocking.get(() -> from.fetch().intoMaps()); (1)
  promise.then(maps -> ctx.render(Jackson.json(maps))); (2)
})

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;

public class TodoModel {
  public final Long id;
  public final String title;
  public final boolean completed;
  public final Integer order;
  private final String baseUrl;

  @JsonCreator
  public TodoModel(@JsonProperty("id") Long id,
              @JsonProperty("title") String title,
              @JsonProperty("completed") boolean completed,
              @JsonProperty("order") Integer order) {
    this(id, title, completed, order, null);
  }

  public TodoModel(Long id, String title, boolean completed, Integer order, String baseUrl) {
    this.id = id;
    this.title = title;
    this.completed = completed;
    this.order = order;
    this.baseUrl = baseUrl;
  }

  public TodoModel baseUrl(String baseUrl) {
    return new TodoModel(id, title, completed, order, baseUrl);
  }

  public String getUrl() {
    return baseUrl + "/" + id;
  }

}

private final DSLContext create;

public TodoRepository(DataSource ds) {
  this.create = DSL.using(ds, SQLDialect.H2);
}

public Promise<List<TodoModel>> getAll() {
  SelectJoinStep all = create.select().from(TODO);
  return Blocking.get(() -> all.fetchInto(TodoModel.class));
}

import com.google.inject.AbstractModule;
import com.google.inject.Provides;

import javax.inject.Singleton;
import javax.sql.DataSource;

public class TodoModule extends AbstractModule {
  @Override
  protected void configure() {}

  @Provides
  @Singleton
  TodoRepository todoRepository(DataSource ds) {
    return new TodoRepository(ds); (1)
  }
}

.module(TodoModule.class)

.get(ctx -> {
  TodoRepository repository = ctx.get(TodoRepository.class); (1)
  Promise<List<TodoModel>> todos = repository.getAll(); (2)
  todos.then(t -> ctx.render(Jackson.json(t))); (3)
})

.get(ctx -> {
  TodoRepository repository = ctx.get(TodoRepository.class);
  repository.getAll()
    .map(Jackson::json)
    .then(ctx::render);
})

import jooq.tables.records.TodoRecord;
import org.jooq.*;
import org.jooq.impl.DSL;
import ratpack.exec.Blocking;
import ratpack.exec.Operation;
import ratpack.exec.Promise;

import javax.sql.DataSource;
import java.util.List;
import java.util.Map;

import static jooq.tables.Todo.TODO;

public class TodoRepository2 {

  private final DSLContext create;

  public TodoRepository2(DataSource ds) {
    this.create = DSL.using(ds, SQLDialect.H2);
  }

  public Promise<List<TodoModel>> getAll() {
    SelectJoinStep all = create.select().from(TODO);
    return Blocking.get(() -> all.fetchInto(TodoModel.class));
  }

  public Promise<TodoModel> getById(Long id) {
    SelectConditionStep where = create.select().from(TODO).where(TODO.ID.equal(id));
    return Blocking.get(() -> where.fetchOne().into(TodoModel.class));
  }

  public Promise<TodoModel> add(TodoModel todo) {
    TodoRecord record = create.newRecord(TODO, todo);
    return Blocking.op(record::store)
      .next(Blocking.op(record::refresh))
      .map(() -> record.into(TodoModel.class));
  }

  public Promise<TodoModel> update(Map<String, Object> todo) {
    TodoRecord record = create.newRecord(TODO, todo);
    return Blocking.op(() -> create.executeUpdate(record))
      .next(Blocking.op(record::refresh))
      .map(() -> record.into(TodoModel.class));
  }

  public Operation delete(Long id) {
    DeleteConditionStep<TodoRecord> deleteWhereId = create.deleteFrom(TODO).where(TODO.ID.equal(id));
    return Blocking.op(deleteWhereId::execute);
  }

  public Operation deleteAll() {
    DeleteWhereStep<TodoRecord> delete = create.deleteFrom(TODO);
    return Blocking.op(delete::execute);
  }
}

import com.google.inject.AbstractModule;
import com.google.inject.Provides;

import javax.inject.Singleton;
import javax.sql.DataSource;

public class TodoModule2 extends AbstractModule {
  @Override
  protected void configure() {}

  @Provides
  @Singleton
  TodoRepository todoRepository(DataSource ds) {
    return new TodoRepository(ds);
  }
}

import ratpack.guice.Guice;
import ratpack.hikari.HikariModule;
import ratpack.jackson.Jackson;
import ratpack.server.RatpackServer;

public class App4 {
  public static void main(String[] args) throws Exception {
    RatpackServer.start(serverSpec -> serverSpec
      .registry(Guice.registry(bindings -> bindings
        .module(HikariModule.class, config -> {
          config.setDataSourceClassName("org.h2.jdbcx.JdbcDataSource");
          config.addDataSourceProperty("URL", "jdbc:h2:mem:todo;INIT=RUNSCRIPT FROM 'classpath:/init.sql'");
        })
        .module(TodoModule.class)
      ))
      .handlers(chain -> chain
          .get(ctx -> {
            TodoRepository repository = ctx.get(TodoRepository.class);
            repository.getAll()
              .map(Jackson::json)
              .then(ctx::render);
          })
      )
    );
  }
}

.post(ctx -> {
  Promise<TodoModel> todo = ctx.parse(Jackson.fromJson(TodoModel.class)); (1)
  todo.then(t -> ctx.render(t.title)); (2)
})

$ ./gradlew :example-05-json:demo -Papp=App (1)

$ curl -X POST -H 'Content-type: application/json' --data '{"title":"New Task"}' http://localhost:5050/
New Task

$ curl -X POST -H 'Content-type: application/json' --data '{"title":"Attend JEEConf 2016"}' http://localhost:5050/
Attend JEEConf 2016

.post(ctx -> {
  TodoRepository repository = ctx.get(TodoRepository.class); (1)
  Promise<TodoModel> todo = ctx.parse(Jackson.fromJson(TodoModel.class)); (2)
  todo
    .flatMap(repository::add) (3)
    .map(Jackson::json) (4)
    .then(ctx::render); (5)
})

$ ./gradlew :example-05-json:demo -Papp=App2

$ curl -X POST -H 'Content-type: application/json' --data '{"title":"New Task"}' http://localhost:5050/
{"id":1,"title":"New Task","completed":false,"order":null,"url":"null/1"}

$ curl -X POST -H 'Content-type: application/json' --data '{"title":"Attend JEEConf 2016"}' http://localhost:5050/
{"id":2,"title":"Attend JEEConf 2016","completed":false,"order":null,"url":"null/2"}

.get(ctx -> {
  TodoRepository repository = ctx.get(TodoRepository.class);
  repository.getAll()
    .map(Jackson::json)
    .then(ctx::render);
})
.post(ctx -> {
  TodoRepository repository = ctx.get(TodoRepository.class);
  Promise<TodoModel> todo = ctx.parse(Jackson.fromJson(TodoModel.class));
  todo
    .flatMap(repository::add)
    .map(Jackson::json)
    .then(ctx::render);
})

$ ./gradlew :example-05-json:demo -Papp=App3

$ curl http://localhost:5050/
[]

$ curl -X POST -H 'Content-type: application/json' --data '{"title":"Attend JEEConf 2016"}' --raw -v -s http://localhost:5050/
* timeout on name lookup is not supported
*   Trying ::1...
* Connected to localhost (::1) port 5050 (#0)
> POST / HTTP/1.1
> Host: localhost:5050
> User-Agent: curl/7.45.0
> Accept: */*
> Content-type: application/json
> Content-Length: 31
>
* upload completely sent off: 31 out of 31 bytes
< HTTP/1.1 405 Method Not Allowed (1)
< content-length: 0
< connection: close
<

.path(ctx -> { (1)
  TodoRepository repository = ctx.get(TodoRepository.class); (2)
  ctx.byMethod(method -> method (3)
      .get(() -> (4)
        repository.getAll()
          .map(Jackson::json)
          .then(ctx::render)
      )
      .post(() -> { (5)
        Promise<TodoModel> todo = ctx.parse(Jackson.fromJson(TodoModel.class));
        todo
          .flatMap(repository::add)
          .map(Jackson::json)
          .then(ctx::render);
      })
  );
})

$ ./gradlew :example-05-json:demo -Papp=App4

$ curl http://localhost:5050/
[]

$ curl -X POST -H 'Content-type: application/json' --data '{"title":"Attend JEEConf 2016"}' http://localhost:5050/
{"id":1,"title":"Attend JEEConf 2016","completed":false,"order":null,"url":"null/1"}

$ curl http://localhost:5050/
[{"id":1,"title":"Attend JEEConf 2016","completed":false,"order":null,"url":"null/1"}]

import ratpack.exec.Promise;
import ratpack.guice.Guice;
import ratpack.hikari.HikariModule;
import ratpack.http.Response;
import ratpack.jackson.Jackson;
import ratpack.server.RatpackServer;

public class App5 {
  public static void main(String[] args) throws Exception {
    RatpackServer.start(serverSpec -> serverSpec
      .registry(Guice.registry(bindings -> bindings
        .module(HikariModule.class, config -> {
          config.setDataSourceClassName("org.h2.jdbcx.JdbcDataSource");
          config.addDataSourceProperty("URL", "jdbc:h2:mem:todo;INIT=RUNSCRIPT FROM 'classpath:/init.sql'");
        })
        .module(TodoModule.class)
        .bindInstance(new CORSHandler()) (1)
      ))
      .handlers(chain -> chain
          .all(CORSHandler.class) (2)
          .path(ctx -> { (3)
            TodoRepository repository = ctx.get(TodoRepository.class);
            Response response = ctx.getResponse();
            ctx.byMethod(method -> method
                .options(() -> {
                  response.getHeaders().set("Access-Control-Allow-Methods", "OPTIONS, GET, POST, DELETE");
                  response.send();
                })
                .get(() ->
                  repository.getAll()
                    .map(Jackson::json)
                    .then(ctx::render)
                )
                .post(() -> {
                  Promise<TodoModel> todo = ctx.parse(Jackson.fromJson(TodoModel.class));
                  todo
                    .flatMap(repository::add)
                    .map(Jackson::json)
                    .then(ctx::render);
                })
                .delete(() -> repository.deleteAll().then(response::send))
            );
          })
      )
    );
  }
}

$ ./gradlew :example-05-json:demo -Papp=App5

$ curl http://localhost:5050/
[]

$ curl -X OPTIONS --raw -v -s http://localhost:5050/
* timeout on name lookup is not supported
*   Trying ::1...
* Connected to localhost (::1) port 5050 (#0)
> OPTIONS / HTTP/1.1
> Host: localhost:5050
> User-Agent: curl/7.45.0
> Accept: */*
>
< HTTP/1.1 200 OK
< Access-Control-Allow-Origin: *
< Access-Control-Allow-Headers: x-requested-with, origin, content-type, accept
< Access-Control-Allow-Methods: OPTIONS, GET, POST, DELETE
< content-length: 0
< connection: keep-alive
<

$ curl -X POST -H 'Content-type: application/json' --data '{"title":"Attend JEEConf 2016"}' http://localhost:5050/
{"id":1,"title":"Attend JEEConf 2016","completed":false,"order":null,"url":"null/1"}

$ curl http://localhost:5050/
[{"id":1,"title":"Attend JEEConf 2016","completed":false,"order":null,"url":"null/1"}]

$ curl -X DELETE http://localhost:5050/

$ curl http://localhost:5050/
[]

import ratpack.exec.Promise;
import ratpack.handling.Context;
import ratpack.handling.InjectionHandler;
import ratpack.http.Response;
import ratpack.jackson.Jackson;

public class TodoBaseHandler extends InjectionHandler { (1)
  public void handle (Context ctx, TodoRepository repository) throws Exception { (2)
    Response response = ctx.getResponse();
    ctx.byMethod(method -> method
      .options(() -> {
        response.getHeaders().set("Access-Control-Allow-Methods", "OPTIONS, GET, POST, DELETE");
        response.send();
      })
      .get(() ->
        repository.getAll()
          .map(Jackson::json)
          .then(ctx::render)
      )
      .post(() -> {
        Promise<TodoModel> todo = ctx.parse(Jackson.fromJson(TodoModel.class));
        todo
          .flatMap(repository::add)
          .map(Jackson::json)
          .then(ctx::render);
      })
      .delete(() -> repository.deleteAll().then(response::send))
    );
  }
}

import ratpack.func.Action;
import ratpack.handling.Chain;

public class TodoChain implements Action<Chain> {
  @Override
  public void execute(Chain chain) throws Exception {
    chain.path(TodoBaseHandler.class);
  }
}

import ratpack.guice.Guice;
import ratpack.hikari.HikariModule;
import ratpack.server.RatpackServer;

public class App {
  public static void main(String[] args) throws Exception {
    RatpackServer.start(serverSpec -> serverSpec
      .registry(Guice.registry(bindings -> bindings
        .module(HikariModule.class, config -> {
          config.setDataSourceClassName("org.h2.jdbcx.JdbcDataSource");
          config.addDataSourceProperty("URL", "jdbc:h2:mem:todo;INIT=RUNSCRIPT FROM 'classpath:/init.sql'");
        })
        .module(TodoModule.class)
        .bindInstance(new CORSHandler())
        .bindInstance(new TodoBaseHandler()) (1)
        .bindInstance(new TodoChain()) (2)
      ))
      .handlers(chain -> chain
          .all(CORSHandler.class)
          .insert(TodoChain.class) (3)
      )
    );
  }
}

import com.google.common.collect.Maps;
import com.google.common.reflect.TypeToken;
import ratpack.func.Function;
import ratpack.handling.Context;
import ratpack.handling.InjectionHandler;
import ratpack.http.Response;
import ratpack.jackson.Jackson;
import ratpack.jackson.JsonRender;

import java.util.Map;

public class TodoHandler extends InjectionHandler {
  public void handle(Context ctx, TodoRepository repo, String base) throws Exception {
    Long todoId = Long.parseLong(ctx.getPathTokens().get("id"));

    Function<TodoModel, TodoModel> hostUpdater = todo -> todo.baseUrl(base);
    Function<TodoModel, JsonRender> toJson = hostUpdater.andThen(Jackson::json);

    Response response = ctx.getResponse();

    ctx.byMethod(byMethodSpec -> byMethodSpec
      .options(() -> {
        response.getHeaders().set("Access-Control-Allow-Methods", "OPTIONS, GET, PATCH, DELETE");
        response.send();
      })
      .get(() -> repo.getById(todoId).map(toJson).then(ctx::render))
      .patch(() -> ctx
        .parse(Jackson.fromJson(new TypeToken<Map<String, Object>>() {}))
        .map(map -> {
          Map<String, Object> m = Maps.newHashMap();
          map.keySet().forEach(key -> m.put(key.toUpperCase(), map.get(key)));
          m.put("ID", todoId);
          return m;
        })
        .flatMap(repo::update)
        .map(toJson)
        .then(ctx::render)
      )
      .delete(() -> repo.delete(todoId).then(response::send))
    );
  }
}

import ratpack.func.Action;
import ratpack.handling.Chain;

public class TodoChain2 implements Action<Chain> {
  @Override
  public void execute(Chain chain) throws Exception {
    chain
      .path(TodoBaseHandler2.class)
      .path(":id", TodoHandler.class); (1)
  }
}

.bindInstance(new TodoHandler()) (1)

import ratpack.handling.Context;
import ratpack.handling.Handler;
import ratpack.http.MutableHeaders;
import ratpack.registry.Registry;

public class CORSHandler implements Handler {
  @Override
  public void handle(Context ctx) throws Exception {
    MutableHeaders headers = ctx.getResponse().getHeaders();
    headers.set("Access-Control-Allow-Origin", "*");
    headers.set("Access-Control-Allow-Headers", "x-requested-with, origin, content-type, accept");
    String baseUrl = "http://" + ctx.getRequest().getHeaders().get("Host"); (1)
    ctx.next(Registry.single(String.class, baseUrl)); (2)
  }
}

$ ./gradlew :example-06-evolution:demo -Papp=App2

$ curl http://localhost:5050/
[]

$ curl -X POST -H 'Content-type: application/json' --data '{"title":"Attend JEEConf 2016"}' http://localhost:5050/
{"id":1,"title":"Attend JEEConf 2016","completed":false,"order":null,"url":"http://localhost:5050/1"}

$ curl http://localhost:5050/
[{"id":1,"title":"Attend JEEConf 2016","completed":false,"order":null,"url":"http://localhost:5050/1"}]

$ curl http://localhost:5050/1
{"id":1,"title":"Attend JEEConf 2016","completed":false,"order":null,"url":"http://localhost:5050/1"}

$ curl -X PATCH -H 'Content-type: application/json' --data '{"completed": true}' http://localhost:5050/1
{"id":1,"title":"Attend JEEConf 2016","completed":true,"order":null,"url":"http://localhost:5050/1"}

$ curl http://localhost:5050/
[{"id":1,"title":"Attend JEEConf 2016","completed":true,"order":null,"url":"http://localhost:5050/1"}]

$ curl -X DELETE http://localhost:5050/1


$ curl http://localhost:5050/
[]

$ curl http://localhost:5050/1

plugins {
  id 'io.ratpack.ratpack-java' version '1.3.3'
  id 'com.github.johnrengelman.shadow' version '1.2.3' (1)
}

repositories {
  jcenter()
}

mainClassName = 'todobackend.ratpack.TodoApp' (2)

task stage(dependsOn: installShadowApp) (3)

web: build/installShadow/example-07-heroku/bin/example-07-heroku

$  heroku apps:create (1)
Creating app... done, stack is cedar-14
https://infinite-ridge-35787.herokuapp.com/ | https://git.heroku.com/infinite-ridge-35787.git

$ heroku git:remote --app infinite-ridge-35787  (2)
set git remote heroku to https://git.heroku.com/infinite-ridge-35787.git

$ git remote -v (3)
heroku  https://git.heroku.com/infinite-ridge-35787.git (fetch)
heroku  https://git.heroku.com/infinite-ridge-35787.git (push)

$ git push heroku master (4)

$ heroku logs -t (5)

$ curl https://infinite-ridge-35787.herokuapp.com/todo (6)
[]