API Change: Delete Locals (Request and Session will be affected) fix #60

Author: jknack

jooby-hbs/src/main/java/org/jooby/internal/hbs/RequestValueResolver.java

@@ -22,38 +22,38 @@
 import java.util.Map.Entry;
 import java.util.Set;
 
-import org.jooby.Locals;
+import org.jooby.Request;
 
 import com.github.jknack.handlebars.ValueResolver;
 
 /**
- * Handlebars value resolver for accessing to {@link Locals}, like request and session objects.
+ * Handlebars value resolver for accessing to {@link Request}, like request and session objects.
  *
  * @author edgar
  */
-public class LocalsValueResolver implements ValueResolver {
+public class RequestValueResolver implements ValueResolver {
 
   @Override
   public Object resolve(final Object context, final String name) {
     Object value = null;
-    if (context instanceof Locals) {
-      value = ((Locals) context).get(name).orElse(null);
+    if (context instanceof Request) {
+      value = ((Request) context).get(name).orElse(null);
     }
     return value == null ? UNRESOLVED : value;
   }
 
   @Override
   public Object resolve(final Object context) {
-    if (context instanceof Locals) {
+    if (context instanceof Request) {
       return context;
     }
     return UNRESOLVED;
   }
 
   @Override
   public Set<Entry<String, Object>> propertySet(final Object context) {
-    if (context instanceof Locals) {
-      return ((Locals) context).attributes().entrySet();
+    if (context instanceof Request) {
+      return ((Request) context).attributes().entrySet();
     }
     return Collections.emptySet();
   }

jooby-hbs/src/main/java/org/jooby/internal/hbs/SessionValueResolver.java

@@ -0,0 +1,64 @@
+/**
+ * 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.internal.hbs;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.jooby.Session;
+
+import com.github.jknack.handlebars.ValueResolver;
+
+/**
+ * Handlebars value resolver for accessing to {@link Session}, like request and session objects.
+ *
+ * @author edgar
+ */
+public class SessionValueResolver implements ValueResolver {
+
+  @Override
+  public Object resolve(final Object context, final String name) {
+    Object value = null;
+    if (context instanceof Session) {
+      value = ((Session) context).get(name).toOptional().orElse(null);
+    }
+    return value == null ? UNRESOLVED : value;
+  }
+
+  @Override
+  public Object resolve(final Object context) {
+    if (context instanceof Session) {
+      return context;
+    }
+    return UNRESOLVED;
+  }
+
+  @SuppressWarnings({"unchecked", "rawtypes" })
+  @Override
+  public Set<Entry<String, Object>> propertySet(final Object context) {
+    if (context instanceof Session) {
+      Map session = ((Session) context).attributes();
+      return session.entrySet();
+    }
+    return Collections.emptySet();
+  }
+
+}

jooby-hbs/src/test/java/org/jooby/internal/hbs/RequestValueResolverTest.java

@@ -10,92 +10,91 @@
 import java.util.Optional;
 import java.util.Set;
 
-import org.jooby.Locals;
 import org.jooby.MockUnit;
-import org.jooby.internal.hbs.LocalsValueResolver;
+import org.jooby.Request;
 import org.junit.Test;
 
 import com.github.jknack.handlebars.ValueResolver;
 
-public class LocalsValueResolverTest {
+public class RequestValueResolverTest {
 
   @Test
   public void resolveProperty() throws Exception {
-    new MockUnit(Locals.class)
+    new MockUnit(Request.class)
         .expect(unit -> {
-          Locals locals = unit.get(Locals.class);
-          expect(locals.get("prop")).andReturn(Optional.of("x"));
+          Request Request = unit.get(Request.class);
+          expect(Request.get("prop")).andReturn(Optional.of("x"));
         })
         .run(unit -> {
-          assertEquals("x", new LocalsValueResolver().resolve(unit.get(Locals.class), "prop"));
+          assertEquals("x", new RequestValueResolver().resolve(unit.get(Request.class), "prop"));
         });
   }
 
   @Test
   public void resolveMissingProperty() throws Exception {
-    new MockUnit(Locals.class)
+    new MockUnit(Request.class)
         .expect(unit -> {
-          Locals locals = unit.get(Locals.class);
-          expect(locals.get("prop")).andReturn(Optional.empty());
+          Request Request = unit.get(Request.class);
+          expect(Request.get("prop")).andReturn(Optional.empty());
         })
         .run(
             unit -> {
               assertEquals(ValueResolver.UNRESOLVED,
-                  new LocalsValueResolver().resolve(unit.get(Locals.class), "prop"));
+                  new RequestValueResolver().resolve(unit.get(Request.class), "prop"));
             });
   }
 
   @Test
-  public void skipNoLocals() throws Exception {
-    new MockUnit(Locals.class)
+  public void skipNoRequest() throws Exception {
+    new MockUnit(Request.class)
         .run(
             unit -> {
               assertEquals(ValueResolver.UNRESOLVED,
-                  new LocalsValueResolver().resolve(new Object(), "prop"));
+                  new RequestValueResolver().resolve(new Object(), "prop"));
             });
   }
 
   @Test
   public void resolveContext() throws Exception {
-    new MockUnit(Locals.class)
+    new MockUnit(Request.class)
         .run(unit -> {
-          assertEquals(unit.get(Locals.class),
-              new LocalsValueResolver().resolve(unit.get(Locals.class)));
+          assertEquals(unit.get(Request.class),
+              new RequestValueResolver().resolve(unit.get(Request.class)));
         });
   }
 
   @Test
-  public void resolveNoLocals() throws Exception {
+  public void resolveNoRequest() throws Exception {
     new MockUnit()
         .run(unit -> {
           assertEquals(ValueResolver.UNRESOLVED,
-              new LocalsValueResolver().resolve(new Object()));
+              new RequestValueResolver().resolve(new Object()));
         });
   }
 
   @SuppressWarnings("unchecked")
   @Test
   public void propertySet() throws Exception {
     Set<Entry<String, Object>> entries = new HashSet<>();
-    new MockUnit(Locals.class)
+    new MockUnit(Request.class)
         .expect(unit -> {
-          Locals locals = unit.get(Locals.class);
+          Request Request = unit.get(Request.class);
           Map<String, Object> attributes = unit.mock(Map.class);
-          expect(locals.attributes()).andReturn(attributes);
+          expect(Request.attributes()).andReturn(attributes);
           expect(attributes.entrySet()).andReturn(entries);
         })
         .run(unit -> {
           assertEquals(entries,
-              new LocalsValueResolver().propertySet(unit.get(Locals.class)));
+              new RequestValueResolver().propertySet(unit.get(Request.class)));
         });
   }
 
   @Test
   public void propertySetAnything() throws Exception {
-    new MockUnit(Locals.class)
+    new MockUnit(Request.class)
         .run(unit -> {
           assertEquals(Collections.emptySet(),
-              new LocalsValueResolver().propertySet(new Object()));
+              new RequestValueResolver().propertySet(new Object()));
         });
   }
 

jooby-hbs/src/test/java/org/jooby/internal/hbs/SessionValueResolverTest.java

@@ -0,0 +1,107 @@
+package org.jooby.internal.hbs;
+
+import static org.easymock.EasyMock.expect;
+import static org.junit.Assert.assertEquals;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.Set;
+
+import org.jooby.MockUnit;
+import org.jooby.Mutant;
+import org.jooby.Session;
+import org.junit.Test;
+
+import com.github.jknack.handlebars.ValueResolver;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Maps;
+
+public class SessionValueResolverTest {
+
+  @Test
+  public void resolveProperty() throws Exception {
+    new MockUnit(Session.class)
+        .expect(unit -> {
+          Session session = unit.get(Session.class);
+          Mutant v = unit.mock(Mutant.class);
+          expect(v.toOptional()).andReturn(Optional.of("x"));
+          expect(session.get("prop")).andReturn(v);
+        })
+        .run(unit -> {
+          assertEquals("x", new SessionValueResolver().resolve(unit.get(Session.class), "prop"));
+        });
+  }
+
+  @Test
+  public void resolveMissingProperty() throws Exception {
+    new MockUnit(Session.class)
+        .expect(unit -> {
+          Session session = unit.get(Session.class);
+          Mutant v = unit.mock(Mutant.class);
+          expect(v.toOptional()).andReturn(Optional.empty());
+          expect(session.get("prop")).andReturn(v);
+        })
+        .run(
+            unit -> {
+              assertEquals(ValueResolver.UNRESOLVED,
+                  new SessionValueResolver().resolve(unit.get(Session.class), "prop"));
+            });
+  }
+
+  @Test
+  public void skipSession() throws Exception {
+    new MockUnit(Session.class)
+        .run(
+            unit -> {
+              assertEquals(ValueResolver.UNRESOLVED,
+                  new SessionValueResolver().resolve(new Object(), "prop"));
+            });
+  }
+
+  @Test
+  public void resolveContext() throws Exception {
+    new MockUnit(Session.class)
+        .run(unit -> {
+          assertEquals(unit.get(Session.class),
+              new SessionValueResolver().resolve(unit.get(Session.class)));
+        });
+  }
+
+  @Test
+  public void resolveNoSession() throws Exception {
+    new MockUnit()
+        .run(unit -> {
+          assertEquals(ValueResolver.UNRESOLVED,
+              new SessionValueResolver().resolve(new Object()));
+        });
+  }
+
+  @Test
+  public void propertySet() throws Exception {
+    Map<String, String> attributes = ImmutableMap.of("k", "v");
+    Set<Entry<String, Object>> entries = ImmutableSet.of(Maps.immutableEntry("k", "v"));
+    new MockUnit(Session.class)
+        .expect(unit -> {
+          Session Rsession = unit.get(Session.class);
+
+          expect(Rsession.attributes()).andReturn(attributes);
+        })
+        .run(unit -> {
+          assertEquals(entries,
+              new SessionValueResolver().propertySet(unit.get(Session.class)));
+        });
+  }
+
+  @Test
+  public void propertySetAnything() throws Exception {
+    new MockUnit(Session.class)
+        .run(unit -> {
+          assertEquals(Collections.emptySet(),
+              new SessionValueResolver().propertySet(new Object()));
+        });
+  }
+
+}

jooby/src/main/java/org/jooby/Mutant.java

@@ -73,6 +73,13 @@ default byte byteValue() {
     return to(byte.class);
   }
 
+  /**
+   * @return Get a byte when possible.
+   */
+  default char charValue() {
+    return to(char.class);
+  }
+
   /**
    * @return Get a short when possible.
    */