support for null results (fixes albertlatacz#29)

Author: albertlatacz

src/javarepl/EvaluationTemplate.java

@@ -1,9 +1,10 @@
 package javarepl;
 
+import com.googlecode.totallylazy.Option;
+
 import static com.googlecode.totallylazy.Predicates.equalTo;
 import static com.googlecode.totallylazy.Predicates.where;
 import static javarepl.Result.functions.key;
-import static javarepl.Result.functions.value;
 
 @SuppressWarnings("unused")
 public abstract class EvaluationTemplate {
@@ -15,10 +16,12 @@ public EvaluationTemplate(EvaluationContext context) {
 
     @SuppressWarnings("unchecked")
     public final <T> T valueOf(final String key) {
-        return (T) context.results()
-                .filter(where(key(), equalTo(key)))
-                .map(value())
-                .headOption()
-                .getOrThrow(new IllegalArgumentException("Result '" + key + "' not found"));
+        Option<Result> result = context.results()
+                .find(where(key(), equalTo(key)));
+
+        if (result.isEmpty())
+            throw new IllegalArgumentException("Result '" + key + "' not found");
+
+        return (T) result.get().value();
     }
 }

src/javarepl/Evaluator.java

@@ -3,6 +3,8 @@
 import com.googlecode.totallylazy.*;
 import com.googlecode.totallylazy.annotations.multimethod;
 import javarepl.expressions.*;
+import javarepl.expressions.Method;
+import javarepl.expressions.Type;
 import javarepl.expressions.Value;
 
 import javax.tools.DiagnosticCollector;
@@ -11,8 +13,7 @@
 import javax.tools.StandardJavaFileManager;
 import java.io.File;
 import java.io.FileNotFoundException;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
+import java.lang.reflect.*;
 import java.net.URL;
 import java.util.regex.MatchResult;
 
@@ -97,8 +98,13 @@ private Import createImport(String expression) {
     }
 
     private AssignmentWithType createAssignmentWithType(String expression) {
-        MatchResult match = Patterns.assignmentWithTypeNamePattern.match(expression);
-        return new AssignmentWithType(expression, match.group(1), match.group(2), match.group(3));
+        try {
+            MatchResult match = Patterns.assignmentWithTypeNamePattern.match(expression);
+            java.lang.reflect.Method declaredMethod = detectMethod(match.group(1) + " " + randomIdentifier("method") + "(){}");
+            return new AssignmentWithType(expression, declaredMethod.getReturnType(), match.group(2), match.group(3));
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
     }
 
     private Assignment createAssignmentExpression(String expression) {
@@ -154,7 +160,7 @@ public final Option<Class> typeOfExpression(String expression) {
         if (evaluation.isRight()) {
             Option<Result> result = evaluation.right().result();
             if (!result.isEmpty()) {
-                expressionType = some((Class) result.get().value().getClass());
+                expressionType = some((Class) result.get().type());
             }
         }
 
@@ -214,23 +220,25 @@ private Either<? extends Throwable, Evaluation> evaluate(Type expression) {
 
     private Method createMethodExpression(String expression) {
         try {
-            final String className = randomIdentifier("Method");
-            final File outputJavaFile = file(outputDirectory, className + ".java");
-
-            final String sources = renderMethodSignatureDetection(context, className, expression);
-            Files.write(sources.getBytes(), outputJavaFile);
+            java.lang.reflect.Method declaredMethod = detectMethod(expression);
+            return new Method(expression, declaredMethod.getReturnType(), declaredMethod.getName(), sequence(declaredMethod.getParameterTypes()));
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
 
-            compile(outputJavaFile);
+    private java.lang.reflect.Method detectMethod(String expression) throws Exception {
+        final String className = randomIdentifier("Method");
+        final File outputJavaFile = file(outputDirectory, className + ".java");
 
-            Class<?> expressionClass = classLoader.loadClass(className);
+        final String sources = renderMethodSignatureDetection(context, className, expression);
+        Files.write(sources.getBytes(), outputJavaFile);
 
-            java.lang.reflect.Method declaredMethod = expressionClass.getDeclaredMethods()[0];
+        compile(outputJavaFile);
 
-            return new Method(expression, declaredMethod.getReturnType(), declaredMethod.getName(), sequence(declaredMethod.getParameterTypes()));
+        Class<?> expressionClass = classLoader.loadClass(className);
 
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
+        return expressionClass.getDeclaredMethods()[0];
     }
 
     private Either<? extends Throwable, Evaluation> evaluateExpression(final Expression expression) {
@@ -252,12 +260,13 @@ private Either<? extends Throwable, Evaluation> evaluateExpression(final Express
 
             final Object expressionInstance = constructor.newInstance(newContext);
 
-            Object resultObject = expressionClass.getMethod("evaluate").invoke(expressionInstance);
+            java.lang.reflect.Method method = expressionClass.getMethod("evaluate");
+            Object resultObject = method.invoke(expressionInstance);
 
             Sequence<Result> modifiedResults = modifiedResults(expressionInstance);
 
-            if (resultObject != null) {
-                Result result = Result.result(nextResultKeyFor(expression), resultObject);
+            if (resultObject != null || !method.getReturnType().equals(void.class)) {
+                Result result = Result.result(nextResultKeyFor(expression), resultObject, typeFor(expression));
                 context = newContext.addExpression(expression).addResults(modifiedResults.add(result)).lastSource(sources);
                 return right(evaluation(expression, some(result)));
             } else {
@@ -294,6 +303,12 @@ private String nextResultKeyFor(Expression expression) {
                 : expression.key();
     }
 
+    private Option<Class<?>> typeFor(Expression expression) {
+        return (expression instanceof AssignmentWithType)
+            ? Option.<Class<?>>some(((AssignmentWithType) expression).type())
+            : Option.<Class<?>>none();
+    }
+
     private void compile(File file) throws Exception {
         String classpath = sequence(System.getProperty("java.class.path")).join(sequence(classLoader.getURLs()).map(toString)).toString(pathSeparator);
         JavaCompiler compiler = getSystemJavaCompiler();

src/javarepl/Result.java

@@ -10,14 +10,19 @@
 public class Result {
     private final String key;
     private final Object value;
+    private final Option<Class<?>> type;
 
-    private Result(String key, Object value) {
+    private Result(String key, Object value, Option<Class<?>> type) {
         this.key = key;
         this.value = value;
+        this.type = type;
     }
 
+    public static Result result(String key, Object value, Option<Class<?>> type) {
+        return new Result(key, value, type);
+    }
     public static Result result(String key, Object value) {
-        return new Result(key, value);
+        return result(key, value, Option.<Class<?>>none());
     }
 
     public String key() {
@@ -28,13 +33,16 @@ public Object value() {
         return value;
     }
 
+    public Class<?> type() {
+        return type.getOrElse(value != null ? value.getClass() : Object.class);
+    }
+
     public static Option<Result> noResult() {
         return none();
     }
 
     public String toString(boolean canonical) {
-        Class<?> type = extractType(value.getClass());
-        return (canonical ? type.getCanonicalName() : type.getSimpleName()) + " " + key + " = " + renderValue(value);
+        return (canonical ? type().getCanonicalName() : type().getSimpleName()) + " " + key + " = " + renderValue(value);
     }
 
     @Override
@@ -59,15 +67,23 @@ public static final class functions {
         public static Mapper<Result, String> key() {
             return new Mapper<Result, String>() {
                 public String call(Result result) throws Exception {
-                    return result.key;
+                    return result.key();
                 }
             };
         }
 
         public static Mapper<Result, Object> value() {
             return new Mapper<Result, Object>() {
                 public Object call(Result result) throws Exception {
-                    return result.value;
+                    return result.value();
+                }
+            };
+        }
+
+        public static Mapper<Result, Class<?>> type() {
+            return new Mapper<Result, Class<?>>() {
+                public Class<?> call(Result result) throws Exception {
+                    return result.type();
                 }
             };
         }

src/javarepl/Utils.java

@@ -34,6 +34,14 @@ public static String randomIdentifier(String prefix) {
         return prefix + "$" + takeFromValues(characters("abcdefghijklmnopqrstuvwxyz1234567890")).take(20).toString("");
     }
 
+    public static Class<?> extractType(Object object) {
+        if (object == null) {
+            return Object.class;
+        } else {
+            return extractType(object.getClass());
+        }
+    }
+
     public static Class<?> extractType(Class<?> clazz) {
         if (clazz.isAnonymousClass()) {
             if (clazz.getSuperclass().equals(Object.class)) {
@@ -84,7 +92,6 @@ public static String applicationVersion() {
                 JarInputStream jarStream = new JarInputStream(new FileInputStream(path));
                 Manifest manifest = jarStream.getManifest();
                 return manifest.getMainAttributes().getValue("Implementation-Version");
-
             }
         } catch (Exception e) {
             // ignore

src/javarepl/console/commands/EvaluateFile.java

@@ -26,7 +26,6 @@ public void execute(String expression) {
             for (String line : Strings.lines(resolveURL(path).openStream())) {
                 EvaluateExpression.evaluate(evaluator, logger, line);
             }
-            ;
 
             logger.success(format("Finished evaluating %s", path));
         } catch (Exception e) {

src/javarepl/expressions/AssignmentWithType.java

@@ -1,11 +1,11 @@
 package javarepl.expressions;
 
 public final class AssignmentWithType extends Expression {
-    private final String type;
+    private final Class<?> type;
     private final String key;
     private final String value;
 
-    public AssignmentWithType(String source, String type, String key, String value) {
+    public AssignmentWithType(String source, Class<?> type, String key, String value) {
         super(source);
 
         this.type = type;
@@ -17,7 +17,7 @@ public String key() {
         return key;
     }
 
-    public String type() {
+    public Class<?> type() {
         return type;
     }
 

src/javarepl/rendering/EvaluationClassRenderer.java

@@ -140,7 +140,7 @@ private static String render(EvaluationContext context, String className, Expres
     private static String renderPreviousEvaluations(EvaluationContext context) {
         return context.results().map(new Mapper<Result, String>() {
             public String call(Result result) throws Exception {
-                return format("  public %s %s = valueOf(\"%s\");", extractType(result.value().getClass()).getCanonicalName(), result.key(), result.key());
+                return format("  public %s %s = valueOf(\"%s\");", result.type().getCanonicalName(), result.key(), result.key());
             }
         }).toString("\n");
     }

src/javarepl/rendering/ExpressionTokenRenderer.java

@@ -48,10 +48,10 @@ private static String renderExpressionToken(Import expression) {
     }
 
     private static String expressionWithValue(String value) {
-        return expressionWithValue(value, "Object");
+        return expressionWithValue(value, Object.class);
     }
 
-    private static String expressionWithValue(String value, String returnType) {
-        return format("    %s %s =\n\n    %s;\n\n    return %s;", returnType, EXPRESSION_VALUE, EXPRESSION_TOKEN, EXPRESSION_VALUE);
+    private static String expressionWithValue(String value, Class<?> returnType) {
+        return format("    %s %s =\n\n    %s;\n\n    return %s;", returnType.getCanonicalName(), EXPRESSION_VALUE, EXPRESSION_TOKEN, EXPRESSION_VALUE);
     }
 }

src/javarepl/rendering/MethodNameRenderer.java

@@ -15,22 +15,22 @@ public static String renderMethodName(Expression expression) {
 
     @multimethod
     private static String renderMethodName(Statement expression) {
-        return methodNameWithType("void");
+        return methodNameWithType(void.class);
     }
 
     @multimethod
     private static String renderMethodName(Import expression) {
-        return methodNameWithType("void");
+        return methodNameWithType(void.class);
     }
 
     @multimethod
     private static String renderMethodName(Method expression) {
-        return methodNameWithType("void");
+        return methodNameWithType(void.class);
     }
 
     @multimethod
     private static String renderMethodName(Assignment expression) {
-        return methodNameWithType("Object");
+        return methodNameWithType(Object.class);
     }
 
     @multimethod
@@ -40,10 +40,10 @@ private static String renderMethodName(AssignmentWithType expression) {
 
     @multimethod
     private static String renderMethodName(Value expression) {
-        return methodNameWithType("Object");
+        return methodNameWithType(Object.class);
     }
 
-    private static String methodNameWithType(String returnType) {
-        return format("  public %s evaluate() throws Exception {", returnType);
+    private static String methodNameWithType(Class<?> returnType) {
+        return format("  public %s evaluate() throws Exception {", returnType.getCanonicalName());
     }
 }

test/javarepl/EvaluatorTest.java

@@ -40,6 +40,7 @@ public void shouldEvaluateExpressions() {
         assertThat(evaluating("class NewClass {public int field=20;}"), hasNoResult());
         assertThat(evaluating("class NewClass {public int field=20;}", "new NewClass().field"), hasResult(20));
         assertThat(evaluating("int max(int a, int b) { return a > b ? a : b; }", "max(20, 30)"), hasResult(30));
+        assertThat(evaluating("String res = null", "res"), hasResult(null));
     }
 
     @Test