Add optional argument factory, fix #46

Author: jknack

jooby-jdbc/src/main/java/org/jooby/jdbc/Jdbc.java

@@ -114,7 +114,7 @@
  * <h2>hikari configuration</h2>
  * <p>
  * If you need to configure or tweak the <a
- * href="https://github.com/brettwooldridge/HikariCP">hikari poll</a> just add <code>hikari.*</code>
+ * href="https://github.com/brettwooldridge/HikariCP">hikari pool</a> just add <code>hikari.*</code>
  * entries to your <code>application.conf</code> file:
  * </p>
  *

jooby-jdbi/src/main/java/org/jooby/jdbi/Jdbi.java

@@ -45,7 +45,7 @@
  * module.
  * </p>
  *
- * <h1>Getting Started</h1>
+ * <h1>usage</h1>
  *
  * <p>
  * It is pretty straightforward:
@@ -67,8 +67,12 @@
  *   });
  * }
  * </pre>
+ * <p>
+ * A call to <code>req.require(Handle.class)</code> is the same as:
+ * <code>req.require(DBI.class).open(Handle.class)</code>.
+ * </p>
  *
- * <h1>Working with SQL Objects</h1>
+ * <h1>sql objects</h1>
  *
  * <p>
  * It is pretty straightforward (too):
@@ -105,7 +109,7 @@
  * }
  * </pre>
  *
- * <h1>Configuration</h1>
+ * <h1>configuration</h1>
  * <p>
  * If you need to configure and/or customize a {@link DBI} instance, just do:
  * </p>
@@ -152,6 +156,8 @@ public void configure(final Env env, final Config config, final Binder binder) {
 
     DBI dbi = new DBI(() -> dataSource().get().getConnection());
     dbi.setSQLLog(new SLF4JLog());
+    dbi.registerArgumentFactory(new OptionalArgumentFactory());
+    dbi.registerContainerFactory(new OptionalContainerFactory());
 
     keys(DBI.class, key -> binder.bind(key).toInstance(dbi));
 

jooby-jdbi/src/main/java/org/jooby/jdbi/OptionalArgumentFactory.java

@@ -0,0 +1,29 @@
+package org.jooby.jdbi;
+
+import java.sql.Types;
+import java.util.Optional;
+
+import org.skife.jdbi.v2.StatementContext;
+import org.skife.jdbi.v2.tweak.Argument;
+import org.skife.jdbi.v2.tweak.ArgumentFactory;
+
+class OptionalArgumentFactory implements ArgumentFactory<Optional<?>> {
+
+  @Override
+  public boolean accepts(final Class<?> expectedType, final Object value, final StatementContext ctx) {
+    return value instanceof Optional;
+  }
+
+  @Override
+  public Argument build(final Class<?> expectedType, final Optional<?> value,
+      final StatementContext sctx) {
+    return (pos, stmt, ctx) -> {
+      if (value.isPresent()) {
+        stmt.setObject(pos, value.get());
+      } else {
+        stmt.setNull(pos, Types.OTHER);
+      }
+    };
+  }
+
+}

jooby-jdbi/src/main/java/org/jooby/jdbi/OptionalContainerFactory.java

@@ -0,0 +1,58 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.jooby.jdbi;
+
+import java.util.Optional;
+
+import org.skife.jdbi.v2.ContainerBuilder;
+import org.skife.jdbi.v2.tweak.ContainerFactory;
+
+class OptionalContainerFactory implements ContainerFactory<Optional<?>> {
+
+  @Override
+  public boolean accepts(final Class<?> type) {
+    return Optional.class.isAssignableFrom(type);
+  }
+
+  @Override
+  public ContainerBuilder<Optional<?>> newContainerBuilderFor(final Class<?> type) {
+    return optional();
+  }
+
+  private static ContainerBuilder<Optional<?>> optional() {
+    return new ContainerBuilder<Optional<?>>() {
+
+      private Optional<?> value = Optional.empty();
+
+      @Override
+      public Optional<?> build() {
+        return value;
+      }
+
+      @Override
+      public ContainerBuilder<Optional<?>> add(final Object it) {
+        value = Optional.ofNullable(it);
+        return this;
+      }
+    };
+  }
+
+
+
+}

jooby-jdbi/src/test/java/org/jooby/jdbi/OptionaArgumentFactoryTest.java

@@ -0,0 +1,54 @@
+package org.jooby.jdbi;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.sql.PreparedStatement;
+import java.sql.Types;
+import java.util.Optional;
+
+import org.jooby.MockUnit;
+import org.junit.Test;
+import org.skife.jdbi.v2.StatementContext;
+import org.skife.jdbi.v2.tweak.Argument;
+
+public class OptionaArgumentFactoryTest {
+
+  @Test
+  public void accepts() {
+    assertTrue(new OptionalArgumentFactory().accepts(Optional.class, Optional.empty(), null));
+    assertFalse(new OptionalArgumentFactory().accepts(Optional.class, new Object(), null));
+  }
+
+  @Test
+  public void empty() throws Exception {
+    new MockUnit(StatementContext.class, PreparedStatement.class)
+        .expect(unit -> {
+          PreparedStatement stmt = unit.get(PreparedStatement.class);
+          stmt.setNull(1, Types.OTHER);
+        })
+        .run(unit -> {
+          Argument arg = new OptionalArgumentFactory()
+              .build(Optional.class, Optional.empty(), unit.get(StatementContext.class));
+          assertNotNull(arg);
+          arg.apply(1, unit.get(PreparedStatement.class), unit.get(StatementContext.class));
+        });
+  }
+
+  @Test
+  public void value() throws Exception {
+    new MockUnit(StatementContext.class, PreparedStatement.class)
+        .expect(unit -> {
+          PreparedStatement stmt = unit.get(PreparedStatement.class);
+          stmt.setObject(1, "x");
+        })
+        .run(unit -> {
+          Argument arg = new OptionalArgumentFactory()
+              .build(Optional.class, Optional.of("x"), unit.get(StatementContext.class));
+          assertNotNull(arg);
+          arg.apply(1, unit.get(PreparedStatement.class), unit.get(StatementContext.class));
+        });
+  }
+
+}

jooby-jdbi/src/test/java/org/jooby/jdbi/OptionalContainerFactoryTest.java

@@ -0,0 +1,33 @@
+package org.jooby.jdbi;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Optional;
+
+import org.junit.Test;
+import org.skife.jdbi.v2.ContainerBuilder;
+
+public class OptionalContainerFactoryTest {
+
+  @Test
+  public void accepts() {
+    assertTrue(new OptionalContainerFactory().accepts(Optional.class));
+    assertFalse(new OptionalContainerFactory().accepts(Object.class));
+  }
+
+  @Test
+  public void newContainerBuilderFor() {
+    ContainerBuilder<Optional<?>> cb = new OptionalContainerFactory()
+        .newContainerBuilderFor(Optional.class);
+    assertNotNull(cb);
+    assertEquals(Optional.empty(), cb.build());
+
+    cb.add("x");
+
+    assertEquals(Optional.of("x"), cb.build());
+  }
+
+}