Support experimental option to compile to Scala 2.10

framework/src/console/src/main/scala/Console.scala

@@ -20,13 +20,13 @@ object Console {
            ||  __/|_|\____|\__ (_)
            ||_|            |__/
            |
-           |""".stripMargin) + ("play! " + play.core.PlayVersion.current + ", http://www.playframework.org")
+           |""".stripMargin) + ("play! " + play.core.PlayVersion.current + " (using Scala " + play.core.PlayVersion.scalaVersion + "), http://www.playframework.org")
 
   // -- Commands
 
   def replace(file: File, tokens: (String, String)*) {
     if (file.exists) {
-      Path(file).write(tokens.foldLeft(Path(file).slurpString) { (state, token) =>
+      Path(file).write(tokens.foldLeft(Path(file).string) { (state, token) =>
         state.replace("%" + token._1 + "%", token._2)
       })
     }

framework/src/play-exceptions/src/main/java/play/api/PlayException.java

@@ -0,0 +1,159 @@
+package play.api;
+
+import java.io.*;
+import java.util.*;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Helper for `PlayException`.
+ */
+public class PlayException extends UsefulException {
+
+    private final AtomicLong generator = new AtomicLong(System.currentTimeMillis());
+
+    /**
+     * Generates a new unique exception ID.
+     */
+    private String nextId() { 
+        return java.lang.Long.toString(generator.incrementAndGet(), 26);
+    }
+
+    public PlayException(String title, String description, Throwable cause) {
+        super(title + "[" + description + "]",cause);
+        this.title = title;
+        this.description = description;
+        this.id = nextId();
+        this.cause = cause;
+    }
+
+    public PlayException(String title, String description) {
+        super(title + "[" + description + "]");
+        this.title = title;
+        this.description = description;
+        this.id = nextId();
+        this.cause = null;
+    }
+
+    /**
+     * Adds source attachment to a Play exception.
+     */
+    public static abstract class ExceptionSource extends PlayException {
+
+        public ExceptionSource(String title, String description, Throwable cause) {
+          super(title, description,cause);
+        }
+
+        public ExceptionSource(String title, String description) {
+          super(title, description);
+        }
+
+        /**
+         * Error line number, if defined.
+         */
+        public abstract Integer line();
+
+        /**
+         * Column position, if defined.
+         */
+        public abstract Integer position();
+
+        /**
+         * Input stream used to read the source content.
+         */
+        public abstract String input();
+
+        /**
+         * The source file name if defined.
+         */
+        public abstract String sourceName();
+
+        /**
+         * Extracts interesting lines to be displayed to the user.
+         *
+         * @param border number of lines to use as a border
+         */
+        public InterestingLines interestingLines(int border) {
+            try {
+                if(input() == null || line() == null) {
+                    return null;
+                }
+                String[] lines = input().split("\n");
+                int firstLine = Math.max(0, line() - border);
+                int lastLine = Math.min(lines.length - 1, line() + border);
+                List<String> focusOn = new ArrayList<String>();
+                for(int i = firstLine; i <= lastLine; i++) {
+                    focusOn.add(lines[i]);
+                }
+                return new InterestingLines(firstLine + 1, focusOn.toArray(new String[focusOn.size()]), line() - firstLine - 1);
+            } catch(Throwable e) {
+                e.printStackTrace();
+                return null;
+            }
+        }
+
+        public String toString() {
+            return super.toString() + " in " + sourceName() + ":" + line();
+        }
+    }
+
+    /**
+     * Adds any attachment to a Play exception.
+     */
+    public static abstract class ExceptionAttachment extends PlayException {
+
+        public ExceptionAttachment(String title, String description, Throwable cause) {
+            super(title, description, cause);
+        }
+
+        public ExceptionAttachment(String title, String description) {
+            super(title, description);
+        }
+
+        /**
+         * Content title.
+         */
+        public abstract String subTitle(); 
+
+        /**
+         * Content to be displayed.
+         */
+        public abstract String content();
+
+    }
+
+    /**
+     * Adds a rich HTML description to a Play exception.
+     */
+    public static abstract class RichDescription extends ExceptionAttachment {
+
+        public RichDescription(String title, String description, Throwable cause) {
+            super(title, description, cause);
+        }
+
+        public RichDescription(String title, String description) {
+            super(title, description);
+        }
+
+        /**
+         * The new description formatted as HTML.
+         */
+        public abstract String htmlDescription();
+
+    }
+
+    public static class InterestingLines {
+
+        public final int firstLine;
+        public final int errorLine;
+        public final String[] focus;
+
+        public InterestingLines(int firstLine, String[] focus, int errorLine){
+            this.firstLine = firstLine;
+            this.errorLine = errorLine;
+            this.focus = focus;
+        }
+
+    }
+
+}

framework/src/play-exceptions/src/main/java/play/api/UsefulException.java

@@ -0,0 +1,40 @@
+package play.api;
+
+/**
+* A UsefulException is something useful to display in the User browser.
+*/
+public abstract class UsefulException extends RuntimeException {
+
+    /**
+     * Exception title.
+     */
+    public String title;
+
+    /**
+     * Exception description.
+     */
+    public String description; 
+
+    /**
+     * Exception cause if defined.
+     */
+    public Throwable cause;
+
+    /**
+     * Unique id for this exception.
+     */
+    public String id;
+
+    public UsefulException(String message, Throwable cause) {
+      super(message, cause);
+    }
+
+    public UsefulException(String message) {
+      super(message);
+    }
+
+    public String toString() {
+        return "@" + id + ": " + title;
+    }
+
+} 

framework/src/play/src/main/scala/play/api/Application.scala

@@ -52,10 +52,11 @@ trait WithDefaultGlobal {
       javaGlobal.map(new j.JavaGlobalSettingsAdapter(_)).getOrElse(scalaGlobal)
     } catch {
       case e: PlayException => throw e
-      case e => throw PlayException(
+      case e => throw new PlayException(
         "Cannot init the Global object",
         e.getMessage,
-        Some(e))
+        e
+      )
     }
   }
 
@@ -76,6 +77,7 @@ trait WithDefaultConfiguration {
   }
 
   def configuration: Configuration = fullConfiguration
+
 }
 
 trait WithDefaultPlugins {
@@ -92,7 +94,7 @@ trait WithDefaultPlugins {
     val pluginFiles = self.classloader.getResources("play.plugins").asScala.toList ++ self.classloader.getResources("conf/play.plugins").asScala.toList
 
     pluginFiles.distinct.map { plugins =>
-      (plugins.asInput.slurpString.split("\n").map(_.trim)).filterNot(_.isEmpty).map {
+      (plugins.asInput.string.split("\n").map(_.trim)).filterNot(_.isEmpty).map {
         case PluginDeclaration(priority, className) => (priority.toInt, className)
       }
     }.flatten.sortBy(_._1).map(_._2)
@@ -133,21 +135,21 @@ trait WithDefaultPlugins {
             if (plugin.enabled) Some(plugin) else { Logger("play").warn("Plugin [" + className + "] is disabled"); None }
           } catch {
             case e: PlayException => throw e
-            case e => throw PlayException(
+            case e => throw new PlayException(
               "Cannot load plugin",
               "Plugin [" + className + "] cannot been instantiated.",
-              Some(e))
+              e)
           }
         }
-        case e: InvocationTargetException => throw PlayException(
+        case e: InvocationTargetException => throw new PlayException(
           "Cannot load plugin",
           "An exception occurred during Plugin [" + className + "] initialization",
-          Some(e.getTargetException))
+          e.getTargetException)
         case e: PlayException => throw e
-        case e => throw PlayException(
+        case e => throw new PlayException(
           "Cannot load plugin",
           "Plugin [" + className + "] cannot been instantiated.",
-          Some(e))
+          e)
       }
     }.flatten
 
@@ -262,19 +264,19 @@ trait Application {
    */
   private[play] def handleError(request: RequestHeader, e: Throwable): Result = try {
     e match {
-      case e: PlayException.UsefulException => throw e
+      case e: UsefulException => throw e
       case e: Throwable => {
 
         val source = sources.flatMap(_.sourceFor(e))
 
-        throw new PlayException(
+        throw new PlayException.ExceptionSource(
           "Execution exception",
           "[%s: %s]".format(e.getClass.getSimpleName, e.getMessage),
-          Some(e)) with PlayException.ExceptionSource {
-          def line = source.map(_._2)
-          def position = None
-          def input = source.map(_._1).map(scalax.file.Path(_))
-          def sourceName = source.map(_._1.getAbsolutePath)
+          e) {
+          def line = source.flatMap(_._2).map(_.asInstanceOf[java.lang.Integer]).orNull
+          def position = null
+          def input = source.map(_._1).map(scalax.file.Path(_).string).orNull
+          def sourceName = source.map(_._1.getAbsolutePath).orNull
         }
       }
     }
@@ -288,8 +290,8 @@ trait Application {
           case p: PlayException => "@" + p.id + " - "
           case _ => ""
         }, request.method, request.uri),
-        e)
-
+        e
+      )
       global.onError(request, e)
     } catch {
       case e => DefaultGlobal.onError(request, e)
@@ -413,4 +415,4 @@ class DefaultApplication(
   override val classloader: ClassLoader,
   override val sources: Option[SourceMapper],
   override val mode: Mode.Mode
-) extends Application with WithDefaultConfiguration with WithDefaultGlobal with WithDefaultPlugins
+) extends Application with WithDefaultConfiguration with WithDefaultGlobal with WithDefaultPlugins

framework/src/play/src/main/scala/play/api/Configuration.scala

@@ -68,11 +68,11 @@ object Configuration {
 
   private def configError(origin: ConfigOrigin, message: String, e: Option[Throwable] = None): PlayException = {
     import scalax.io.JavaConverters._
-    new PlayException("Configuration error", message, e) with PlayException.ExceptionSource {
-      def line = Option(origin.lineNumber)
-      def position = None
-      def input = Option(origin.url).map(_.asInput)
-      def sourceName = Option(origin.filename)
+    new PlayException.ExceptionSource("Configuration error", message, e.orNull) {
+      def line = Option(origin.lineNumber:java.lang.Integer).orNull
+      def position = null
+      def input = Option(origin.url).map(_.asInput.string).orNull
+      def sourceName = Option(origin.filename).orNull
       override def toString = "Configuration error: " + getMessage
     }
   }