Merge pull request #1 from SimonRichardson/meltdown

Updating to purescript 0.7.0

Author: garyb

.travis.yml

@@ -1,13 +1,15 @@
 language: node_js
+sudo: false
 node_js:
   - 0.10
 env:
-  - TAG=v0.6.9.3
+  - TAG=v0.7.0 PATH=$HOME/bin:$PATH
 install:
+  - mkdir $HOME/bin
   - wget -O $HOME/purescript.tar.gz https://github.com/purescript/purescript/releases/download/$TAG/linux64.tar.gz
-  - sudo tar zxvf $HOME/purescript.tar.gz -C /usr/local/bin purescript/psc{,i,-docs,-make} --strip-components=1
-  - sudo chmod a+x /usr/local/bin/psc{,i,-docs,-make}
+  - tar zxvf $HOME/purescript.tar.gz -C $HOME/bin purescript/psc{,i,-docs,-bundle,-publish} --strip-components=1
+  - chmod a+x $HOME/bin/psc{,i,-docs,-bundle,-publish}
   - npm install bower gulp -g
   - npm install && bower install
 script:
-  - gulp
+  - gulp

bower.json

@@ -17,10 +17,12 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-string-parsers": "~0.4.1",
-    "purescript-pathy": "~0.1.3",
-    "purescript-maps": "~0.3.4",
-    "purescript-integers": "~0.1.0",
-    "purescript-globals": "~0.1.6"
+    "purescript-string-parsers":  "^0.5.0",
+    "purescript-pathy":           "^0.2.0",
+    "purescript-arrays":          "^0.4.0",
+    "purescript-lists":           "^0.7.0",
+    "purescript-maps":            "^0.4.0",
+    "purescript-integers":        "^0.2.0",
+    "purescript-globals":         "^0.2.0"
   }
 }

gulpfile.js

@@ -1,53 +1,34 @@
+/* jshint node: true */
 "use strict";
 
-var gulp = require("gulp");
-var plumber = require("gulp-plumber");
-var purescript = require("gulp-purescript");
-var jsvalidate = require("gulp-jsvalidate");
-var run = require("gulp-run");
+var gulp = require("gulp"),
+    purescript = require("gulp-purescript"),
+    run = require("gulp-run"),
 
-var paths = [
-  "src/**/*.purs",
-  "bower_components/purescript-*/src/**/*.purs",
-  "test/**/*.purs"
-];
+    sources = [
+      "src/**/*.purs",
+      "bower_components/purescript-*/src/**/*.purs",
+      "test/**/*.purs"
+    ],
+
+    foreigns = [
+      "src/**/*.js",
+      "bower_components/purescript-*/src/**/*.js",
+      "test/**/*.js"
+    ];
 
 gulp.task("make", function() {
-  return gulp.src(paths)
-    .pipe(plumber())
-    .pipe(purescript.pscMake());
+  return purescript.psc({ src: sources, ffi: foreigns });
 });
 
-gulp.task("jsvalidate", ["make"], function () {
-  return gulp.src("output/**/*.js")
-    .pipe(plumber())
-    .pipe(jsvalidate());
+gulp.task("test", ["make"], function() {
+  return purescript.pscBundle({ src: "output/**/*.js", main: "Test.Main" })
+    .pipe(run("node"));
 });
 
-var docTasks = [];
-
-var docTask = function(name) {
-  var taskName = "docs-" + name.toLowerCase();
-  gulp.task(taskName, function () {
-    return gulp.src("src/" + name.replace(/\./g, "/") + ".purs")
-      .pipe(plumber())
-      .pipe(purescript.pscDocs())
-      .pipe(gulp.dest("docs/" + name + ".md"));
-  });
-  docTasks.push(taskName);
-};
-
-["Data.URI", "Data.URI.Authority", "Data.URI.Common", "Data.URI.Host",
- "Data.URI.Path", "Data.URI.Query", "Data.URI.Scheme", "Data.URI.Types",
- "Data.URI.UserInfo"].forEach(docTask);
-
-gulp.task("docs", docTasks);
-
-gulp.task("test", function() {
-  return gulp.src(paths)
-    .pipe(plumber())
-    .pipe(purescript.psc({ main: "Test.Main" }))
-    .pipe(run("node"));
+gulp.task("dotpsci", function () {
+  return purescript.psci({ src: sources, ffi: foreigns })
+    .pipe(gulp.dest("."));
 });
 
-gulp.task("default", ["jsvalidate", "docs", "test"]);
+gulp.task("default", ["test", "dotpsci"]);

package.json

@@ -1,10 +1,12 @@
 {
+  "name"    : "purescript-uri",
   "private": true,
   "devDependencies": {
+    "ioredis": "1.1.x",
     "gulp": "^3.8.11",
-    "gulp-jsvalidate": "^1.0.1",
-    "gulp-plumber": "^1.0.0",
-    "gulp-purescript": "^0.3.1",
-    "gulp-run": "^1.6.7"
+    "gulp-jscs": "^1.6.0",
+    "gulp-jshint": "^1.11.2",
+    "gulp-purescript": "^0.5.0",
+    "gulp-run": "^1.6.8"
   }
-}
+}

src/Data/URI.purs

@@ -1,11 +1,11 @@
 module Data.URI where
 
+import Prelude
 import Control.Alt ((<|>))
 import Control.Apply ((<*), (*>))
 import Data.Array (catMaybes)
 import Data.Either (Either(..), either)
 import Data.Maybe (Maybe(..))
-import Data.String (joinWith)
 import Data.URI.Authority
 import Data.URI.Common
 import Data.URI.Fragment
@@ -17,6 +17,7 @@ import Data.URI.Query
 import Data.URI.Scheme
 import Data.URI.Types
 import Data.URI.UserInfo
+import qualified Data.String as S
 import Text.Parsing.StringParser (Parser(), ParseError(), runParser, try)
 import Text.Parsing.StringParser.Combinators (optionMaybe)
 import Text.Parsing.StringParser.String (string, eof)
@@ -61,22 +62,22 @@ printURIRef = either printURI printRelativeRef
 
 printURI :: URI -> String
 printURI (URI s h q f) =
-  joinWith "" $ catMaybes [ printScheme <$> s
-                          , Just (printHierPart h)
-                          , printQuery <$> q
-                          , ("#" ++ ) <$> f
-                          ]
+  S.joinWith "" $ catMaybes [ printScheme <$> s
+                            , Just (printHierPart h)
+                            , printQuery <$> q
+                            , ("#" ++ ) <$> f
+                            ]
 
 printAbsoluteURI :: AbsoluteURI -> String
 printAbsoluteURI (AbsoluteURI s h q) =
-  joinWith "" $ catMaybes [ printScheme <$> s
-                          , Just (printHierPart h)
-                          , printQuery <$> q
-                          ]
+  S.joinWith "" $ catMaybes [ printScheme <$> s
+                            , Just (printHierPart h)
+                            , printQuery <$> q
+                            ]
 
 printRelativeRef :: RelativeRef -> String
 printRelativeRef (RelativeRef h q f) =
-  joinWith "" $ catMaybes [ Just (printRelativePart h)
-                          , printQuery <$> q
-                          , ("#" ++ ) <$> f
-                          ]
+  S.joinWith "" $ catMaybes [ Just (printRelativePart h)
+                            , printQuery <$> q
+                            , ("#" ++ ) <$> f
+                            ]

src/Data/URI/Authority.purs

@@ -1,16 +1,18 @@
 module Data.URI.Authority where
 
+import Prelude
 import Control.Apply ((*>))
 import Data.Array (catMaybes)
 import Data.Int (fromNumber, toNumber)
 import Data.Maybe (Maybe(..), maybe)
-import Data.String (joinWith)
 import Data.Tuple(Tuple(..))
+import Data.List (List(..), fromList)
 import Data.URI.Common
 import Data.URI.Host
 import Data.URI.Types
 import Data.URI.UserInfo
 import Global (readInt, isNaN)
+import qualified Data.String as S
 import Text.Parsing.StringParser (Parser(), fail)
 import Text.Parsing.StringParser.Combinators (optionMaybe, sepBy1)
 import Text.Parsing.StringParser.String (string)
@@ -20,19 +22,18 @@ parseAuthority = do
   ui <- optionMaybe parseUserInfo
   hosts <- flip sepBy1 (string ",") $ Tuple <$> parseHost
                                             <*> optionMaybe (string ":" *> parsePort)
-  return $ Authority ui hosts
+  return $ Authority ui (fromList hosts)
 
 parsePort :: Parser Port
 parsePort = do
-  s <- rxPat "[0-9]+"
-  let n = readInt 10 s
-  if isNaN n && show n == s
-    then fail "Expected valid port number"
-    else pure (fromNumber n)
+ s <- rxPat "[0-9]+"
+ case fromNumber $ readInt 10 s of
+    Just x  -> pure x
+    _       -> fail "Expected valid port number"
 
 printAuthority :: Authority -> String
 printAuthority (Authority u hs) =
   "//" ++ maybe "" (++ "@") u
-       ++ joinWith "," (printHostAndPort <$> hs)
+       ++ S.joinWith "," (printHostAndPort <$> hs)
   where
-  printHostAndPort (Tuple h p) = printHost h ++ maybe "" (\n -> ":" ++ show (toNumber n)) p
+  printHostAndPort (Tuple h p) = printHost h ++ maybe "" (\n -> ":" ++ show n) p

src/Data/URI/Common.purs

@@ -1,17 +1,22 @@
 module Data.URI.Common where
 
+import Prelude
 import Control.Alt ((<|>))
-import Control.Monad (replicateM)
+import Data.Array (replicateM)
+import Data.List (List(..), fromList)
 import Data.Function (Fn5(), runFn5)
 import Data.Maybe (Maybe(..))
-import Data.String (joinWith, length)
+import qualified Data.String as S
 import Data.URI.Types
 import Text.Parsing.StringParser (Parser(..), ParseError(..), unParser)
 import Text.Parsing.StringParser.String (string)
 import qualified Data.String.Regex as Rx
 
-rep :: Number -> Parser String -> Parser String
-rep n p = joinWith "" <$> replicateM n p
+joinWith :: String -> List String -> String
+joinWith x y = S.joinWith x $ fromList y
+
+rep :: Int -> Parser String -> Parser String
+rep n p = S.joinWith "" <$> replicateM n p
 
 rxPat :: String -> Parser String
 rxPat rx = anyMatch $ Rx.regex rx (Rx.noFlags { ignoreCase = true })
@@ -39,22 +44,10 @@ parseSubDelims = rxPat "[!$&'()*+;=]"
 
 anyMatch :: Rx.Regex -> Parser String
 anyMatch rx = Parser \{ str: str, pos: i } fc sc -> case match1From rx i str of
-  Just m -> sc m { str: str, pos: i + (length m) }
+  Just m -> sc m { str: str, pos: i + (S.length m) }
   Nothing -> fc i (ParseError $ "Expected " ++ show rx)
 
-match1From :: Rx.Regex -> Number -> String -> Maybe String
-match1From rx i str = runFn5 match1FromImpl Just Nothing rx i str
-
-foreign import match1FromImpl
-  """
-  function match1FromImpl(just, nothing, rx, i, str) {
-    var rxStr = rx.toString();
-    var flagIndex = rxStr.lastIndexOf("/");
-    var pattern = rxStr.substring(1, flagIndex);
-    var flags = rxStr.substring(flagIndex + 1);
-    rx = new RegExp(pattern, flags.indexOf("g") === -1 ? flags + "g" : flags);
-    rx.lastIndex = i;
-    var result = rx.exec(str);
-    return result && result.index === i ? just(result[0]) : nothing;
-  }
-  """ :: forall a. Fn5 (a -> Maybe a) (Maybe a) Rx.Regex Number String (Maybe String)
+match1From :: Rx.Regex -> Int -> String -> Maybe String
+match1From rx i str = runFn5 _match1From Just Nothing rx i str
+
+foreign import _match1From :: forall a. Fn5 (a -> Maybe a) (Maybe a) Rx.Regex Int String (Maybe String)

src/Data/URI/Fragment.purs

@@ -1,7 +1,7 @@
 module Data.URI.Fragment where
 
+import Prelude
 import Control.Alt ((<|>))
-import Data.String (joinWith)
 import Data.URI.Common
 import Data.URI.Types
 import Text.Parsing.StringParser (Parser(), try)

src/Data/URI/HierarchicalPart.purs

@@ -1,14 +1,15 @@
 module Data.URI.HierarchicalPart where
 
+import Prelude
 import Control.Alt ((<|>))
 import Control.Apply ((*>))
 import Data.Array (catMaybes)
 import Data.Maybe (Maybe(..))
-import Data.String (joinWith)
 import Data.URI.Authority
 import Data.URI.Common
 import Data.URI.Path
 import Data.URI.Types
+import qualified Data.String as S
 import Text.Parsing.StringParser (Parser())
 import Text.Parsing.StringParser.Combinators (optionMaybe)
 import Text.Parsing.StringParser.String (string)
@@ -21,6 +22,6 @@ parseHierarchicalPart = (HierarchicalPart <$> optionMaybe (string "//" *> parseA
 
 printHierPart :: HierarchicalPart -> String
 printHierPart (HierarchicalPart a p) =
-  joinWith "" $ catMaybes [ printAuthority <$> a
-                          , printPath <$> p
-                          ]
+  S.joinWith "" $ catMaybes [ printAuthority <$> a
+                            , printPath <$> p
+                            ]

src/Data/URI/Host.purs

@@ -1,11 +1,13 @@
 module Data.URI.Host where
 
+import Prelude
 import Control.Alt ((<|>))
 import Control.Apply ((*>), (<*))
 import Data.Array (length)
-import Data.String (joinWith)
+import Data.List (fromList)
 import Data.URI.Common
 import Data.URI.Types
+import qualified Data.String as S
 import Text.Parsing.StringParser (Parser(), try)
 import Text.Parsing.StringParser.Combinators ((<?>), many1, sepBy1)
 import Text.Parsing.StringParser.String (string)
@@ -22,7 +24,7 @@ parseIPv4Address :: Parser Host
 parseIPv4Address = IPv4Address <$> rxPat pattern <?> "IPv4 address"
   where
   pattern :: String
-  pattern = joinWith "" ["(", octet, "\\.", octet, "\\.", octet, "\\.", octet, ")"]
+  pattern = S.joinWith "" ["(", octet, "\\.", octet, "\\.", octet, "\\.", octet, ")"]
   octet :: String
   octet = "(1[0-9]{2}|[1-9][0-9]|[0-9]|2[0-4][0-9]|25[0-5])"