Avoid pipes

.travis.yml

@@ -1,3 +1,15 @@
-language: node_js
-node_js:
-  - "0.12"
+sudo: false
+
+env:
+  matrix:
+    - ELM_VERSION=0.16.0 TARGET_NODE_VERSION=node
+    - ELM_VERSION=0.16.0 TARGET_NODE_VERSION=0.12
+
+install:
+  - nvm install $TARGET_NODE_VERSION
+  - nvm use $TARGET_NODE_VERSION
+  - node --version
+  - npm --version
+  - npm install -g elm@$ELM_VERSION
+
+script: ./ci.sh

BuildFromSource.hs

@@ -0,0 +1,164 @@
+{-| This script builds any version of the Elm Platform from source.
+Before you use it, make sure you have the Haskell Platform with a recent
+version of cabal.
+
+To install a released version of Elm, you will run something like this:
+
+    runhaskell BuildFromSource.hs 0.15.1
+
+Before you do that, in some directory of your choosing, add
+wherever/Elm-Platform/0.15.1/.cabal-sandbox/bin to your PATH.
+
+Then, run the above. You will now actually have a new directory for the
+Elm Platform, like this:
+
+    Elm-Platform/0.15.1/
+        elm-make/        -- git repo for the build tool, ready to edit
+        elm-repl/        -- git repo for the REPL, ready to edit
+        ...
+        .cabal-sandbox/  -- various build files
+
+All of the executables you need are in .cabal-sandbox/bin, which is on
+your PATH and thus can be used from anywhere.
+
+You can build many versions of the Elm Platform, so it is possible to have
+Elm-Platform/0.15.1/ and Elm-Platform/0.13/ with no problems. It is up to you
+to manage your PATH variable or symlinks though.
+
+To get set up with the master branch of all Elm Platform projects, run this:
+
+    runhaskell BuildFromSource.hs master
+
+From there you can start developing on any of the projects, switching branches
+and testing interactions between projects.
+-}
+module Main where
+
+import qualified Data.List          as List
+import qualified Data.Map           as Map
+import           System.Directory   (createDirectoryIfMissing,
+                                     getCurrentDirectory, setCurrentDirectory)
+import           System.Environment (getArgs)
+import           System.Exit        (ExitCode, exitFailure)
+import           System.FilePath    ((</>))
+import           System.IO          (hPutStrLn, stderr)
+import           System.Process     (rawSystem)
+
+
+(=:) = (,)
+
+configs :: Map.Map String [(String, String)]
+configs =
+  Map.fromList
+    [
+      "master" =:
+        [ "elm-compiler" =: "master"
+        , "elm-package"  =: "master"
+        , "elm-make"     =: "master"
+        , "elm-reactor"  =: "master"
+        , "elm-repl"     =: "master"
+        ]
+    ,
+      "0.15.1" =:
+        [ "elm-compiler" =: "0.15.1"
+        , "elm-package"  =: "0.5.1"
+        , "elm-make"     =: "0.2"
+        ]
+    ,
+      "0.15" =:
+        [ "elm-compiler" =: "0.15"
+        , "elm-package"  =: "0.5"
+        , "elm-make"     =: "0.1.2"
+        , "elm-reactor"  =: "0.3.1"
+        , "elm-repl"     =: "0.4.1"
+        ]
+    ,
+      "0.14.1" =:
+        [ "elm-compiler" =: "0.14.1"
+        , "elm-package"  =: "0.4"
+        , "elm-make"     =: "0.1.1"
+        , "elm-reactor"  =: "0.3"
+        , "elm-repl"     =: "0.4"
+        ]
+    ,
+      "0.14" =:
+        [ "elm-compiler" =: "0.14"
+        , "elm-package"  =: "0.2"
+        , "elm-make"     =: "0.1"
+        , "elm-reactor"  =: "0.2"
+        , "elm-repl"     =: "0.4"
+        ]
+    ,
+      "0.13" =:
+        [ "Elm"         =: "0.13"
+        , "elm-reactor" =: "0.1"
+        , "elm-repl"    =: "0.3"
+        , "elm-get"     =: "0.1.3"
+        ]
+    ,
+      "0.12.3" =:
+        [ "Elm"        =: "0.12.3"
+        , "elm-server" =: "0.11.0.1"
+        , "elm-repl"   =: "0.2.2.1"
+        , "elm-get"    =: "0.1.2"
+        ]
+    ]
+
+
+main :: IO ()
+main =
+ do args <- getArgs
+    case args of
+      [version] | Map.member version configs ->
+          let artifactDirectory = "Elm-Platform" </> version
+              repos = configs Map.! version
+          in
+              makeRepos artifactDirectory version repos
+
+      _ ->
+        do hPutStrLn stderr $
+               "Expecting one of the following values as an argument:\n" ++
+               "    " ++ List.intercalate ", " (Map.keys configs)
+           exitFailure
+
+
+makeRepos :: FilePath -> String -> [(String, String)] -> IO ()
+makeRepos artifactDirectory version repos =
+ do createDirectoryIfMissing True artifactDirectory
+    setCurrentDirectory artifactDirectory
+    root <- getCurrentDirectory
+    mapM_ (uncurry (makeRepo root)) repos
+
+    cabal [ "update" ]
+
+    -- create a sandbox for installation
+    cabal [ "sandbox", "init" ]
+
+    -- add each of the sub-directories as a sandbox source
+    cabal ([ "sandbox", "add-source" ] ++ map fst repos)
+
+    -- install all of the packages together in order to resolve transitive dependencies robustly
+    -- (install the dependencies a bit more quietly than the elm packages)
+    cabal ([ "install", "-j", "--only-dependencies", "--ghc-options=\"-w\"" ] ++ (if version <= "0.15.1" then [ "--constraint=fsnotify<0.2" ] else []) ++ map fst repos)
+    cabal ([ "install", "-j", "--ghc-options=\"-XFlexibleContexts\"" ] ++ filter (/= "elm-reactor") (map fst repos))
+
+    return ()
+
+makeRepo :: FilePath -> String -> String -> IO ()
+makeRepo root projectName version =
+  do  -- get the right version of the repo
+    git [ "clone", "https://github.com/elm-lang/" ++ projectName ++ ".git" ]
+    setCurrentDirectory projectName
+    git [ "checkout", version, "--quiet" ]
+
+    -- move back into the root
+    setCurrentDirectory root
+
+
+-- HELPER FUNCTIONS
+
+cabal :: [String] -> IO ExitCode
+cabal = rawSystem "cabal"
+
+git :: [String] -> IO ExitCode
+git = rawSystem "git"

bin/elm-test

@@ -2,7 +2,7 @@
 
 var processTitle = "elm-test"
 
-process.title = 'elm-test';
+process.title = processTitle;
 
 var compile    = require("node-elm-compiler").compile,
   suffix       = require("../elm-io-ports.js"),
@@ -12,7 +12,16 @@ var compile    = require("node-elm-compiler").compile,
   util         = require("util"),
   _            = require("lodash"),
   childProcess = require("child_process"),
-  elm          = require("elm");
+  findup       = require("findup-sync");
+
+var elm = {
+  'elm-package': 'elm-package'
+};
+
+if (process.argv[2] == "--version") {
+  console.log(require(path.join(__dirname, "..", "package.json")).version);
+  process.exit(0);
+}
 
 if (process.argv[2] == "init") {
   var copyTemplate = function(templateName) {
@@ -33,15 +42,17 @@ if (process.argv[2] == "init") {
       childProcess.execSync(elm["elm-package"] + " " + command + elmOptions, {stdio:[0,1,2]});
   }
 
-  execElmPackageSync("install deadfoxygrandpa/Elm-Test");
-  execElmPackageSync("install maxsnew/IO");
+  copyTemplate("elm-package.json");
+  execElmPackageSync("install deadfoxygrandpa/elm-test");
+  execElmPackageSync("install laszlopandy/elm-console");
   copyTemplate("TestRunner.elm");
   copyTemplate("Tests.elm");
   process.exit(0);
 }
 
-var testFile   = process.argv[2],
-    cwd        = __dirname;
+var testFile = process.argv[2],
+    cwd = __dirname,
+    pathToMake = undefined;
 
 function spawnCompiler(cmd, args, opts) {
   var compilerOpts = _.defaults({stdio: ["inherit", "pipe", "inherit"]}, opts);
@@ -51,7 +62,7 @@ function spawnCompiler(cmd, args, opts) {
 
 if (typeof testFile !== "string") {
   console.log("Usage: elm-test init [--yes]  # Create example tests\n");
-  console.log("Usage: elm-test TESTFILE  # Run tests\n");
+  console.log("Usage: elm-test TESTFILE [--compiler /path/to/compiler] # Run tests\n");
   process.exit(1);
 }
 
@@ -60,18 +71,27 @@ if (!fs.existsSync(testFile)) {
   process.exit(1);
 }
 
-temp.open('elm_test_', function(err, info) {
-  var dest = info.path;
-  var compileProcess = compile([testFile], {output: dest, spawn: spawnCompiler});
+if (process.argv[3] == "--compiler" || process.argv[3] == "-c") {
+  pathToMake = process.argv[4];
 
-  console.log("Compiling", testFile);
+  if (!pathToMake) {
+    console.error("The --compiler option must be given a path to an elm-make executable.");
+    process.exit(1);
+  }
+}
+
+temp.open({ prefix:'elm_test_', suffix:'.js' }, function(err, info) {
+  var dest = info.path;
+  var compileProcess = compile( [testFile],
+    {output: dest, spawn: spawnCompiler, pathToMake: pathToMake});
 
   compileProcess.stdout.setEncoding("utf8")
   compileProcess.stdout.on("data", function(data) {
     // Explicitly strip out the "Successfully generated" message.
     // This avoids the nasty compiler output message for the temp file, e.g.
     // "Successfully generated /var/folders/f2/afd9fg0acfg32/elm_test_3423940"
-    if ((typeof data === "string") && !data.match(/^Successfully generated /)) {
+    // Also strip out "Success! Compiled 1 module."
+    if ((typeof data === "string") && !/^Success/.test(data)) {
       console.log(data);
     }
   });
@@ -83,23 +103,24 @@ temp.open('elm_test_', function(err, info) {
 
     console.log("Successfully compiled", testFile);
 
-    var runnerOpts = {stdio: ["pipe", "inherit", "inherit"]};
-    var runnerProcess = childProcess.spawn("node", [], runnerOpts);
-
-    runnerProcess.on('exit', function (exitCode) {
-      process.exit(exitCode);
-    });
+    // append suffix to temp file
+    fs.appendFile(dest, suffix, function(err){
+      if (err) throw(err);
 
-    var reader = fs.createReadStream(dest);
+      console.log("Bootstrapped test script")
 
-    reader.on("end", function() {
-      runnerProcess.stdin.write(suffix);
+      // add node_modules to NODE_PATH so the temporary file can require
+      // local modules
+      var pathToNodeModules = findup("node_modules");
+      process.env.NODE_PATH = _.compact([process.env.NODE_PATH, pathToNodeModules]).join(':');
 
-      runnerProcess.stdin.end();
-    })
+      var runnerProcess = childProcess.spawn("node", [dest], {stdio: 'inherit'});
 
-    reader.pipe(runnerProcess.stdin);
+      runnerProcess.on('exit', function (exitCode) {
+        process.exit(exitCode);
+      });
 
-    console.log("Running tests...");
+      console.log("Running tests...");
+    });
   });
 });

ci.sh

@@ -2,31 +2,48 @@
 
 set -e
 
+function assertTestFailure() {
+  elm-package install --yes
+  elm-test "$1" | tee "$1".test.log
+  if test ${PIPESTATUS[0]} -ne 1; then
+    echo "$0: ERROR: $1: Expected tests to fail" >&2
+    exit 1
+  fi
+}
+
+function assertTestSuccess() {
+  elm-package install --yes
+  elm-test "$1" | tee "$1".test.log
+  if test ${PIPESTATUS[0]} -ne 0; then
+    echo "$0: ERROR: $1: Expected tests to pass" >&2
+    exit 1
+  fi
+}
+
 echo "$0: Installing elm-test..."
 npm install --global
 
+echo "$0: Verifying installed elm-test version..."
+elm-test --version
+
+echo "$0: Testing examples..."
+cd examples
+assertTestSuccess PassingTests.elm
+assertTestFailure FailingTests.elm
+cd ..
+
 echo "$0: Testing elm-test init..."
-mkdir tmp
+mkdir -p tmp
 cd tmp
 elm-test init --yes
-elm-test TestRunner.elm | tee test.log
-if test ${PIPESTATUS[0]} -ne 1; then
-  echo "$0: ERROR: Expected example tests to fail" >&2
-  exit 1
-fi
+assertTestFailure TestRunner.elm
+# delete the failing tests and the comma on the preceding line
+ex -c 'g/should fail/' -c 'd' -c 'g-1' -c 's/,$//' -c 'wq' Tests.elm
+rm -Rf elm-stuff
+assertTestSuccess TestRunner.elm
 cd ..
 rm -Rf tmp
 
-echo "$0: Testing examples..."
-cd examples
-elm-package install --yes
-elm-test Test.elm | tee test.log
-if test ${PIPESTATUS[0]} -ne 1; then
-  echo "$0: ERROR: Expected example tests to fail" >&2
-  exit 1
-fi
-cd ..
-
 echo ""
 echo "$0: Everything looks good!"
 echo "                                                            "